• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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