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 "test/unittests/compiler/node-test-utils.h"
6
7 #include <vector>
8
9 #include "src/assembler.h"
10 #include "src/compiler/common-operator.h"
11 #include "src/compiler/js-operator.h"
12 #include "src/compiler/node-properties.h"
13 #include "src/compiler/simplified-operator.h"
14 #include "src/handles-inl.h"
15 #include "src/objects.h"
16
17 using testing::_;
18 using testing::MakeMatcher;
19 using testing::MatcherInterface;
20 using testing::MatchResultListener;
21 using testing::StringMatchResultListener;
22
23 namespace v8 {
24 namespace internal {
25
operator ==(Handle<HeapObject> const & lhs,Handle<HeapObject> const & rhs)26 bool operator==(Handle<HeapObject> const& lhs, Handle<HeapObject> const& rhs) {
27 return lhs.is_identical_to(rhs);
28 }
29
30 namespace compiler {
31
32 namespace {
33
34 template <typename T>
PrintMatchAndExplain(const T & value,const std::string & value_name,const Matcher<T> & value_matcher,MatchResultListener * listener)35 bool PrintMatchAndExplain(const T& value, const std::string& value_name,
36 const Matcher<T>& value_matcher,
37 MatchResultListener* listener) {
38 StringMatchResultListener value_listener;
39 if (!value_matcher.MatchAndExplain(value, &value_listener)) {
40 *listener << "whose " << value_name << " " << value << " doesn't match";
41 if (value_listener.str() != "") {
42 *listener << ", " << value_listener.str();
43 }
44 return false;
45 }
46 return true;
47 }
48
49
50 class NodeMatcher : public MatcherInterface<Node*> {
51 public:
NodeMatcher(IrOpcode::Value opcode)52 explicit NodeMatcher(IrOpcode::Value opcode) : opcode_(opcode) {}
53
DescribeTo(std::ostream * os) const54 void DescribeTo(std::ostream* os) const override {
55 *os << "is a " << IrOpcode::Mnemonic(opcode_) << " node";
56 }
57
MatchAndExplain(Node * node,MatchResultListener * listener) const58 bool MatchAndExplain(Node* node,
59 MatchResultListener* listener) const override {
60 if (node == NULL) {
61 *listener << "which is NULL";
62 return false;
63 }
64 if (node->opcode() != opcode_) {
65 *listener << "whose opcode is " << IrOpcode::Mnemonic(node->opcode())
66 << " but should have been " << IrOpcode::Mnemonic(opcode_);
67 return false;
68 }
69 return true;
70 }
71
72 private:
73 const IrOpcode::Value opcode_;
74 };
75
76
77 class IsBranchMatcher final : public NodeMatcher {
78 public:
IsBranchMatcher(const Matcher<Node * > & value_matcher,const Matcher<Node * > & control_matcher)79 IsBranchMatcher(const Matcher<Node*>& value_matcher,
80 const Matcher<Node*>& control_matcher)
81 : NodeMatcher(IrOpcode::kBranch),
82 value_matcher_(value_matcher),
83 control_matcher_(control_matcher) {}
84
DescribeTo(std::ostream * os) const85 void DescribeTo(std::ostream* os) const final {
86 NodeMatcher::DescribeTo(os);
87 *os << " whose value (";
88 value_matcher_.DescribeTo(os);
89 *os << ") and control (";
90 control_matcher_.DescribeTo(os);
91 *os << ")";
92 }
93
MatchAndExplain(Node * node,MatchResultListener * listener) const94 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
95 return (NodeMatcher::MatchAndExplain(node, listener) &&
96 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
97 "value", value_matcher_, listener) &&
98 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
99 "control", control_matcher_, listener));
100 }
101
102 private:
103 const Matcher<Node*> value_matcher_;
104 const Matcher<Node*> control_matcher_;
105 };
106
107
108 class IsSwitchMatcher final : public NodeMatcher {
109 public:
IsSwitchMatcher(const Matcher<Node * > & value_matcher,const Matcher<Node * > & control_matcher)110 IsSwitchMatcher(const Matcher<Node*>& value_matcher,
111 const Matcher<Node*>& control_matcher)
112 : NodeMatcher(IrOpcode::kSwitch),
113 value_matcher_(value_matcher),
114 control_matcher_(control_matcher) {}
115
DescribeTo(std::ostream * os) const116 void DescribeTo(std::ostream* os) const final {
117 NodeMatcher::DescribeTo(os);
118 *os << " whose value (";
119 value_matcher_.DescribeTo(os);
120 *os << ") and control (";
121 control_matcher_.DescribeTo(os);
122 *os << ")";
123 }
124
MatchAndExplain(Node * node,MatchResultListener * listener) const125 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
126 return (NodeMatcher::MatchAndExplain(node, listener) &&
127 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
128 "value", value_matcher_, listener) &&
129 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
130 "control", control_matcher_, listener));
131 }
132
133 private:
134 const Matcher<Node*> value_matcher_;
135 const Matcher<Node*> control_matcher_;
136 };
137
138
139 class IsIfValueMatcher final : public NodeMatcher {
140 public:
IsIfValueMatcher(const Matcher<int32_t> & value_matcher,const Matcher<Node * > & control_matcher)141 IsIfValueMatcher(const Matcher<int32_t>& value_matcher,
142 const Matcher<Node*>& control_matcher)
143 : NodeMatcher(IrOpcode::kIfValue),
144 value_matcher_(value_matcher),
145 control_matcher_(control_matcher) {}
146
DescribeTo(std::ostream * os) const147 void DescribeTo(std::ostream* os) const final {
148 NodeMatcher::DescribeTo(os);
149 *os << " whose value (";
150 value_matcher_.DescribeTo(os);
151 *os << ") and control (";
152 control_matcher_.DescribeTo(os);
153 *os << ")";
154 }
155
MatchAndExplain(Node * node,MatchResultListener * listener) const156 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
157 return (NodeMatcher::MatchAndExplain(node, listener) &&
158 PrintMatchAndExplain(OpParameter<int32_t>(node->op()), "value",
159 value_matcher_, listener) &&
160 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
161 "control", control_matcher_, listener));
162 }
163
164 private:
165 const Matcher<int32_t> value_matcher_;
166 const Matcher<Node*> control_matcher_;
167 };
168
169
170 class IsControl1Matcher final : public NodeMatcher {
171 public:
IsControl1Matcher(IrOpcode::Value opcode,const Matcher<Node * > & control_matcher)172 IsControl1Matcher(IrOpcode::Value opcode,
173 const Matcher<Node*>& control_matcher)
174 : NodeMatcher(opcode), control_matcher_(control_matcher) {}
175
DescribeTo(std::ostream * os) const176 void DescribeTo(std::ostream* os) const final {
177 NodeMatcher::DescribeTo(os);
178 *os << " whose control (";
179 control_matcher_.DescribeTo(os);
180 *os << ")";
181 }
182
MatchAndExplain(Node * node,MatchResultListener * listener) const183 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
184 return (NodeMatcher::MatchAndExplain(node, listener) &&
185 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
186 "control", control_matcher_, listener));
187 }
188
189 private:
190 const Matcher<Node*> control_matcher_;
191 };
192
193
194 class IsControl2Matcher final : public NodeMatcher {
195 public:
IsControl2Matcher(IrOpcode::Value opcode,const Matcher<Node * > & control0_matcher,const Matcher<Node * > & control1_matcher)196 IsControl2Matcher(IrOpcode::Value opcode,
197 const Matcher<Node*>& control0_matcher,
198 const Matcher<Node*>& control1_matcher)
199 : NodeMatcher(opcode),
200 control0_matcher_(control0_matcher),
201 control1_matcher_(control1_matcher) {}
202
DescribeTo(std::ostream * os) const203 void DescribeTo(std::ostream* os) const final {
204 NodeMatcher::DescribeTo(os);
205 *os << " whose control0 (";
206 control0_matcher_.DescribeTo(os);
207 *os << ") and control1 (";
208 control1_matcher_.DescribeTo(os);
209 *os << ")";
210 }
211
MatchAndExplain(Node * node,MatchResultListener * listener) const212 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
213 return (NodeMatcher::MatchAndExplain(node, listener) &&
214 PrintMatchAndExplain(NodeProperties::GetControlInput(node, 0),
215 "control0", control0_matcher_, listener) &&
216 PrintMatchAndExplain(NodeProperties::GetControlInput(node, 1),
217 "control1", control1_matcher_, listener));
218 }
219
220 private:
221 const Matcher<Node*> control0_matcher_;
222 const Matcher<Node*> control1_matcher_;
223 };
224
225
226 class IsControl3Matcher final : public NodeMatcher {
227 public:
IsControl3Matcher(IrOpcode::Value opcode,const Matcher<Node * > & control0_matcher,const Matcher<Node * > & control1_matcher,const Matcher<Node * > & control2_matcher)228 IsControl3Matcher(IrOpcode::Value opcode,
229 const Matcher<Node*>& control0_matcher,
230 const Matcher<Node*>& control1_matcher,
231 const Matcher<Node*>& control2_matcher)
232 : NodeMatcher(opcode),
233 control0_matcher_(control0_matcher),
234 control1_matcher_(control1_matcher),
235 control2_matcher_(control2_matcher) {}
236
DescribeTo(std::ostream * os) const237 void DescribeTo(std::ostream* os) const final {
238 NodeMatcher::DescribeTo(os);
239 *os << " whose control0 (";
240 control0_matcher_.DescribeTo(os);
241 *os << ") and control1 (";
242 control1_matcher_.DescribeTo(os);
243 *os << ") and control2 (";
244 control2_matcher_.DescribeTo(os);
245 *os << ")";
246 }
247
MatchAndExplain(Node * node,MatchResultListener * listener) const248 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
249 return (NodeMatcher::MatchAndExplain(node, listener) &&
250 PrintMatchAndExplain(NodeProperties::GetControlInput(node, 0),
251 "control0", control0_matcher_, listener) &&
252 PrintMatchAndExplain(NodeProperties::GetControlInput(node, 1),
253 "control1", control1_matcher_, listener) &&
254 PrintMatchAndExplain(NodeProperties::GetControlInput(node, 2),
255 "control2", control2_matcher_, listener));
256 }
257
258 private:
259 const Matcher<Node*> control0_matcher_;
260 const Matcher<Node*> control1_matcher_;
261 const Matcher<Node*> control2_matcher_;
262 };
263
264
265 class IsBeginRegionMatcher final : public NodeMatcher {
266 public:
IsBeginRegionMatcher(const Matcher<Node * > & effect_matcher)267 explicit IsBeginRegionMatcher(const Matcher<Node*>& effect_matcher)
268 : NodeMatcher(IrOpcode::kBeginRegion), effect_matcher_(effect_matcher) {}
269
DescribeTo(std::ostream * os) const270 void DescribeTo(std::ostream* os) const final {
271 NodeMatcher::DescribeTo(os);
272 *os << " whose effect (";
273 effect_matcher_.DescribeTo(os);
274 *os << ")";
275 }
276
MatchAndExplain(Node * node,MatchResultListener * listener) const277 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
278 return (NodeMatcher::MatchAndExplain(node, listener) &&
279 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
280 effect_matcher_, listener));
281 }
282
283 private:
284 const Matcher<Node*> effect_matcher_;
285 };
286
287
288 class IsFinishRegionMatcher final : public NodeMatcher {
289 public:
IsFinishRegionMatcher(const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher)290 IsFinishRegionMatcher(const Matcher<Node*>& value_matcher,
291 const Matcher<Node*>& effect_matcher)
292 : NodeMatcher(IrOpcode::kFinishRegion),
293 value_matcher_(value_matcher),
294 effect_matcher_(effect_matcher) {}
295
DescribeTo(std::ostream * os) const296 void DescribeTo(std::ostream* os) const final {
297 NodeMatcher::DescribeTo(os);
298 *os << " whose value (";
299 value_matcher_.DescribeTo(os);
300 *os << ") and effect (";
301 effect_matcher_.DescribeTo(os);
302 *os << ")";
303 }
304
MatchAndExplain(Node * node,MatchResultListener * listener) const305 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
306 return (NodeMatcher::MatchAndExplain(node, listener) &&
307 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
308 "value", value_matcher_, listener) &&
309 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
310 effect_matcher_, listener));
311 }
312
313 private:
314 const Matcher<Node*> value_matcher_;
315 const Matcher<Node*> effect_matcher_;
316 };
317
318
319 class IsReturnMatcher final : public NodeMatcher {
320 public:
IsReturnMatcher(const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)321 IsReturnMatcher(const Matcher<Node*>& value_matcher,
322 const Matcher<Node*>& effect_matcher,
323 const Matcher<Node*>& control_matcher)
324 : NodeMatcher(IrOpcode::kReturn),
325 value_matcher_(value_matcher),
326 value2_matcher_(_),
327 effect_matcher_(effect_matcher),
328 control_matcher_(control_matcher),
329 has_second_return_value_(false) {}
330
IsReturnMatcher(const Matcher<Node * > & value_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)331 IsReturnMatcher(const Matcher<Node*>& value_matcher,
332 const Matcher<Node*>& value2_matcher,
333 const Matcher<Node*>& effect_matcher,
334 const Matcher<Node*>& control_matcher)
335 : NodeMatcher(IrOpcode::kReturn),
336 value_matcher_(value_matcher),
337 value2_matcher_(value2_matcher),
338 effect_matcher_(effect_matcher),
339 control_matcher_(control_matcher),
340 has_second_return_value_(true) {}
341
DescribeTo(std::ostream * os) const342 void DescribeTo(std::ostream* os) const final {
343 NodeMatcher::DescribeTo(os);
344 *os << " whose value (";
345 value_matcher_.DescribeTo(os);
346 if (has_second_return_value_) {
347 *os << ") and second value (";
348 value2_matcher_.DescribeTo(os);
349 }
350 *os << ") and effect (";
351 effect_matcher_.DescribeTo(os);
352 *os << ") and control (";
353 control_matcher_.DescribeTo(os);
354 *os << ")";
355 }
356
MatchAndExplain(Node * node,MatchResultListener * listener) const357 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
358 return (NodeMatcher::MatchAndExplain(node, listener) &&
359 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
360 "value", value_matcher_, listener) &&
361 (!has_second_return_value_ ||
362 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
363 "value2", value2_matcher_, listener)) &&
364 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
365 effect_matcher_, listener) &&
366 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
367 "control", control_matcher_, listener));
368 }
369
370 private:
371 const Matcher<Node*> value_matcher_;
372 const Matcher<Node*> value2_matcher_;
373 const Matcher<Node*> effect_matcher_;
374 const Matcher<Node*> control_matcher_;
375 bool has_second_return_value_;
376 };
377
378
379 class IsTerminateMatcher final : public NodeMatcher {
380 public:
IsTerminateMatcher(const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)381 IsTerminateMatcher(const Matcher<Node*>& effect_matcher,
382 const Matcher<Node*>& control_matcher)
383 : NodeMatcher(IrOpcode::kTerminate),
384 effect_matcher_(effect_matcher),
385 control_matcher_(control_matcher) {}
386
DescribeTo(std::ostream * os) const387 void DescribeTo(std::ostream* os) const final {
388 NodeMatcher::DescribeTo(os);
389 *os << " whose effect (";
390 effect_matcher_.DescribeTo(os);
391 *os << ") and control (";
392 control_matcher_.DescribeTo(os);
393 *os << ")";
394 }
395
MatchAndExplain(Node * node,MatchResultListener * listener) const396 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
397 return (NodeMatcher::MatchAndExplain(node, listener) &&
398 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
399 effect_matcher_, listener) &&
400 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
401 "control", control_matcher_, listener));
402 }
403
404 private:
405 const Matcher<Node*> effect_matcher_;
406 const Matcher<Node*> control_matcher_;
407 };
408
409
410 template <typename T>
411 class IsConstantMatcher final : public NodeMatcher {
412 public:
IsConstantMatcher(IrOpcode::Value opcode,const Matcher<T> & value_matcher)413 IsConstantMatcher(IrOpcode::Value opcode, const Matcher<T>& value_matcher)
414 : NodeMatcher(opcode), value_matcher_(value_matcher) {}
415
DescribeTo(std::ostream * os) const416 void DescribeTo(std::ostream* os) const final {
417 NodeMatcher::DescribeTo(os);
418 *os << " whose value (";
419 value_matcher_.DescribeTo(os);
420 *os << ")";
421 }
422
MatchAndExplain(Node * node,MatchResultListener * listener) const423 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
424 return (NodeMatcher::MatchAndExplain(node, listener) &&
425 PrintMatchAndExplain(OpParameter<T>(node), "value", value_matcher_,
426 listener));
427 }
428
429 private:
430 const Matcher<T> value_matcher_;
431 };
432
433
434 class IsSelectMatcher final : public NodeMatcher {
435 public:
IsSelectMatcher(const Matcher<MachineRepresentation> & type_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher)436 IsSelectMatcher(const Matcher<MachineRepresentation>& type_matcher,
437 const Matcher<Node*>& value0_matcher,
438 const Matcher<Node*>& value1_matcher,
439 const Matcher<Node*>& value2_matcher)
440 : NodeMatcher(IrOpcode::kSelect),
441 type_matcher_(type_matcher),
442 value0_matcher_(value0_matcher),
443 value1_matcher_(value1_matcher),
444 value2_matcher_(value2_matcher) {}
445
DescribeTo(std::ostream * os) const446 void DescribeTo(std::ostream* os) const final {
447 NodeMatcher::DescribeTo(os);
448 *os << " whose representation (";
449 type_matcher_.DescribeTo(os);
450 *os << "), value0 (";
451 value0_matcher_.DescribeTo(os);
452 *os << "), value1 (";
453 value1_matcher_.DescribeTo(os);
454 *os << ") and value2 (";
455 value2_matcher_.DescribeTo(os);
456 *os << ")";
457 }
458
MatchAndExplain(Node * node,MatchResultListener * listener) const459 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
460 return (
461 NodeMatcher::MatchAndExplain(node, listener) &&
462 PrintMatchAndExplain(SelectParametersOf(node->op()).representation(),
463 "representation", type_matcher_, listener) &&
464 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "value0",
465 value0_matcher_, listener) &&
466 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1), "value1",
467 value1_matcher_, listener) &&
468 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2), "value2",
469 value2_matcher_, listener));
470 }
471
472 private:
473 const Matcher<MachineRepresentation> type_matcher_;
474 const Matcher<Node*> value0_matcher_;
475 const Matcher<Node*> value1_matcher_;
476 const Matcher<Node*> value2_matcher_;
477 };
478
479
480 class IsPhiMatcher final : public NodeMatcher {
481 public:
IsPhiMatcher(const Matcher<MachineRepresentation> & type_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & control_matcher)482 IsPhiMatcher(const Matcher<MachineRepresentation>& type_matcher,
483 const Matcher<Node*>& value0_matcher,
484 const Matcher<Node*>& value1_matcher,
485 const Matcher<Node*>& control_matcher)
486 : NodeMatcher(IrOpcode::kPhi),
487 type_matcher_(type_matcher),
488 value0_matcher_(value0_matcher),
489 value1_matcher_(value1_matcher),
490 control_matcher_(control_matcher) {}
491
DescribeTo(std::ostream * os) const492 void DescribeTo(std::ostream* os) const final {
493 NodeMatcher::DescribeTo(os);
494 *os << " whose representation (";
495 type_matcher_.DescribeTo(os);
496 *os << "), value0 (";
497 value0_matcher_.DescribeTo(os);
498 *os << "), value1 (";
499 value1_matcher_.DescribeTo(os);
500 *os << ") and control (";
501 control_matcher_.DescribeTo(os);
502 *os << ")";
503 }
504
MatchAndExplain(Node * node,MatchResultListener * listener) const505 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
506 return (NodeMatcher::MatchAndExplain(node, listener) &&
507 PrintMatchAndExplain(PhiRepresentationOf(node->op()),
508 "representation", type_matcher_, listener) &&
509 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
510 "value0", value0_matcher_, listener) &&
511 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
512 "value1", value1_matcher_, listener) &&
513 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
514 "control", control_matcher_, listener));
515 }
516
517 private:
518 const Matcher<MachineRepresentation> type_matcher_;
519 const Matcher<Node*> value0_matcher_;
520 const Matcher<Node*> value1_matcher_;
521 const Matcher<Node*> control_matcher_;
522 };
523
524
525 class IsPhi2Matcher final : public NodeMatcher {
526 public:
IsPhi2Matcher(const Matcher<MachineRepresentation> & type_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & control_matcher)527 IsPhi2Matcher(const Matcher<MachineRepresentation>& type_matcher,
528 const Matcher<Node*>& value0_matcher,
529 const Matcher<Node*>& value1_matcher,
530 const Matcher<Node*>& value2_matcher,
531 const Matcher<Node*>& control_matcher)
532 : NodeMatcher(IrOpcode::kPhi),
533 type_matcher_(type_matcher),
534 value0_matcher_(value0_matcher),
535 value1_matcher_(value1_matcher),
536 value2_matcher_(value2_matcher),
537 control_matcher_(control_matcher) {}
538
DescribeTo(std::ostream * os) const539 void DescribeTo(std::ostream* os) const final {
540 NodeMatcher::DescribeTo(os);
541 *os << " whose representation (";
542 type_matcher_.DescribeTo(os);
543 *os << "), value0 (";
544 value0_matcher_.DescribeTo(os);
545 *os << "), value1 (";
546 value1_matcher_.DescribeTo(os);
547 *os << "), value2 (";
548 value2_matcher_.DescribeTo(os);
549 *os << ") and control (";
550 control_matcher_.DescribeTo(os);
551 *os << ")";
552 }
553
MatchAndExplain(Node * node,MatchResultListener * listener) const554 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
555 return (NodeMatcher::MatchAndExplain(node, listener) &&
556 PrintMatchAndExplain(PhiRepresentationOf(node->op()),
557 "representation", type_matcher_, listener) &&
558 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
559 "value0", value0_matcher_, listener) &&
560 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
561 "value1", value1_matcher_, listener) &&
562 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
563 "value2", value2_matcher_, listener) &&
564 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
565 "control", control_matcher_, listener));
566 }
567
568 private:
569 const Matcher<MachineRepresentation> type_matcher_;
570 const Matcher<Node*> value0_matcher_;
571 const Matcher<Node*> value1_matcher_;
572 const Matcher<Node*> value2_matcher_;
573 const Matcher<Node*> control_matcher_;
574 };
575
576
577 class IsEffectPhiMatcher final : public NodeMatcher {
578 public:
IsEffectPhiMatcher(const Matcher<Node * > & effect0_matcher,const Matcher<Node * > & effect1_matcher,const Matcher<Node * > & control_matcher)579 IsEffectPhiMatcher(const Matcher<Node*>& effect0_matcher,
580 const Matcher<Node*>& effect1_matcher,
581 const Matcher<Node*>& control_matcher)
582 : NodeMatcher(IrOpcode::kEffectPhi),
583 effect0_matcher_(effect0_matcher),
584 effect1_matcher_(effect1_matcher),
585 control_matcher_(control_matcher) {}
586
DescribeTo(std::ostream * os) const587 void DescribeTo(std::ostream* os) const final {
588 NodeMatcher::DescribeTo(os);
589 *os << "), effect0 (";
590 effect0_matcher_.DescribeTo(os);
591 *os << "), effect1 (";
592 effect1_matcher_.DescribeTo(os);
593 *os << ") and control (";
594 control_matcher_.DescribeTo(os);
595 *os << ")";
596 }
597
MatchAndExplain(Node * node,MatchResultListener * listener) const598 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
599 return (NodeMatcher::MatchAndExplain(node, listener) &&
600 PrintMatchAndExplain(NodeProperties::GetEffectInput(node, 0),
601 "effect0", effect0_matcher_, listener) &&
602 PrintMatchAndExplain(NodeProperties::GetEffectInput(node, 1),
603 "effect1", effect1_matcher_, listener) &&
604 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
605 "control", control_matcher_, listener));
606 }
607
608 private:
609 const Matcher<Node*> effect0_matcher_;
610 const Matcher<Node*> effect1_matcher_;
611 const Matcher<Node*> control_matcher_;
612 };
613
614
615 class IsProjectionMatcher final : public NodeMatcher {
616 public:
IsProjectionMatcher(const Matcher<size_t> & index_matcher,const Matcher<Node * > & base_matcher)617 IsProjectionMatcher(const Matcher<size_t>& index_matcher,
618 const Matcher<Node*>& base_matcher)
619 : NodeMatcher(IrOpcode::kProjection),
620 index_matcher_(index_matcher),
621 base_matcher_(base_matcher) {}
622
DescribeTo(std::ostream * os) const623 void DescribeTo(std::ostream* os) const final {
624 NodeMatcher::DescribeTo(os);
625 *os << " whose index (";
626 index_matcher_.DescribeTo(os);
627 *os << ") and base (";
628 base_matcher_.DescribeTo(os);
629 *os << ")";
630 }
631
MatchAndExplain(Node * node,MatchResultListener * listener) const632 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
633 return (NodeMatcher::MatchAndExplain(node, listener) &&
634 PrintMatchAndExplain(OpParameter<size_t>(node), "index",
635 index_matcher_, listener) &&
636 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
637 base_matcher_, listener));
638 }
639
640 private:
641 const Matcher<size_t> index_matcher_;
642 const Matcher<Node*> base_matcher_;
643 };
644
645
646 class IsCallMatcher final : public NodeMatcher {
647 public:
IsCallMatcher(const Matcher<const CallDescriptor * > & descriptor_matcher,const std::vector<Matcher<Node * >> & value_matchers,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)648 IsCallMatcher(const Matcher<const CallDescriptor*>& descriptor_matcher,
649 const std::vector<Matcher<Node*>>& value_matchers,
650 const Matcher<Node*>& effect_matcher,
651 const Matcher<Node*>& control_matcher)
652 : NodeMatcher(IrOpcode::kCall),
653 descriptor_matcher_(descriptor_matcher),
654 value_matchers_(value_matchers),
655 effect_matcher_(effect_matcher),
656 control_matcher_(control_matcher) {}
657
DescribeTo(std::ostream * os) const658 void DescribeTo(std::ostream* os) const final {
659 NodeMatcher::DescribeTo(os);
660 for (size_t i = 0; i < value_matchers_.size(); ++i) {
661 if (i == 0) {
662 *os << " whose value0 (";
663 } else {
664 *os << "), value" << i << " (";
665 }
666 value_matchers_[i].DescribeTo(os);
667 }
668 *os << "), effect (";
669 effect_matcher_.DescribeTo(os);
670 *os << ") and control (";
671 control_matcher_.DescribeTo(os);
672 *os << ")";
673 }
674
MatchAndExplain(Node * node,MatchResultListener * listener) const675 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
676 if (!NodeMatcher::MatchAndExplain(node, listener) ||
677 !PrintMatchAndExplain(OpParameter<const CallDescriptor*>(node),
678 "descriptor", descriptor_matcher_, listener)) {
679 return false;
680 }
681 for (size_t i = 0; i < value_matchers_.size(); ++i) {
682 std::ostringstream ost;
683 ost << "value" << i;
684 if (!PrintMatchAndExplain(
685 NodeProperties::GetValueInput(node, static_cast<int>(i)),
686 ost.str(), value_matchers_[i], listener)) {
687 return false;
688 }
689 }
690 Node* effect_node = nullptr;
691 Node* control_node = nullptr;
692 if (NodeProperties::FirstEffectIndex(node) < node->InputCount()) {
693 effect_node = NodeProperties::GetEffectInput(node);
694 }
695 if (NodeProperties::FirstControlIndex(node) < node->InputCount()) {
696 control_node = NodeProperties::GetControlInput(node);
697 }
698 return (PrintMatchAndExplain(effect_node, "effect", effect_matcher_,
699 listener) &&
700 PrintMatchAndExplain(control_node, "control", control_matcher_,
701 listener));
702 }
703
704 private:
705 const Matcher<const CallDescriptor*> descriptor_matcher_;
706 const std::vector<Matcher<Node*>> value_matchers_;
707 const Matcher<Node*> effect_matcher_;
708 const Matcher<Node*> control_matcher_;
709 };
710
711
712 class IsTailCallMatcher final : public NodeMatcher {
713 public:
IsTailCallMatcher(const Matcher<CallDescriptor const * > & descriptor_matcher,const std::vector<Matcher<Node * >> & value_matchers,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)714 IsTailCallMatcher(const Matcher<CallDescriptor const*>& descriptor_matcher,
715 const std::vector<Matcher<Node*>>& value_matchers,
716 const Matcher<Node*>& effect_matcher,
717 const Matcher<Node*>& control_matcher)
718 : NodeMatcher(IrOpcode::kTailCall),
719 descriptor_matcher_(descriptor_matcher),
720 value_matchers_(value_matchers),
721 effect_matcher_(effect_matcher),
722 control_matcher_(control_matcher) {}
723
DescribeTo(std::ostream * os) const724 void DescribeTo(std::ostream* os) const final {
725 NodeMatcher::DescribeTo(os);
726 for (size_t i = 0; i < value_matchers_.size(); ++i) {
727 if (i == 0) {
728 *os << " whose value0 (";
729 } else {
730 *os << "), value" << i << " (";
731 }
732 value_matchers_[i].DescribeTo(os);
733 }
734 *os << "), effect (";
735 effect_matcher_.DescribeTo(os);
736 *os << ") and control (";
737 control_matcher_.DescribeTo(os);
738 *os << ")";
739 }
740
MatchAndExplain(Node * node,MatchResultListener * listener) const741 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
742 if (!NodeMatcher::MatchAndExplain(node, listener) ||
743 !PrintMatchAndExplain(OpParameter<CallDescriptor const*>(node),
744 "descriptor", descriptor_matcher_, listener)) {
745 return false;
746 }
747 for (size_t i = 0; i < value_matchers_.size(); ++i) {
748 std::ostringstream ost;
749 ost << "value" << i;
750 if (!PrintMatchAndExplain(
751 NodeProperties::GetValueInput(node, static_cast<int>(i)),
752 ost.str(), value_matchers_[i], listener)) {
753 return false;
754 }
755 }
756 Node* effect_node = nullptr;
757 Node* control_node = nullptr;
758 if (NodeProperties::FirstEffectIndex(node) < node->InputCount()) {
759 effect_node = NodeProperties::GetEffectInput(node);
760 }
761 if (NodeProperties::FirstControlIndex(node) < node->InputCount()) {
762 control_node = NodeProperties::GetControlInput(node);
763 }
764 return (PrintMatchAndExplain(effect_node, "effect", effect_matcher_,
765 listener) &&
766 PrintMatchAndExplain(control_node, "control", control_matcher_,
767 listener));
768 }
769
770 private:
771 const Matcher<CallDescriptor const*> descriptor_matcher_;
772 const std::vector<Matcher<Node*>> value_matchers_;
773 const Matcher<Node*> effect_matcher_;
774 const Matcher<Node*> control_matcher_;
775 };
776
777
778 class IsReferenceEqualMatcher final : public NodeMatcher {
779 public:
IsReferenceEqualMatcher(const Matcher<Type * > & type_matcher,const Matcher<Node * > & lhs_matcher,const Matcher<Node * > & rhs_matcher)780 IsReferenceEqualMatcher(const Matcher<Type*>& type_matcher,
781 const Matcher<Node*>& lhs_matcher,
782 const Matcher<Node*>& rhs_matcher)
783 : NodeMatcher(IrOpcode::kReferenceEqual),
784 type_matcher_(type_matcher),
785 lhs_matcher_(lhs_matcher),
786 rhs_matcher_(rhs_matcher) {}
787
MatchAndExplain(Node * node,MatchResultListener * listener) const788 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
789 return (NodeMatcher::MatchAndExplain(node, listener) &&
790 // TODO(bmeurer): The type parameter is currently ignored.
791 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "lhs",
792 lhs_matcher_, listener) &&
793 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1), "rhs",
794 rhs_matcher_, listener));
795 }
796
797 private:
798 const Matcher<Type*> type_matcher_;
799 const Matcher<Node*> lhs_matcher_;
800 const Matcher<Node*> rhs_matcher_;
801 };
802
803 class IsSpeculativeBinopMatcher final : public NodeMatcher {
804 public:
IsSpeculativeBinopMatcher(IrOpcode::Value opcode,const Matcher<BinaryOperationHints::Hint> & hint_matcher,const Matcher<Node * > & lhs_matcher,const Matcher<Node * > & rhs_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)805 IsSpeculativeBinopMatcher(
806 IrOpcode::Value opcode,
807 const Matcher<BinaryOperationHints::Hint>& hint_matcher,
808 const Matcher<Node*>& lhs_matcher, const Matcher<Node*>& rhs_matcher,
809 const Matcher<Node*>& effect_matcher,
810 const Matcher<Node*>& control_matcher)
811 : NodeMatcher(opcode),
812 lhs_matcher_(lhs_matcher),
813 rhs_matcher_(rhs_matcher),
814 effect_matcher_(effect_matcher),
815 control_matcher_(control_matcher) {}
816
MatchAndExplain(Node * node,MatchResultListener * listener) const817 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
818 return (NodeMatcher::MatchAndExplain(node, listener) &&
819 // TODO(bmeurer): The type parameter is currently ignored.
820 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "lhs",
821 lhs_matcher_, listener) &&
822 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1), "rhs",
823 rhs_matcher_, listener) &&
824 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
825 effect_matcher_, listener) &&
826 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
827 "control", control_matcher_, listener));
828 }
829
830 private:
831 const Matcher<Type*> type_matcher_;
832 const Matcher<Node*> lhs_matcher_;
833 const Matcher<Node*> rhs_matcher_;
834 const Matcher<Node*> effect_matcher_;
835 const Matcher<Node*> control_matcher_;
836 };
837
838 class IsAllocateMatcher final : public NodeMatcher {
839 public:
IsAllocateMatcher(const Matcher<Node * > & size_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)840 IsAllocateMatcher(const Matcher<Node*>& size_matcher,
841 const Matcher<Node*>& effect_matcher,
842 const Matcher<Node*>& control_matcher)
843 : NodeMatcher(IrOpcode::kAllocate),
844 size_matcher_(size_matcher),
845 effect_matcher_(effect_matcher),
846 control_matcher_(control_matcher) {}
847
MatchAndExplain(Node * node,MatchResultListener * listener) const848 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
849 return (NodeMatcher::MatchAndExplain(node, listener) &&
850 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "size",
851 size_matcher_, listener) &&
852 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
853 effect_matcher_, listener) &&
854 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
855 "control", control_matcher_, listener));
856 }
857
858 private:
859 const Matcher<Node*> size_matcher_;
860 const Matcher<Node*> effect_matcher_;
861 const Matcher<Node*> control_matcher_;
862 };
863
864
865 class IsLoadFieldMatcher final : public NodeMatcher {
866 public:
IsLoadFieldMatcher(const Matcher<FieldAccess> & access_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)867 IsLoadFieldMatcher(const Matcher<FieldAccess>& access_matcher,
868 const Matcher<Node*>& base_matcher,
869 const Matcher<Node*>& effect_matcher,
870 const Matcher<Node*>& control_matcher)
871 : NodeMatcher(IrOpcode::kLoadField),
872 access_matcher_(access_matcher),
873 base_matcher_(base_matcher),
874 effect_matcher_(effect_matcher),
875 control_matcher_(control_matcher) {}
876
DescribeTo(std::ostream * os) const877 void DescribeTo(std::ostream* os) const final {
878 NodeMatcher::DescribeTo(os);
879 *os << " whose access (";
880 access_matcher_.DescribeTo(os);
881 *os << "), base (";
882 base_matcher_.DescribeTo(os);
883 *os << "), effect (";
884 effect_matcher_.DescribeTo(os);
885 *os << ") and control (";
886 control_matcher_.DescribeTo(os);
887 *os << ")";
888 }
889
MatchAndExplain(Node * node,MatchResultListener * listener) const890 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
891 return (NodeMatcher::MatchAndExplain(node, listener) &&
892 PrintMatchAndExplain(OpParameter<FieldAccess>(node), "access",
893 access_matcher_, listener) &&
894 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
895 base_matcher_, listener) &&
896 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
897 effect_matcher_, listener) &&
898 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
899 "control", control_matcher_, listener));
900 }
901
902 private:
903 const Matcher<FieldAccess> access_matcher_;
904 const Matcher<Node*> base_matcher_;
905 const Matcher<Node*> effect_matcher_;
906 const Matcher<Node*> control_matcher_;
907 };
908
909
910 class IsStoreFieldMatcher final : public NodeMatcher {
911 public:
IsStoreFieldMatcher(const Matcher<FieldAccess> & access_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)912 IsStoreFieldMatcher(const Matcher<FieldAccess>& access_matcher,
913 const Matcher<Node*>& base_matcher,
914 const Matcher<Node*>& value_matcher,
915 const Matcher<Node*>& effect_matcher,
916 const Matcher<Node*>& control_matcher)
917 : NodeMatcher(IrOpcode::kStoreField),
918 access_matcher_(access_matcher),
919 base_matcher_(base_matcher),
920 value_matcher_(value_matcher),
921 effect_matcher_(effect_matcher),
922 control_matcher_(control_matcher) {}
923
DescribeTo(std::ostream * os) const924 void DescribeTo(std::ostream* os) const final {
925 NodeMatcher::DescribeTo(os);
926 *os << " whose access (";
927 access_matcher_.DescribeTo(os);
928 *os << "), base (";
929 base_matcher_.DescribeTo(os);
930 *os << "), value (";
931 value_matcher_.DescribeTo(os);
932 *os << "), effect (";
933 effect_matcher_.DescribeTo(os);
934 *os << ") and control (";
935 control_matcher_.DescribeTo(os);
936 *os << ")";
937 }
938
MatchAndExplain(Node * node,MatchResultListener * listener) const939 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
940 return (NodeMatcher::MatchAndExplain(node, listener) &&
941 PrintMatchAndExplain(OpParameter<FieldAccess>(node), "access",
942 access_matcher_, listener) &&
943 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
944 base_matcher_, listener) &&
945 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
946 "value", value_matcher_, listener) &&
947 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
948 effect_matcher_, listener) &&
949 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
950 "control", control_matcher_, listener));
951 }
952
953 private:
954 const Matcher<FieldAccess> access_matcher_;
955 const Matcher<Node*> base_matcher_;
956 const Matcher<Node*> value_matcher_;
957 const Matcher<Node*> effect_matcher_;
958 const Matcher<Node*> control_matcher_;
959 };
960
961
962 class IsLoadBufferMatcher final : public NodeMatcher {
963 public:
IsLoadBufferMatcher(const Matcher<BufferAccess> & access_matcher,const Matcher<Node * > & buffer_matcher,const Matcher<Node * > & offset_matcher,const Matcher<Node * > & length_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)964 IsLoadBufferMatcher(const Matcher<BufferAccess>& access_matcher,
965 const Matcher<Node*>& buffer_matcher,
966 const Matcher<Node*>& offset_matcher,
967 const Matcher<Node*>& length_matcher,
968 const Matcher<Node*>& effect_matcher,
969 const Matcher<Node*>& control_matcher)
970 : NodeMatcher(IrOpcode::kLoadBuffer),
971 access_matcher_(access_matcher),
972 buffer_matcher_(buffer_matcher),
973 offset_matcher_(offset_matcher),
974 length_matcher_(length_matcher),
975 effect_matcher_(effect_matcher),
976 control_matcher_(control_matcher) {}
977
DescribeTo(std::ostream * os) const978 void DescribeTo(std::ostream* os) const final {
979 NodeMatcher::DescribeTo(os);
980 *os << " whose access (";
981 access_matcher_.DescribeTo(os);
982 *os << "), buffer (";
983 buffer_matcher_.DescribeTo(os);
984 *os << "), offset (";
985 offset_matcher_.DescribeTo(os);
986 *os << "), length (";
987 length_matcher_.DescribeTo(os);
988 *os << "), effect (";
989 effect_matcher_.DescribeTo(os);
990 *os << ") and control (";
991 control_matcher_.DescribeTo(os);
992 *os << ")";
993 }
994
MatchAndExplain(Node * node,MatchResultListener * listener) const995 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
996 return (NodeMatcher::MatchAndExplain(node, listener) &&
997 PrintMatchAndExplain(BufferAccessOf(node->op()), "access",
998 access_matcher_, listener) &&
999 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
1000 "buffer", buffer_matcher_, listener) &&
1001 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
1002 "offset", offset_matcher_, listener) &&
1003 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
1004 "length", length_matcher_, listener) &&
1005 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
1006 effect_matcher_, listener) &&
1007 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
1008 "control", control_matcher_, listener));
1009 }
1010
1011 private:
1012 const Matcher<BufferAccess> access_matcher_;
1013 const Matcher<Node*> buffer_matcher_;
1014 const Matcher<Node*> offset_matcher_;
1015 const Matcher<Node*> length_matcher_;
1016 const Matcher<Node*> effect_matcher_;
1017 const Matcher<Node*> control_matcher_;
1018 };
1019
1020
1021 class IsStoreBufferMatcher final : public NodeMatcher {
1022 public:
IsStoreBufferMatcher(const Matcher<BufferAccess> & access_matcher,const Matcher<Node * > & buffer_matcher,const Matcher<Node * > & offset_matcher,const Matcher<Node * > & length_matcher,const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1023 IsStoreBufferMatcher(const Matcher<BufferAccess>& access_matcher,
1024 const Matcher<Node*>& buffer_matcher,
1025 const Matcher<Node*>& offset_matcher,
1026 const Matcher<Node*>& length_matcher,
1027 const Matcher<Node*>& value_matcher,
1028 const Matcher<Node*>& effect_matcher,
1029 const Matcher<Node*>& control_matcher)
1030 : NodeMatcher(IrOpcode::kStoreBuffer),
1031 access_matcher_(access_matcher),
1032 buffer_matcher_(buffer_matcher),
1033 offset_matcher_(offset_matcher),
1034 length_matcher_(length_matcher),
1035 value_matcher_(value_matcher),
1036 effect_matcher_(effect_matcher),
1037 control_matcher_(control_matcher) {}
1038
DescribeTo(std::ostream * os) const1039 void DescribeTo(std::ostream* os) const final {
1040 NodeMatcher::DescribeTo(os);
1041 *os << " whose access (";
1042 access_matcher_.DescribeTo(os);
1043 *os << "), buffer (";
1044 buffer_matcher_.DescribeTo(os);
1045 *os << "), offset (";
1046 offset_matcher_.DescribeTo(os);
1047 *os << "), length (";
1048 length_matcher_.DescribeTo(os);
1049 *os << "), value (";
1050 value_matcher_.DescribeTo(os);
1051 *os << "), effect (";
1052 effect_matcher_.DescribeTo(os);
1053 *os << ") and control (";
1054 control_matcher_.DescribeTo(os);
1055 *os << ")";
1056 }
1057
MatchAndExplain(Node * node,MatchResultListener * listener) const1058 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1059 return (NodeMatcher::MatchAndExplain(node, listener) &&
1060 PrintMatchAndExplain(BufferAccessOf(node->op()), "access",
1061 access_matcher_, listener) &&
1062 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
1063 "buffer", buffer_matcher_, listener) &&
1064 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
1065 "offset", offset_matcher_, listener) &&
1066 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
1067 "length", length_matcher_, listener) &&
1068 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 3),
1069 "value", value_matcher_, listener) &&
1070 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
1071 effect_matcher_, listener) &&
1072 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
1073 "control", control_matcher_, listener));
1074 }
1075
1076 private:
1077 const Matcher<BufferAccess> access_matcher_;
1078 const Matcher<Node*> buffer_matcher_;
1079 const Matcher<Node*> offset_matcher_;
1080 const Matcher<Node*> length_matcher_;
1081 const Matcher<Node*> value_matcher_;
1082 const Matcher<Node*> effect_matcher_;
1083 const Matcher<Node*> control_matcher_;
1084 };
1085
1086
1087 class IsLoadElementMatcher final : public NodeMatcher {
1088 public:
IsLoadElementMatcher(const Matcher<ElementAccess> & access_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & index_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1089 IsLoadElementMatcher(const Matcher<ElementAccess>& access_matcher,
1090 const Matcher<Node*>& base_matcher,
1091 const Matcher<Node*>& index_matcher,
1092 const Matcher<Node*>& effect_matcher,
1093 const Matcher<Node*>& control_matcher)
1094 : NodeMatcher(IrOpcode::kLoadElement),
1095 access_matcher_(access_matcher),
1096 base_matcher_(base_matcher),
1097 index_matcher_(index_matcher),
1098 effect_matcher_(effect_matcher),
1099 control_matcher_(control_matcher) {}
1100
DescribeTo(std::ostream * os) const1101 void DescribeTo(std::ostream* os) const final {
1102 NodeMatcher::DescribeTo(os);
1103 *os << " whose access (";
1104 access_matcher_.DescribeTo(os);
1105 *os << "), base (";
1106 base_matcher_.DescribeTo(os);
1107 *os << "), index (";
1108 index_matcher_.DescribeTo(os);
1109 *os << "), effect (";
1110 effect_matcher_.DescribeTo(os);
1111 *os << ") and control (";
1112 control_matcher_.DescribeTo(os);
1113 *os << ")";
1114 }
1115
MatchAndExplain(Node * node,MatchResultListener * listener) const1116 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1117 return (NodeMatcher::MatchAndExplain(node, listener) &&
1118 PrintMatchAndExplain(OpParameter<ElementAccess>(node), "access",
1119 access_matcher_, listener) &&
1120 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
1121 base_matcher_, listener) &&
1122 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
1123 "index", index_matcher_, listener) &&
1124 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
1125 effect_matcher_, listener) &&
1126 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
1127 "control", control_matcher_, listener));
1128 }
1129
1130 private:
1131 const Matcher<ElementAccess> access_matcher_;
1132 const Matcher<Node*> base_matcher_;
1133 const Matcher<Node*> index_matcher_;
1134 const Matcher<Node*> effect_matcher_;
1135 const Matcher<Node*> control_matcher_;
1136 };
1137
1138
1139 class IsStoreElementMatcher final : public NodeMatcher {
1140 public:
IsStoreElementMatcher(const Matcher<ElementAccess> & access_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & index_matcher,const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1141 IsStoreElementMatcher(const Matcher<ElementAccess>& access_matcher,
1142 const Matcher<Node*>& base_matcher,
1143 const Matcher<Node*>& index_matcher,
1144 const Matcher<Node*>& value_matcher,
1145 const Matcher<Node*>& effect_matcher,
1146 const Matcher<Node*>& control_matcher)
1147 : NodeMatcher(IrOpcode::kStoreElement),
1148 access_matcher_(access_matcher),
1149 base_matcher_(base_matcher),
1150 index_matcher_(index_matcher),
1151 value_matcher_(value_matcher),
1152 effect_matcher_(effect_matcher),
1153 control_matcher_(control_matcher) {}
1154
DescribeTo(std::ostream * os) const1155 void DescribeTo(std::ostream* os) const final {
1156 NodeMatcher::DescribeTo(os);
1157 *os << " whose access (";
1158 access_matcher_.DescribeTo(os);
1159 *os << "), base (";
1160 base_matcher_.DescribeTo(os);
1161 *os << "), index (";
1162 index_matcher_.DescribeTo(os);
1163 *os << "), value (";
1164 value_matcher_.DescribeTo(os);
1165 *os << "), effect (";
1166 effect_matcher_.DescribeTo(os);
1167 *os << ") and control (";
1168 control_matcher_.DescribeTo(os);
1169 *os << ")";
1170 }
1171
MatchAndExplain(Node * node,MatchResultListener * listener) const1172 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1173 return (NodeMatcher::MatchAndExplain(node, listener) &&
1174 PrintMatchAndExplain(OpParameter<ElementAccess>(node), "access",
1175 access_matcher_, listener) &&
1176 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
1177 base_matcher_, listener) &&
1178 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
1179 "index", index_matcher_, listener) &&
1180 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
1181 "value", value_matcher_, listener) &&
1182 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
1183 effect_matcher_, listener) &&
1184 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
1185 "control", control_matcher_, listener));
1186 }
1187
1188 private:
1189 const Matcher<ElementAccess> access_matcher_;
1190 const Matcher<Node*> base_matcher_;
1191 const Matcher<Node*> index_matcher_;
1192 const Matcher<Node*> value_matcher_;
1193 const Matcher<Node*> effect_matcher_;
1194 const Matcher<Node*> control_matcher_;
1195 };
1196
1197
1198 class IsLoadMatcher final : public NodeMatcher {
1199 public:
IsLoadMatcher(const Matcher<LoadRepresentation> & rep_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & index_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1200 IsLoadMatcher(const Matcher<LoadRepresentation>& rep_matcher,
1201 const Matcher<Node*>& base_matcher,
1202 const Matcher<Node*>& index_matcher,
1203 const Matcher<Node*>& effect_matcher,
1204 const Matcher<Node*>& control_matcher)
1205 : NodeMatcher(IrOpcode::kLoad),
1206 rep_matcher_(rep_matcher),
1207 base_matcher_(base_matcher),
1208 index_matcher_(index_matcher),
1209 effect_matcher_(effect_matcher),
1210 control_matcher_(control_matcher) {}
1211
DescribeTo(std::ostream * os) const1212 void DescribeTo(std::ostream* os) const final {
1213 NodeMatcher::DescribeTo(os);
1214 *os << " whose rep (";
1215 rep_matcher_.DescribeTo(os);
1216 *os << "), base (";
1217 base_matcher_.DescribeTo(os);
1218 *os << "), index (";
1219 index_matcher_.DescribeTo(os);
1220 *os << "), effect (";
1221 effect_matcher_.DescribeTo(os);
1222 *os << ") and control (";
1223 control_matcher_.DescribeTo(os);
1224 *os << ")";
1225 }
1226
MatchAndExplain(Node * node,MatchResultListener * listener) const1227 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1228 Node* effect_node = nullptr;
1229 Node* control_node = nullptr;
1230 if (NodeProperties::FirstEffectIndex(node) < node->InputCount()) {
1231 effect_node = NodeProperties::GetEffectInput(node);
1232 }
1233 if (NodeProperties::FirstControlIndex(node) < node->InputCount()) {
1234 control_node = NodeProperties::GetControlInput(node);
1235 }
1236 return (NodeMatcher::MatchAndExplain(node, listener) &&
1237 PrintMatchAndExplain(OpParameter<LoadRepresentation>(node), "rep",
1238 rep_matcher_, listener) &&
1239 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
1240 base_matcher_, listener) &&
1241 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
1242 "index", index_matcher_, listener) &&
1243 PrintMatchAndExplain(effect_node, "effect", effect_matcher_,
1244 listener) &&
1245 PrintMatchAndExplain(control_node, "control", control_matcher_,
1246 listener));
1247 }
1248
1249 private:
1250 const Matcher<LoadRepresentation> rep_matcher_;
1251 const Matcher<Node*> base_matcher_;
1252 const Matcher<Node*> index_matcher_;
1253 const Matcher<Node*> effect_matcher_;
1254 const Matcher<Node*> control_matcher_;
1255 };
1256
1257
1258 class IsStoreMatcher final : public NodeMatcher {
1259 public:
IsStoreMatcher(const Matcher<StoreRepresentation> & rep_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & index_matcher,const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1260 IsStoreMatcher(const Matcher<StoreRepresentation>& rep_matcher,
1261 const Matcher<Node*>& base_matcher,
1262 const Matcher<Node*>& index_matcher,
1263 const Matcher<Node*>& value_matcher,
1264 const Matcher<Node*>& effect_matcher,
1265 const Matcher<Node*>& control_matcher)
1266 : NodeMatcher(IrOpcode::kStore),
1267 rep_matcher_(rep_matcher),
1268 base_matcher_(base_matcher),
1269 index_matcher_(index_matcher),
1270 value_matcher_(value_matcher),
1271 effect_matcher_(effect_matcher),
1272 control_matcher_(control_matcher) {}
1273
DescribeTo(std::ostream * os) const1274 void DescribeTo(std::ostream* os) const final {
1275 NodeMatcher::DescribeTo(os);
1276 *os << " whose rep (";
1277 rep_matcher_.DescribeTo(os);
1278 *os << "), base (";
1279 base_matcher_.DescribeTo(os);
1280 *os << "), index (";
1281 index_matcher_.DescribeTo(os);
1282 *os << "), value (";
1283 value_matcher_.DescribeTo(os);
1284 *os << "), effect (";
1285 effect_matcher_.DescribeTo(os);
1286 *os << ") and control (";
1287 control_matcher_.DescribeTo(os);
1288 *os << ")";
1289 }
1290
MatchAndExplain(Node * node,MatchResultListener * listener) const1291 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1292 Node* effect_node = nullptr;
1293 Node* control_node = nullptr;
1294 if (NodeProperties::FirstEffectIndex(node) < node->InputCount()) {
1295 effect_node = NodeProperties::GetEffectInput(node);
1296 }
1297 if (NodeProperties::FirstControlIndex(node) < node->InputCount()) {
1298 control_node = NodeProperties::GetControlInput(node);
1299 }
1300 return (NodeMatcher::MatchAndExplain(node, listener) &&
1301 PrintMatchAndExplain(OpParameter<StoreRepresentation>(node), "rep",
1302 rep_matcher_, listener) &&
1303 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
1304 base_matcher_, listener) &&
1305 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
1306 "index", index_matcher_, listener) &&
1307 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
1308 "value", value_matcher_, listener) &&
1309 PrintMatchAndExplain(effect_node, "effect", effect_matcher_,
1310 listener) &&
1311 PrintMatchAndExplain(control_node, "control", control_matcher_,
1312 listener));
1313 }
1314
1315 private:
1316 const Matcher<StoreRepresentation> rep_matcher_;
1317 const Matcher<Node*> base_matcher_;
1318 const Matcher<Node*> index_matcher_;
1319 const Matcher<Node*> value_matcher_;
1320 const Matcher<Node*> effect_matcher_;
1321 const Matcher<Node*> control_matcher_;
1322 };
1323
1324 class IsStackSlotMatcher final : public NodeMatcher {
1325 public:
IsStackSlotMatcher(const Matcher<MachineRepresentation> & rep_matcher)1326 explicit IsStackSlotMatcher(const Matcher<MachineRepresentation>& rep_matcher)
1327 : NodeMatcher(IrOpcode::kStackSlot), rep_matcher_(rep_matcher) {}
1328
DescribeTo(std::ostream * os) const1329 void DescribeTo(std::ostream* os) const final {
1330 NodeMatcher::DescribeTo(os);
1331 *os << " whose rep (";
1332 rep_matcher_.DescribeTo(os);
1333 *os << ")";
1334 }
1335
MatchAndExplain(Node * node,MatchResultListener * listener) const1336 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1337 return (NodeMatcher::MatchAndExplain(node, listener) &&
1338 PrintMatchAndExplain(OpParameter<MachineRepresentation>(node),
1339 "rep", rep_matcher_, listener));
1340 }
1341
1342 private:
1343 const Matcher<MachineRepresentation> rep_matcher_;
1344 };
1345
1346 class IsTypeGuardMatcher final : public NodeMatcher {
1347 public:
IsTypeGuardMatcher(const Matcher<Type * > & type_matcher,const Matcher<Node * > & value_matcher,const Matcher<Node * > & control_matcher)1348 IsTypeGuardMatcher(const Matcher<Type*>& type_matcher,
1349 const Matcher<Node*>& value_matcher,
1350 const Matcher<Node*>& control_matcher)
1351 : NodeMatcher(IrOpcode::kTypeGuard),
1352 type_matcher_(type_matcher),
1353 value_matcher_(value_matcher),
1354 control_matcher_(control_matcher) {}
1355
MatchAndExplain(Node * node,MatchResultListener * listener) const1356 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1357 return (NodeMatcher::MatchAndExplain(node, listener) &&
1358 PrintMatchAndExplain(OpParameter<Type*>(node->op()), "type",
1359 type_matcher_, listener) &&
1360 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
1361 "value", value_matcher_, listener) &&
1362 PrintMatchAndExplain(NodeProperties::GetControlInput(node, 0),
1363 "control", control_matcher_, listener));
1364 }
1365
1366 private:
1367 const Matcher<Type*> type_matcher_;
1368 const Matcher<Node*> value_matcher_;
1369 const Matcher<Node*> control_matcher_;
1370 };
1371
1372 class IsToNumberMatcher final : public NodeMatcher {
1373 public:
IsToNumberMatcher(const Matcher<Node * > & base_matcher,const Matcher<Node * > & context_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1374 IsToNumberMatcher(const Matcher<Node*>& base_matcher,
1375 const Matcher<Node*>& context_matcher,
1376 const Matcher<Node*>& effect_matcher,
1377 const Matcher<Node*>& control_matcher)
1378 : NodeMatcher(IrOpcode::kJSToNumber),
1379 base_matcher_(base_matcher),
1380 context_matcher_(context_matcher),
1381 effect_matcher_(effect_matcher),
1382 control_matcher_(control_matcher) {}
1383
DescribeTo(std::ostream * os) const1384 void DescribeTo(std::ostream* os) const final {
1385 NodeMatcher::DescribeTo(os);
1386 *os << " whose base (";
1387 base_matcher_.DescribeTo(os);
1388 *os << "), context (";
1389 context_matcher_.DescribeTo(os);
1390 *os << "), effect (";
1391 effect_matcher_.DescribeTo(os);
1392 *os << ") and control (";
1393 control_matcher_.DescribeTo(os);
1394 *os << ")";
1395 }
1396
MatchAndExplain(Node * node,MatchResultListener * listener) const1397 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1398 return (NodeMatcher::MatchAndExplain(node, listener) &&
1399 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
1400 base_matcher_, listener) &&
1401 PrintMatchAndExplain(NodeProperties::GetContextInput(node),
1402 "context", context_matcher_, listener) &&
1403 PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
1404 effect_matcher_, listener) &&
1405 PrintMatchAndExplain(NodeProperties::GetControlInput(node),
1406 "control", control_matcher_, listener));
1407 }
1408
1409 private:
1410 const Matcher<Node*> base_matcher_;
1411 const Matcher<Node*> context_matcher_;
1412 const Matcher<Node*> effect_matcher_;
1413 const Matcher<Node*> control_matcher_;
1414 };
1415
1416
1417 class IsLoadContextMatcher final : public NodeMatcher {
1418 public:
IsLoadContextMatcher(const Matcher<ContextAccess> & access_matcher,const Matcher<Node * > & context_matcher)1419 IsLoadContextMatcher(const Matcher<ContextAccess>& access_matcher,
1420 const Matcher<Node*>& context_matcher)
1421 : NodeMatcher(IrOpcode::kJSLoadContext),
1422 access_matcher_(access_matcher),
1423 context_matcher_(context_matcher) {}
1424
DescribeTo(std::ostream * os) const1425 void DescribeTo(std::ostream* os) const final {
1426 NodeMatcher::DescribeTo(os);
1427 *os << " whose access (";
1428 access_matcher_.DescribeTo(os);
1429 *os << ") and context (";
1430 context_matcher_.DescribeTo(os);
1431 *os << ")";
1432 }
1433
MatchAndExplain(Node * node,MatchResultListener * listener) const1434 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1435 return (NodeMatcher::MatchAndExplain(node, listener) &&
1436 PrintMatchAndExplain(OpParameter<ContextAccess>(node), "access",
1437 access_matcher_, listener) &&
1438 PrintMatchAndExplain(NodeProperties::GetContextInput(node),
1439 "context", context_matcher_, listener));
1440 }
1441
1442 private:
1443 const Matcher<ContextAccess> access_matcher_;
1444 const Matcher<Node*> context_matcher_;
1445 };
1446
1447 class IsQuadopMatcher final : public NodeMatcher {
1448 public:
IsQuadopMatcher(IrOpcode::Value opcode,const Matcher<Node * > & a_matcher,const Matcher<Node * > & b_matcher,const Matcher<Node * > & c_matcher,const Matcher<Node * > & d_matcher)1449 IsQuadopMatcher(IrOpcode::Value opcode, const Matcher<Node*>& a_matcher,
1450 const Matcher<Node*>& b_matcher,
1451 const Matcher<Node*>& c_matcher,
1452 const Matcher<Node*>& d_matcher)
1453 : NodeMatcher(opcode),
1454 a_matcher_(a_matcher),
1455 b_matcher_(b_matcher),
1456 c_matcher_(c_matcher),
1457 d_matcher_(d_matcher) {}
1458
DescribeTo(std::ostream * os) const1459 void DescribeTo(std::ostream* os) const final {
1460 NodeMatcher::DescribeTo(os);
1461 *os << " whose a (";
1462 a_matcher_.DescribeTo(os);
1463 *os << ") and b (";
1464 b_matcher_.DescribeTo(os);
1465 *os << ") and c (";
1466 c_matcher_.DescribeTo(os);
1467 *os << ") and d (";
1468 d_matcher_.DescribeTo(os);
1469 *os << ")";
1470 }
1471
MatchAndExplain(Node * node,MatchResultListener * listener) const1472 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1473 return (NodeMatcher::MatchAndExplain(node, listener) &&
1474 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "a",
1475 a_matcher_, listener) &&
1476 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1), "b",
1477 b_matcher_, listener) &&
1478 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2), "c",
1479 c_matcher_, listener) &&
1480 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 3), "d",
1481 d_matcher_, listener));
1482 }
1483
1484 private:
1485 const Matcher<Node*> a_matcher_;
1486 const Matcher<Node*> b_matcher_;
1487 const Matcher<Node*> c_matcher_;
1488 const Matcher<Node*> d_matcher_;
1489 };
1490
1491 class IsTernopMatcher final : public NodeMatcher {
1492 public:
IsTernopMatcher(IrOpcode::Value opcode,const Matcher<Node * > & lhs_matcher,const Matcher<Node * > & mid_matcher,const Matcher<Node * > & rhs_matcher)1493 IsTernopMatcher(IrOpcode::Value opcode, const Matcher<Node*>& lhs_matcher,
1494 const Matcher<Node*>& mid_matcher,
1495 const Matcher<Node*>& rhs_matcher)
1496 : NodeMatcher(opcode),
1497 lhs_matcher_(lhs_matcher),
1498 mid_matcher_(mid_matcher),
1499 rhs_matcher_(rhs_matcher) {}
1500
DescribeTo(std::ostream * os) const1501 void DescribeTo(std::ostream* os) const final {
1502 NodeMatcher::DescribeTo(os);
1503 *os << " whose lhs (";
1504 lhs_matcher_.DescribeTo(os);
1505 *os << ") and mid (";
1506 mid_matcher_.DescribeTo(os);
1507 *os << ") and rhs (";
1508 rhs_matcher_.DescribeTo(os);
1509 *os << ")";
1510 }
1511
MatchAndExplain(Node * node,MatchResultListener * listener) const1512 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1513 return (NodeMatcher::MatchAndExplain(node, listener) &&
1514 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "lhs",
1515 lhs_matcher_, listener) &&
1516 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1), "mid",
1517 mid_matcher_, listener) &&
1518 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2), "rhs",
1519 rhs_matcher_, listener));
1520 }
1521
1522 private:
1523 const Matcher<Node*> lhs_matcher_;
1524 const Matcher<Node*> mid_matcher_;
1525 const Matcher<Node*> rhs_matcher_;
1526 };
1527
1528 class IsBinopMatcher final : public NodeMatcher {
1529 public:
IsBinopMatcher(IrOpcode::Value opcode,const Matcher<Node * > & lhs_matcher,const Matcher<Node * > & rhs_matcher)1530 IsBinopMatcher(IrOpcode::Value opcode, const Matcher<Node*>& lhs_matcher,
1531 const Matcher<Node*>& rhs_matcher)
1532 : NodeMatcher(opcode),
1533 lhs_matcher_(lhs_matcher),
1534 rhs_matcher_(rhs_matcher) {}
1535
DescribeTo(std::ostream * os) const1536 void DescribeTo(std::ostream* os) const final {
1537 NodeMatcher::DescribeTo(os);
1538 *os << " whose lhs (";
1539 lhs_matcher_.DescribeTo(os);
1540 *os << ") and rhs (";
1541 rhs_matcher_.DescribeTo(os);
1542 *os << ")";
1543 }
1544
MatchAndExplain(Node * node,MatchResultListener * listener) const1545 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1546 return (NodeMatcher::MatchAndExplain(node, listener) &&
1547 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "lhs",
1548 lhs_matcher_, listener) &&
1549 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1), "rhs",
1550 rhs_matcher_, listener));
1551 }
1552
1553 private:
1554 const Matcher<Node*> lhs_matcher_;
1555 const Matcher<Node*> rhs_matcher_;
1556 };
1557
1558
1559 class IsUnopMatcher final : public NodeMatcher {
1560 public:
IsUnopMatcher(IrOpcode::Value opcode,const Matcher<Node * > & input_matcher)1561 IsUnopMatcher(IrOpcode::Value opcode, const Matcher<Node*>& input_matcher)
1562 : NodeMatcher(opcode), input_matcher_(input_matcher) {}
1563
DescribeTo(std::ostream * os) const1564 void DescribeTo(std::ostream* os) const final {
1565 NodeMatcher::DescribeTo(os);
1566 *os << " whose input (";
1567 input_matcher_.DescribeTo(os);
1568 *os << ")";
1569 }
1570
MatchAndExplain(Node * node,MatchResultListener * listener) const1571 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1572 return (NodeMatcher::MatchAndExplain(node, listener) &&
1573 PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
1574 "input", input_matcher_, listener));
1575 }
1576
1577 private:
1578 const Matcher<Node*> input_matcher_;
1579 };
1580
1581
1582 class IsParameterMatcher final : public NodeMatcher {
1583 public:
IsParameterMatcher(const Matcher<int> & index_matcher)1584 explicit IsParameterMatcher(const Matcher<int>& index_matcher)
1585 : NodeMatcher(IrOpcode::kParameter), index_matcher_(index_matcher) {}
1586
DescribeTo(std::ostream * os) const1587 void DescribeTo(std::ostream* os) const override {
1588 *os << "is a Parameter node with index(";
1589 index_matcher_.DescribeTo(os);
1590 *os << ")";
1591 }
1592
MatchAndExplain(Node * node,MatchResultListener * listener) const1593 bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
1594 return (NodeMatcher::MatchAndExplain(node, listener) &&
1595 PrintMatchAndExplain(ParameterIndexOf(node->op()), "index",
1596 index_matcher_, listener));
1597 }
1598
1599 private:
1600 const Matcher<int> index_matcher_;
1601 };
1602
1603 } // namespace
1604
IsDead()1605 Matcher<Node*> IsDead() {
1606 return MakeMatcher(new NodeMatcher(IrOpcode::kDead));
1607 }
1608
IsEnd(const Matcher<Node * > & control0_matcher)1609 Matcher<Node*> IsEnd(const Matcher<Node*>& control0_matcher) {
1610 return MakeMatcher(new IsControl1Matcher(IrOpcode::kEnd, control0_matcher));
1611 }
1612
1613
IsEnd(const Matcher<Node * > & control0_matcher,const Matcher<Node * > & control1_matcher)1614 Matcher<Node*> IsEnd(const Matcher<Node*>& control0_matcher,
1615 const Matcher<Node*>& control1_matcher) {
1616 return MakeMatcher(new IsControl2Matcher(IrOpcode::kEnd, control0_matcher,
1617 control1_matcher));
1618 }
1619
1620
IsEnd(const Matcher<Node * > & control0_matcher,const Matcher<Node * > & control1_matcher,const Matcher<Node * > & control2_matcher)1621 Matcher<Node*> IsEnd(const Matcher<Node*>& control0_matcher,
1622 const Matcher<Node*>& control1_matcher,
1623 const Matcher<Node*>& control2_matcher) {
1624 return MakeMatcher(new IsControl3Matcher(IrOpcode::kEnd, control0_matcher,
1625 control1_matcher, control2_matcher));
1626 }
1627
1628
IsBranch(const Matcher<Node * > & value_matcher,const Matcher<Node * > & control_matcher)1629 Matcher<Node*> IsBranch(const Matcher<Node*>& value_matcher,
1630 const Matcher<Node*>& control_matcher) {
1631 return MakeMatcher(new IsBranchMatcher(value_matcher, control_matcher));
1632 }
1633
1634
IsMerge(const Matcher<Node * > & control0_matcher,const Matcher<Node * > & control1_matcher)1635 Matcher<Node*> IsMerge(const Matcher<Node*>& control0_matcher,
1636 const Matcher<Node*>& control1_matcher) {
1637 return MakeMatcher(new IsControl2Matcher(IrOpcode::kMerge, control0_matcher,
1638 control1_matcher));
1639 }
1640
1641
IsMerge(const Matcher<Node * > & control0_matcher,const Matcher<Node * > & control1_matcher,const Matcher<Node * > & control2_matcher)1642 Matcher<Node*> IsMerge(const Matcher<Node*>& control0_matcher,
1643 const Matcher<Node*>& control1_matcher,
1644 const Matcher<Node*>& control2_matcher) {
1645 return MakeMatcher(new IsControl3Matcher(IrOpcode::kMerge, control0_matcher,
1646 control1_matcher, control2_matcher));
1647 }
1648
1649
IsLoop(const Matcher<Node * > & control0_matcher,const Matcher<Node * > & control1_matcher)1650 Matcher<Node*> IsLoop(const Matcher<Node*>& control0_matcher,
1651 const Matcher<Node*>& control1_matcher) {
1652 return MakeMatcher(new IsControl2Matcher(IrOpcode::kLoop, control0_matcher,
1653 control1_matcher));
1654 }
1655
1656
IsLoop(const Matcher<Node * > & control0_matcher,const Matcher<Node * > & control1_matcher,const Matcher<Node * > & control2_matcher)1657 Matcher<Node*> IsLoop(const Matcher<Node*>& control0_matcher,
1658 const Matcher<Node*>& control1_matcher,
1659 const Matcher<Node*>& control2_matcher) {
1660 return MakeMatcher(new IsControl3Matcher(IrOpcode::kLoop, control0_matcher,
1661 control1_matcher, control2_matcher));
1662 }
1663
1664
IsIfTrue(const Matcher<Node * > & control_matcher)1665 Matcher<Node*> IsIfTrue(const Matcher<Node*>& control_matcher) {
1666 return MakeMatcher(new IsControl1Matcher(IrOpcode::kIfTrue, control_matcher));
1667 }
1668
1669
IsIfFalse(const Matcher<Node * > & control_matcher)1670 Matcher<Node*> IsIfFalse(const Matcher<Node*>& control_matcher) {
1671 return MakeMatcher(
1672 new IsControl1Matcher(IrOpcode::kIfFalse, control_matcher));
1673 }
1674
1675
IsIfSuccess(const Matcher<Node * > & control_matcher)1676 Matcher<Node*> IsIfSuccess(const Matcher<Node*>& control_matcher) {
1677 return MakeMatcher(
1678 new IsControl1Matcher(IrOpcode::kIfSuccess, control_matcher));
1679 }
1680
1681
IsSwitch(const Matcher<Node * > & value_matcher,const Matcher<Node * > & control_matcher)1682 Matcher<Node*> IsSwitch(const Matcher<Node*>& value_matcher,
1683 const Matcher<Node*>& control_matcher) {
1684 return MakeMatcher(new IsSwitchMatcher(value_matcher, control_matcher));
1685 }
1686
1687
IsIfValue(const Matcher<int32_t> & value_matcher,const Matcher<Node * > & control_matcher)1688 Matcher<Node*> IsIfValue(const Matcher<int32_t>& value_matcher,
1689 const Matcher<Node*>& control_matcher) {
1690 return MakeMatcher(new IsIfValueMatcher(value_matcher, control_matcher));
1691 }
1692
1693
IsIfDefault(const Matcher<Node * > & control_matcher)1694 Matcher<Node*> IsIfDefault(const Matcher<Node*>& control_matcher) {
1695 return MakeMatcher(
1696 new IsControl1Matcher(IrOpcode::kIfDefault, control_matcher));
1697 }
1698
1699
IsBeginRegion(const Matcher<Node * > & effect_matcher)1700 Matcher<Node*> IsBeginRegion(const Matcher<Node*>& effect_matcher) {
1701 return MakeMatcher(new IsBeginRegionMatcher(effect_matcher));
1702 }
1703
1704
IsFinishRegion(const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher)1705 Matcher<Node*> IsFinishRegion(const Matcher<Node*>& value_matcher,
1706 const Matcher<Node*>& effect_matcher) {
1707 return MakeMatcher(new IsFinishRegionMatcher(value_matcher, effect_matcher));
1708 }
1709
1710
IsReturn(const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1711 Matcher<Node*> IsReturn(const Matcher<Node*>& value_matcher,
1712 const Matcher<Node*>& effect_matcher,
1713 const Matcher<Node*>& control_matcher) {
1714 return MakeMatcher(
1715 new IsReturnMatcher(value_matcher, effect_matcher, control_matcher));
1716 }
1717
IsReturn2(const Matcher<Node * > & value_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1718 Matcher<Node*> IsReturn2(const Matcher<Node*>& value_matcher,
1719 const Matcher<Node*>& value2_matcher,
1720 const Matcher<Node*>& effect_matcher,
1721 const Matcher<Node*>& control_matcher) {
1722 return MakeMatcher(new IsReturnMatcher(value_matcher, value2_matcher,
1723 effect_matcher, control_matcher));
1724 }
1725
IsTerminate(const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1726 Matcher<Node*> IsTerminate(const Matcher<Node*>& effect_matcher,
1727 const Matcher<Node*>& control_matcher) {
1728 return MakeMatcher(new IsTerminateMatcher(effect_matcher, control_matcher));
1729 }
1730
1731
IsExternalConstant(const Matcher<ExternalReference> & value_matcher)1732 Matcher<Node*> IsExternalConstant(
1733 const Matcher<ExternalReference>& value_matcher) {
1734 return MakeMatcher(new IsConstantMatcher<ExternalReference>(
1735 IrOpcode::kExternalConstant, value_matcher));
1736 }
1737
1738
IsHeapConstant(Handle<HeapObject> value)1739 Matcher<Node*> IsHeapConstant(Handle<HeapObject> value) {
1740 return MakeMatcher(new IsConstantMatcher<Handle<HeapObject>>(
1741 IrOpcode::kHeapConstant, value));
1742 }
1743
1744
IsInt32Constant(const Matcher<int32_t> & value_matcher)1745 Matcher<Node*> IsInt32Constant(const Matcher<int32_t>& value_matcher) {
1746 return MakeMatcher(
1747 new IsConstantMatcher<int32_t>(IrOpcode::kInt32Constant, value_matcher));
1748 }
1749
1750
IsInt64Constant(const Matcher<int64_t> & value_matcher)1751 Matcher<Node*> IsInt64Constant(const Matcher<int64_t>& value_matcher) {
1752 return MakeMatcher(
1753 new IsConstantMatcher<int64_t>(IrOpcode::kInt64Constant, value_matcher));
1754 }
1755
1756
IsFloat32Constant(const Matcher<float> & value_matcher)1757 Matcher<Node*> IsFloat32Constant(const Matcher<float>& value_matcher) {
1758 return MakeMatcher(
1759 new IsConstantMatcher<float>(IrOpcode::kFloat32Constant, value_matcher));
1760 }
1761
1762
IsFloat64Constant(const Matcher<double> & value_matcher)1763 Matcher<Node*> IsFloat64Constant(const Matcher<double>& value_matcher) {
1764 return MakeMatcher(
1765 new IsConstantMatcher<double>(IrOpcode::kFloat64Constant, value_matcher));
1766 }
1767
1768
IsNumberConstant(const Matcher<double> & value_matcher)1769 Matcher<Node*> IsNumberConstant(const Matcher<double>& value_matcher) {
1770 return MakeMatcher(
1771 new IsConstantMatcher<double>(IrOpcode::kNumberConstant, value_matcher));
1772 }
1773
1774
IsSelect(const Matcher<MachineRepresentation> & type_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher)1775 Matcher<Node*> IsSelect(const Matcher<MachineRepresentation>& type_matcher,
1776 const Matcher<Node*>& value0_matcher,
1777 const Matcher<Node*>& value1_matcher,
1778 const Matcher<Node*>& value2_matcher) {
1779 return MakeMatcher(new IsSelectMatcher(type_matcher, value0_matcher,
1780 value1_matcher, value2_matcher));
1781 }
1782
1783
IsPhi(const Matcher<MachineRepresentation> & type_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & merge_matcher)1784 Matcher<Node*> IsPhi(const Matcher<MachineRepresentation>& type_matcher,
1785 const Matcher<Node*>& value0_matcher,
1786 const Matcher<Node*>& value1_matcher,
1787 const Matcher<Node*>& merge_matcher) {
1788 return MakeMatcher(new IsPhiMatcher(type_matcher, value0_matcher,
1789 value1_matcher, merge_matcher));
1790 }
1791
1792
IsPhi(const Matcher<MachineRepresentation> & type_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & merge_matcher)1793 Matcher<Node*> IsPhi(const Matcher<MachineRepresentation>& type_matcher,
1794 const Matcher<Node*>& value0_matcher,
1795 const Matcher<Node*>& value1_matcher,
1796 const Matcher<Node*>& value2_matcher,
1797 const Matcher<Node*>& merge_matcher) {
1798 return MakeMatcher(new IsPhi2Matcher(type_matcher, value0_matcher,
1799 value1_matcher, value2_matcher,
1800 merge_matcher));
1801 }
1802
1803
IsEffectPhi(const Matcher<Node * > & effect0_matcher,const Matcher<Node * > & effect1_matcher,const Matcher<Node * > & merge_matcher)1804 Matcher<Node*> IsEffectPhi(const Matcher<Node*>& effect0_matcher,
1805 const Matcher<Node*>& effect1_matcher,
1806 const Matcher<Node*>& merge_matcher) {
1807 return MakeMatcher(
1808 new IsEffectPhiMatcher(effect0_matcher, effect1_matcher, merge_matcher));
1809 }
1810
1811
IsProjection(const Matcher<size_t> & index_matcher,const Matcher<Node * > & base_matcher)1812 Matcher<Node*> IsProjection(const Matcher<size_t>& index_matcher,
1813 const Matcher<Node*>& base_matcher) {
1814 return MakeMatcher(new IsProjectionMatcher(index_matcher, base_matcher));
1815 }
1816
IsCall(const Matcher<const CallDescriptor * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1817 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
1818 const Matcher<Node*>& value0_matcher,
1819 const Matcher<Node*>& effect_matcher,
1820 const Matcher<Node*>& control_matcher) {
1821 std::vector<Matcher<Node*>> value_matchers;
1822 value_matchers.push_back(value0_matcher);
1823 return MakeMatcher(new IsCallMatcher(descriptor_matcher, value_matchers,
1824 effect_matcher, control_matcher));
1825 }
1826
IsCall(const Matcher<const CallDescriptor * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1827 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
1828 const Matcher<Node*>& value0_matcher,
1829 const Matcher<Node*>& value1_matcher,
1830 const Matcher<Node*>& effect_matcher,
1831 const Matcher<Node*>& control_matcher) {
1832 std::vector<Matcher<Node*>> value_matchers;
1833 value_matchers.push_back(value0_matcher);
1834 value_matchers.push_back(value1_matcher);
1835 return MakeMatcher(new IsCallMatcher(descriptor_matcher, value_matchers,
1836 effect_matcher, control_matcher));
1837 }
1838
1839
IsCall(const Matcher<const CallDescriptor * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1840 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
1841 const Matcher<Node*>& value0_matcher,
1842 const Matcher<Node*>& value1_matcher,
1843 const Matcher<Node*>& value2_matcher,
1844 const Matcher<Node*>& effect_matcher,
1845 const Matcher<Node*>& control_matcher) {
1846 std::vector<Matcher<Node*>> value_matchers;
1847 value_matchers.push_back(value0_matcher);
1848 value_matchers.push_back(value1_matcher);
1849 value_matchers.push_back(value2_matcher);
1850 return MakeMatcher(new IsCallMatcher(descriptor_matcher, value_matchers,
1851 effect_matcher, control_matcher));
1852 }
1853
1854
IsCall(const Matcher<const CallDescriptor * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & value3_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1855 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
1856 const Matcher<Node*>& value0_matcher,
1857 const Matcher<Node*>& value1_matcher,
1858 const Matcher<Node*>& value2_matcher,
1859 const Matcher<Node*>& value3_matcher,
1860 const Matcher<Node*>& effect_matcher,
1861 const Matcher<Node*>& control_matcher) {
1862 std::vector<Matcher<Node*>> value_matchers;
1863 value_matchers.push_back(value0_matcher);
1864 value_matchers.push_back(value1_matcher);
1865 value_matchers.push_back(value2_matcher);
1866 value_matchers.push_back(value3_matcher);
1867 return MakeMatcher(new IsCallMatcher(descriptor_matcher, value_matchers,
1868 effect_matcher, control_matcher));
1869 }
1870
1871
IsCall(const Matcher<const CallDescriptor * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & value3_matcher,const Matcher<Node * > & value4_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1872 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
1873 const Matcher<Node*>& value0_matcher,
1874 const Matcher<Node*>& value1_matcher,
1875 const Matcher<Node*>& value2_matcher,
1876 const Matcher<Node*>& value3_matcher,
1877 const Matcher<Node*>& value4_matcher,
1878 const Matcher<Node*>& effect_matcher,
1879 const Matcher<Node*>& control_matcher) {
1880 std::vector<Matcher<Node*>> value_matchers;
1881 value_matchers.push_back(value0_matcher);
1882 value_matchers.push_back(value1_matcher);
1883 value_matchers.push_back(value2_matcher);
1884 value_matchers.push_back(value3_matcher);
1885 value_matchers.push_back(value4_matcher);
1886 return MakeMatcher(new IsCallMatcher(descriptor_matcher, value_matchers,
1887 effect_matcher, control_matcher));
1888 }
1889
1890
IsCall(const Matcher<const CallDescriptor * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & value3_matcher,const Matcher<Node * > & value4_matcher,const Matcher<Node * > & value5_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1891 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
1892 const Matcher<Node*>& value0_matcher,
1893 const Matcher<Node*>& value1_matcher,
1894 const Matcher<Node*>& value2_matcher,
1895 const Matcher<Node*>& value3_matcher,
1896 const Matcher<Node*>& value4_matcher,
1897 const Matcher<Node*>& value5_matcher,
1898 const Matcher<Node*>& effect_matcher,
1899 const Matcher<Node*>& control_matcher) {
1900 std::vector<Matcher<Node*>> value_matchers;
1901 value_matchers.push_back(value0_matcher);
1902 value_matchers.push_back(value1_matcher);
1903 value_matchers.push_back(value2_matcher);
1904 value_matchers.push_back(value3_matcher);
1905 value_matchers.push_back(value4_matcher);
1906 value_matchers.push_back(value5_matcher);
1907 return MakeMatcher(new IsCallMatcher(descriptor_matcher, value_matchers,
1908 effect_matcher, control_matcher));
1909 }
1910
1911
IsCall(const Matcher<const CallDescriptor * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & value3_matcher,const Matcher<Node * > & value4_matcher,const Matcher<Node * > & value5_matcher,const Matcher<Node * > & value6_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1912 Matcher<Node*> IsCall(
1913 const Matcher<const CallDescriptor*>& descriptor_matcher,
1914 const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
1915 const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
1916 const Matcher<Node*>& value4_matcher, const Matcher<Node*>& value5_matcher,
1917 const Matcher<Node*>& value6_matcher, const Matcher<Node*>& effect_matcher,
1918 const Matcher<Node*>& control_matcher) {
1919 std::vector<Matcher<Node*>> value_matchers;
1920 value_matchers.push_back(value0_matcher);
1921 value_matchers.push_back(value1_matcher);
1922 value_matchers.push_back(value2_matcher);
1923 value_matchers.push_back(value3_matcher);
1924 value_matchers.push_back(value4_matcher);
1925 value_matchers.push_back(value5_matcher);
1926 value_matchers.push_back(value6_matcher);
1927 return MakeMatcher(new IsCallMatcher(descriptor_matcher, value_matchers,
1928 effect_matcher, control_matcher));
1929 }
1930
1931
IsTailCall(const Matcher<CallDescriptor const * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1932 Matcher<Node*> IsTailCall(
1933 const Matcher<CallDescriptor const*>& descriptor_matcher,
1934 const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
1935 const Matcher<Node*>& effect_matcher,
1936 const Matcher<Node*>& control_matcher) {
1937 std::vector<Matcher<Node*>> value_matchers;
1938 value_matchers.push_back(value0_matcher);
1939 value_matchers.push_back(value1_matcher);
1940 return MakeMatcher(new IsTailCallMatcher(descriptor_matcher, value_matchers,
1941 effect_matcher, control_matcher));
1942 }
1943
1944
IsTailCall(const Matcher<CallDescriptor const * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1945 Matcher<Node*> IsTailCall(
1946 const Matcher<CallDescriptor const*>& descriptor_matcher,
1947 const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
1948 const Matcher<Node*>& value2_matcher, const Matcher<Node*>& effect_matcher,
1949 const Matcher<Node*>& control_matcher) {
1950 std::vector<Matcher<Node*>> value_matchers;
1951 value_matchers.push_back(value0_matcher);
1952 value_matchers.push_back(value1_matcher);
1953 value_matchers.push_back(value2_matcher);
1954 return MakeMatcher(new IsTailCallMatcher(descriptor_matcher, value_matchers,
1955 effect_matcher, control_matcher));
1956 }
1957
1958
IsTailCall(const Matcher<CallDescriptor const * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & value3_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1959 Matcher<Node*> IsTailCall(
1960 const Matcher<CallDescriptor const*>& descriptor_matcher,
1961 const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
1962 const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
1963 const Matcher<Node*>& effect_matcher,
1964 const Matcher<Node*>& control_matcher) {
1965 std::vector<Matcher<Node*>> value_matchers;
1966 value_matchers.push_back(value0_matcher);
1967 value_matchers.push_back(value1_matcher);
1968 value_matchers.push_back(value2_matcher);
1969 value_matchers.push_back(value3_matcher);
1970 return MakeMatcher(new IsTailCallMatcher(descriptor_matcher, value_matchers,
1971 effect_matcher, control_matcher));
1972 }
1973
1974
IsTailCall(const Matcher<CallDescriptor const * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & value3_matcher,const Matcher<Node * > & value4_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1975 Matcher<Node*> IsTailCall(
1976 const Matcher<CallDescriptor const*>& descriptor_matcher,
1977 const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
1978 const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
1979 const Matcher<Node*>& value4_matcher, const Matcher<Node*>& effect_matcher,
1980 const Matcher<Node*>& control_matcher) {
1981 std::vector<Matcher<Node*>> value_matchers;
1982 value_matchers.push_back(value0_matcher);
1983 value_matchers.push_back(value1_matcher);
1984 value_matchers.push_back(value2_matcher);
1985 value_matchers.push_back(value3_matcher);
1986 value_matchers.push_back(value4_matcher);
1987 return MakeMatcher(new IsTailCallMatcher(descriptor_matcher, value_matchers,
1988 effect_matcher, control_matcher));
1989 }
1990
1991
IsTailCall(const Matcher<CallDescriptor const * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & value3_matcher,const Matcher<Node * > & value4_matcher,const Matcher<Node * > & value5_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)1992 Matcher<Node*> IsTailCall(
1993 const Matcher<CallDescriptor const*>& descriptor_matcher,
1994 const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
1995 const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
1996 const Matcher<Node*>& value4_matcher, const Matcher<Node*>& value5_matcher,
1997 const Matcher<Node*>& effect_matcher,
1998 const Matcher<Node*>& control_matcher) {
1999 std::vector<Matcher<Node*>> value_matchers;
2000 value_matchers.push_back(value0_matcher);
2001 value_matchers.push_back(value1_matcher);
2002 value_matchers.push_back(value2_matcher);
2003 value_matchers.push_back(value3_matcher);
2004 value_matchers.push_back(value4_matcher);
2005 value_matchers.push_back(value5_matcher);
2006 return MakeMatcher(new IsTailCallMatcher(descriptor_matcher, value_matchers,
2007 effect_matcher, control_matcher));
2008 }
2009
2010
IsTailCall(const Matcher<CallDescriptor const * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & value3_matcher,const Matcher<Node * > & value4_matcher,const Matcher<Node * > & value5_matcher,const Matcher<Node * > & value6_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2011 Matcher<Node*> IsTailCall(
2012 const Matcher<CallDescriptor const*>& descriptor_matcher,
2013 const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
2014 const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
2015 const Matcher<Node*>& value4_matcher, const Matcher<Node*>& value5_matcher,
2016 const Matcher<Node*>& value6_matcher, const Matcher<Node*>& effect_matcher,
2017 const Matcher<Node*>& control_matcher) {
2018 std::vector<Matcher<Node*>> value_matchers;
2019 value_matchers.push_back(value0_matcher);
2020 value_matchers.push_back(value1_matcher);
2021 value_matchers.push_back(value2_matcher);
2022 value_matchers.push_back(value3_matcher);
2023 value_matchers.push_back(value4_matcher);
2024 value_matchers.push_back(value5_matcher);
2025 value_matchers.push_back(value6_matcher);
2026 return MakeMatcher(new IsTailCallMatcher(descriptor_matcher, value_matchers,
2027 effect_matcher, control_matcher));
2028 }
2029
2030
IsTailCall(const Matcher<CallDescriptor const * > & descriptor_matcher,const Matcher<Node * > & value0_matcher,const Matcher<Node * > & value1_matcher,const Matcher<Node * > & value2_matcher,const Matcher<Node * > & value3_matcher,const Matcher<Node * > & value4_matcher,const Matcher<Node * > & value5_matcher,const Matcher<Node * > & value6_matcher,const Matcher<Node * > & value7_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2031 Matcher<Node*> IsTailCall(
2032 const Matcher<CallDescriptor const*>& descriptor_matcher,
2033 const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
2034 const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
2035 const Matcher<Node*>& value4_matcher, const Matcher<Node*>& value5_matcher,
2036 const Matcher<Node*>& value6_matcher, const Matcher<Node*>& value7_matcher,
2037 const Matcher<Node*>& effect_matcher,
2038 const Matcher<Node*>& control_matcher) {
2039 std::vector<Matcher<Node*>> value_matchers;
2040 value_matchers.push_back(value0_matcher);
2041 value_matchers.push_back(value1_matcher);
2042 value_matchers.push_back(value2_matcher);
2043 value_matchers.push_back(value3_matcher);
2044 value_matchers.push_back(value4_matcher);
2045 value_matchers.push_back(value5_matcher);
2046 value_matchers.push_back(value6_matcher);
2047 value_matchers.push_back(value7_matcher);
2048 return MakeMatcher(new IsTailCallMatcher(descriptor_matcher, value_matchers,
2049 effect_matcher, control_matcher));
2050 }
2051
IsTypeGuard(const Matcher<Type * > & type_matcher,const Matcher<Node * > & value_matcher,const Matcher<Node * > & control_matcher)2052 Matcher<Node*> IsTypeGuard(const Matcher<Type*>& type_matcher,
2053 const Matcher<Node*>& value_matcher,
2054 const Matcher<Node*>& control_matcher) {
2055 return MakeMatcher(
2056 new IsTypeGuardMatcher(type_matcher, value_matcher, control_matcher));
2057 }
2058
IsReferenceEqual(const Matcher<Type * > & type_matcher,const Matcher<Node * > & lhs_matcher,const Matcher<Node * > & rhs_matcher)2059 Matcher<Node*> IsReferenceEqual(const Matcher<Type*>& type_matcher,
2060 const Matcher<Node*>& lhs_matcher,
2061 const Matcher<Node*>& rhs_matcher) {
2062 return MakeMatcher(
2063 new IsReferenceEqualMatcher(type_matcher, lhs_matcher, rhs_matcher));
2064 }
2065
IsSpeculativeNumberAdd(const Matcher<BinaryOperationHints::Hint> & hint_matcher,const Matcher<Node * > & lhs_matcher,const Matcher<Node * > & rhs_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2066 Matcher<Node*> IsSpeculativeNumberAdd(
2067 const Matcher<BinaryOperationHints::Hint>& hint_matcher,
2068 const Matcher<Node*>& lhs_matcher, const Matcher<Node*>& rhs_matcher,
2069 const Matcher<Node*>& effect_matcher,
2070 const Matcher<Node*>& control_matcher) {
2071 return MakeMatcher(new IsSpeculativeBinopMatcher(
2072 IrOpcode::kSpeculativeNumberAdd, hint_matcher, lhs_matcher, rhs_matcher,
2073 effect_matcher, control_matcher));
2074 }
2075
IsSpeculativeNumberSubtract(const Matcher<BinaryOperationHints::Hint> & hint_matcher,const Matcher<Node * > & lhs_matcher,const Matcher<Node * > & rhs_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2076 Matcher<Node*> IsSpeculativeNumberSubtract(
2077 const Matcher<BinaryOperationHints::Hint>& hint_matcher,
2078 const Matcher<Node*>& lhs_matcher, const Matcher<Node*>& rhs_matcher,
2079 const Matcher<Node*>& effect_matcher,
2080 const Matcher<Node*>& control_matcher) {
2081 return MakeMatcher(new IsSpeculativeBinopMatcher(
2082 IrOpcode::kSpeculativeNumberSubtract, hint_matcher, lhs_matcher,
2083 rhs_matcher, effect_matcher, control_matcher));
2084 }
2085
IsAllocate(const Matcher<Node * > & size_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2086 Matcher<Node*> IsAllocate(const Matcher<Node*>& size_matcher,
2087 const Matcher<Node*>& effect_matcher,
2088 const Matcher<Node*>& control_matcher) {
2089 return MakeMatcher(
2090 new IsAllocateMatcher(size_matcher, effect_matcher, control_matcher));
2091 }
2092
2093
IsLoadField(const Matcher<FieldAccess> & access_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2094 Matcher<Node*> IsLoadField(const Matcher<FieldAccess>& access_matcher,
2095 const Matcher<Node*>& base_matcher,
2096 const Matcher<Node*>& effect_matcher,
2097 const Matcher<Node*>& control_matcher) {
2098 return MakeMatcher(new IsLoadFieldMatcher(access_matcher, base_matcher,
2099 effect_matcher, control_matcher));
2100 }
2101
2102
IsStoreField(const Matcher<FieldAccess> & access_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2103 Matcher<Node*> IsStoreField(const Matcher<FieldAccess>& access_matcher,
2104 const Matcher<Node*>& base_matcher,
2105 const Matcher<Node*>& value_matcher,
2106 const Matcher<Node*>& effect_matcher,
2107 const Matcher<Node*>& control_matcher) {
2108 return MakeMatcher(new IsStoreFieldMatcher(access_matcher, base_matcher,
2109 value_matcher, effect_matcher,
2110 control_matcher));
2111 }
2112
2113
IsLoadBuffer(const Matcher<BufferAccess> & access_matcher,const Matcher<Node * > & buffer_matcher,const Matcher<Node * > & offset_matcher,const Matcher<Node * > & length_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2114 Matcher<Node*> IsLoadBuffer(const Matcher<BufferAccess>& access_matcher,
2115 const Matcher<Node*>& buffer_matcher,
2116 const Matcher<Node*>& offset_matcher,
2117 const Matcher<Node*>& length_matcher,
2118 const Matcher<Node*>& effect_matcher,
2119 const Matcher<Node*>& control_matcher) {
2120 return MakeMatcher(new IsLoadBufferMatcher(access_matcher, buffer_matcher,
2121 offset_matcher, length_matcher,
2122 effect_matcher, control_matcher));
2123 }
2124
2125
IsStoreBuffer(const Matcher<BufferAccess> & access_matcher,const Matcher<Node * > & buffer_matcher,const Matcher<Node * > & offset_matcher,const Matcher<Node * > & length_matcher,const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2126 Matcher<Node*> IsStoreBuffer(const Matcher<BufferAccess>& access_matcher,
2127 const Matcher<Node*>& buffer_matcher,
2128 const Matcher<Node*>& offset_matcher,
2129 const Matcher<Node*>& length_matcher,
2130 const Matcher<Node*>& value_matcher,
2131 const Matcher<Node*>& effect_matcher,
2132 const Matcher<Node*>& control_matcher) {
2133 return MakeMatcher(new IsStoreBufferMatcher(
2134 access_matcher, buffer_matcher, offset_matcher, length_matcher,
2135 value_matcher, effect_matcher, control_matcher));
2136 }
2137
2138
IsLoadElement(const Matcher<ElementAccess> & access_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & index_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2139 Matcher<Node*> IsLoadElement(const Matcher<ElementAccess>& access_matcher,
2140 const Matcher<Node*>& base_matcher,
2141 const Matcher<Node*>& index_matcher,
2142 const Matcher<Node*>& effect_matcher,
2143 const Matcher<Node*>& control_matcher) {
2144 return MakeMatcher(new IsLoadElementMatcher(access_matcher, base_matcher,
2145 index_matcher, effect_matcher,
2146 control_matcher));
2147 }
2148
2149
IsStoreElement(const Matcher<ElementAccess> & access_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & index_matcher,const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2150 Matcher<Node*> IsStoreElement(const Matcher<ElementAccess>& access_matcher,
2151 const Matcher<Node*>& base_matcher,
2152 const Matcher<Node*>& index_matcher,
2153 const Matcher<Node*>& value_matcher,
2154 const Matcher<Node*>& effect_matcher,
2155 const Matcher<Node*>& control_matcher) {
2156 return MakeMatcher(new IsStoreElementMatcher(
2157 access_matcher, base_matcher, index_matcher, value_matcher,
2158 effect_matcher, control_matcher));
2159 }
2160
2161
IsLoad(const Matcher<LoadRepresentation> & rep_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & index_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2162 Matcher<Node*> IsLoad(const Matcher<LoadRepresentation>& rep_matcher,
2163 const Matcher<Node*>& base_matcher,
2164 const Matcher<Node*>& index_matcher,
2165 const Matcher<Node*>& effect_matcher,
2166 const Matcher<Node*>& control_matcher) {
2167 return MakeMatcher(new IsLoadMatcher(rep_matcher, base_matcher, index_matcher,
2168 effect_matcher, control_matcher));
2169 }
2170
2171
IsStore(const Matcher<StoreRepresentation> & rep_matcher,const Matcher<Node * > & base_matcher,const Matcher<Node * > & index_matcher,const Matcher<Node * > & value_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2172 Matcher<Node*> IsStore(const Matcher<StoreRepresentation>& rep_matcher,
2173 const Matcher<Node*>& base_matcher,
2174 const Matcher<Node*>& index_matcher,
2175 const Matcher<Node*>& value_matcher,
2176 const Matcher<Node*>& effect_matcher,
2177 const Matcher<Node*>& control_matcher) {
2178 return MakeMatcher(new IsStoreMatcher(rep_matcher, base_matcher,
2179 index_matcher, value_matcher,
2180 effect_matcher, control_matcher));
2181 }
2182
IsStackSlot(const Matcher<MachineRepresentation> & rep_matcher)2183 Matcher<Node*> IsStackSlot(const Matcher<MachineRepresentation>& rep_matcher) {
2184 return MakeMatcher(new IsStackSlotMatcher(rep_matcher));
2185 }
2186
IsToNumber(const Matcher<Node * > & base_matcher,const Matcher<Node * > & context_matcher,const Matcher<Node * > & effect_matcher,const Matcher<Node * > & control_matcher)2187 Matcher<Node*> IsToNumber(const Matcher<Node*>& base_matcher,
2188 const Matcher<Node*>& context_matcher,
2189 const Matcher<Node*>& effect_matcher,
2190 const Matcher<Node*>& control_matcher) {
2191 return MakeMatcher(new IsToNumberMatcher(base_matcher, context_matcher,
2192 effect_matcher, control_matcher));
2193 }
2194
2195
IsLoadContext(const Matcher<ContextAccess> & access_matcher,const Matcher<Node * > & context_matcher)2196 Matcher<Node*> IsLoadContext(const Matcher<ContextAccess>& access_matcher,
2197 const Matcher<Node*>& context_matcher) {
2198 return MakeMatcher(new IsLoadContextMatcher(access_matcher, context_matcher));
2199 }
2200
2201
IsParameter(const Matcher<int> index_matcher)2202 Matcher<Node*> IsParameter(const Matcher<int> index_matcher) {
2203 return MakeMatcher(new IsParameterMatcher(index_matcher));
2204 }
2205
2206
IsLoadFramePointer()2207 Matcher<Node*> IsLoadFramePointer() {
2208 return MakeMatcher(new NodeMatcher(IrOpcode::kLoadFramePointer));
2209 }
2210
IsLoadParentFramePointer()2211 Matcher<Node*> IsLoadParentFramePointer() {
2212 return MakeMatcher(new NodeMatcher(IrOpcode::kLoadParentFramePointer));
2213 }
2214
2215 #define IS_QUADOP_MATCHER(Name) \
2216 Matcher<Node*> Is##Name( \
2217 const Matcher<Node*>& a_matcher, const Matcher<Node*>& b_matcher, \
2218 const Matcher<Node*>& c_matcher, const Matcher<Node*>& d_matcher) { \
2219 return MakeMatcher(new IsQuadopMatcher(IrOpcode::k##Name, a_matcher, \
2220 b_matcher, c_matcher, d_matcher)); \
2221 }
2222
2223 IS_QUADOP_MATCHER(Int32PairAdd)
2224 IS_QUADOP_MATCHER(Int32PairSub)
2225 IS_QUADOP_MATCHER(Int32PairMul)
2226
2227 #define IS_TERNOP_MATCHER(Name) \
2228 Matcher<Node*> Is##Name(const Matcher<Node*>& lhs_matcher, \
2229 const Matcher<Node*>& mid_matcher, \
2230 const Matcher<Node*>& rhs_matcher) { \
2231 return MakeMatcher(new IsTernopMatcher(IrOpcode::k##Name, lhs_matcher, \
2232 mid_matcher, rhs_matcher)); \
2233 }
2234
2235 IS_TERNOP_MATCHER(Word32PairShl)
2236 IS_TERNOP_MATCHER(Word32PairShr)
2237 IS_TERNOP_MATCHER(Word32PairSar)
2238
2239 #define IS_BINOP_MATCHER(Name) \
2240 Matcher<Node*> Is##Name(const Matcher<Node*>& lhs_matcher, \
2241 const Matcher<Node*>& rhs_matcher) { \
2242 return MakeMatcher( \
2243 new IsBinopMatcher(IrOpcode::k##Name, lhs_matcher, rhs_matcher)); \
2244 }
2245 IS_BINOP_MATCHER(NumberEqual)
2246 IS_BINOP_MATCHER(NumberLessThan)
2247 IS_BINOP_MATCHER(NumberSubtract)
2248 IS_BINOP_MATCHER(NumberMultiply)
2249 IS_BINOP_MATCHER(NumberShiftLeft)
2250 IS_BINOP_MATCHER(NumberShiftRight)
2251 IS_BINOP_MATCHER(NumberShiftRightLogical)
2252 IS_BINOP_MATCHER(NumberImul)
2253 IS_BINOP_MATCHER(NumberAtan2)
2254 IS_BINOP_MATCHER(Word32And)
2255 IS_BINOP_MATCHER(Word32Or)
2256 IS_BINOP_MATCHER(Word32Xor)
2257 IS_BINOP_MATCHER(Word32Sar)
2258 IS_BINOP_MATCHER(Word32Shl)
2259 IS_BINOP_MATCHER(Word32Shr)
2260 IS_BINOP_MATCHER(Word32Ror)
2261 IS_BINOP_MATCHER(Word32Equal)
2262 IS_BINOP_MATCHER(Word64And)
2263 IS_BINOP_MATCHER(Word64Or)
2264 IS_BINOP_MATCHER(Word64Sar)
2265 IS_BINOP_MATCHER(Word64Shl)
2266 IS_BINOP_MATCHER(Word64Equal)
2267 IS_BINOP_MATCHER(Int32AddWithOverflow)
2268 IS_BINOP_MATCHER(Int32Add)
2269 IS_BINOP_MATCHER(Int32Sub)
2270 IS_BINOP_MATCHER(Int32Mul)
2271 IS_BINOP_MATCHER(Int32MulHigh)
2272 IS_BINOP_MATCHER(Int32LessThan)
2273 IS_BINOP_MATCHER(Uint32LessThan)
2274 IS_BINOP_MATCHER(Uint32LessThanOrEqual)
2275 IS_BINOP_MATCHER(Int64Add)
2276 IS_BINOP_MATCHER(Int64Sub)
2277 IS_BINOP_MATCHER(JSAdd)
2278 IS_BINOP_MATCHER(Float32Max)
2279 IS_BINOP_MATCHER(Float32Min)
2280 IS_BINOP_MATCHER(Float32Equal)
2281 IS_BINOP_MATCHER(Float32LessThan)
2282 IS_BINOP_MATCHER(Float32LessThanOrEqual)
2283 IS_BINOP_MATCHER(Float64Max)
2284 IS_BINOP_MATCHER(Float64Min)
2285 IS_BINOP_MATCHER(Float64Sub)
2286 IS_BINOP_MATCHER(Float64InsertLowWord32)
2287 IS_BINOP_MATCHER(Float64InsertHighWord32)
2288 #undef IS_BINOP_MATCHER
2289
2290
2291 #define IS_UNOP_MATCHER(Name) \
2292 Matcher<Node*> Is##Name(const Matcher<Node*>& input_matcher) { \
2293 return MakeMatcher(new IsUnopMatcher(IrOpcode::k##Name, input_matcher)); \
2294 }
2295 IS_UNOP_MATCHER(BooleanNot)
2296 IS_UNOP_MATCHER(TruncateFloat64ToWord32)
2297 IS_UNOP_MATCHER(ChangeFloat64ToInt32)
2298 IS_UNOP_MATCHER(ChangeFloat64ToUint32)
2299 IS_UNOP_MATCHER(ChangeInt32ToFloat64)
2300 IS_UNOP_MATCHER(ChangeInt32ToInt64)
2301 IS_UNOP_MATCHER(ChangeUint32ToFloat64)
2302 IS_UNOP_MATCHER(ChangeUint32ToUint64)
2303 IS_UNOP_MATCHER(TruncateFloat64ToFloat32)
2304 IS_UNOP_MATCHER(TruncateInt64ToInt32)
2305 IS_UNOP_MATCHER(Float32Abs)
2306 IS_UNOP_MATCHER(Float64Abs)
2307 IS_UNOP_MATCHER(Float64Sqrt)
2308 IS_UNOP_MATCHER(Float64RoundDown)
2309 IS_UNOP_MATCHER(Float64RoundTruncate)
2310 IS_UNOP_MATCHER(Float64RoundTiesAway)
2311 IS_UNOP_MATCHER(Float64ExtractLowWord32)
2312 IS_UNOP_MATCHER(Float64ExtractHighWord32)
2313 IS_UNOP_MATCHER(NumberAbs)
2314 IS_UNOP_MATCHER(NumberAtan)
2315 IS_UNOP_MATCHER(NumberAtanh)
2316 IS_UNOP_MATCHER(NumberCeil)
2317 IS_UNOP_MATCHER(NumberClz32)
2318 IS_UNOP_MATCHER(NumberCbrt)
2319 IS_UNOP_MATCHER(NumberCos)
2320 IS_UNOP_MATCHER(NumberExp)
2321 IS_UNOP_MATCHER(NumberExpm1)
2322 IS_UNOP_MATCHER(NumberFloor)
2323 IS_UNOP_MATCHER(NumberFround)
2324 IS_UNOP_MATCHER(NumberLog)
2325 IS_UNOP_MATCHER(NumberLog1p)
2326 IS_UNOP_MATCHER(NumberLog10)
2327 IS_UNOP_MATCHER(NumberLog2)
2328 IS_UNOP_MATCHER(NumberRound)
2329 IS_UNOP_MATCHER(NumberSin)
2330 IS_UNOP_MATCHER(NumberSqrt)
2331 IS_UNOP_MATCHER(NumberTan)
2332 IS_UNOP_MATCHER(NumberTrunc)
2333 IS_UNOP_MATCHER(NumberToInt32)
2334 IS_UNOP_MATCHER(NumberToUint32)
2335 IS_UNOP_MATCHER(PlainPrimitiveToNumber)
2336 IS_UNOP_MATCHER(ObjectIsReceiver)
2337 IS_UNOP_MATCHER(ObjectIsSmi)
2338 IS_UNOP_MATCHER(StringFromCharCode)
2339 IS_UNOP_MATCHER(Word32Clz)
2340 IS_UNOP_MATCHER(Word32Ctz)
2341 IS_UNOP_MATCHER(Word32Popcnt)
2342 #undef IS_UNOP_MATCHER
2343
2344 } // namespace compiler
2345 } // namespace internal
2346 } // namespace v8
2347