LLVM  15.0.0git
PatternMatch.h
Go to the documentation of this file.
1 //===- PatternMatch.h - Match on the LLVM IR --------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file provides a simple and efficient mechanism for performing general
10 // tree-based pattern matches on the LLVM IR. The power of these routines is
11 // that it allows you to write concise patterns that are expressive and easy to
12 // understand. The other major advantage of this is that it allows you to
13 // trivially capture/bind elements in the pattern to variables. For example,
14 // you can do something like this:
15 //
16 // Value *Exp = ...
17 // Value *X, *Y; ConstantInt *C1, *C2; // (X & C1) | (Y & C2)
18 // if (match(Exp, m_Or(m_And(m_Value(X), m_ConstantInt(C1)),
19 // m_And(m_Value(Y), m_ConstantInt(C2))))) {
20 // ... Pattern is matched and variables are bound ...
21 // }
22 //
23 // This is primarily useful to things like the instruction combiner, but can
24 // also be useful for static analysis tools or code generators.
25 //
26 //===----------------------------------------------------------------------===//
27 
28 #ifndef LLVM_IR_PATTERNMATCH_H
29 #define LLVM_IR_PATTERNMATCH_H
30 
31 #include "llvm/ADT/APFloat.h"
32 #include "llvm/ADT/APInt.h"
33 #include "llvm/IR/Constant.h"
34 #include "llvm/IR/Constants.h"
35 #include "llvm/IR/DataLayout.h"
36 #include "llvm/IR/InstrTypes.h"
37 #include "llvm/IR/Instruction.h"
38 #include "llvm/IR/Instructions.h"
39 #include "llvm/IR/IntrinsicInst.h"
40 #include "llvm/IR/Intrinsics.h"
41 #include "llvm/IR/Operator.h"
42 #include "llvm/IR/Value.h"
43 #include "llvm/Support/Casting.h"
44 #include <cstdint>
45 
46 namespace llvm {
47 namespace PatternMatch {
48 
49 template <typename Val, typename Pattern> bool match(Val *V, const Pattern &P) {
50  return const_cast<Pattern &>(P).match(V);
51 }
52 
53 template <typename Pattern> bool match(ArrayRef<int> Mask, const Pattern &P) {
54  return const_cast<Pattern &>(P).match(Mask);
55 }
56 
57 template <typename SubPattern_t> struct OneUse_match {
58  SubPattern_t SubPattern;
59 
60  OneUse_match(const SubPattern_t &SP) : SubPattern(SP) {}
61 
62  template <typename OpTy> bool match(OpTy *V) {
63  return V->hasOneUse() && SubPattern.match(V);
64  }
65 };
66 
67 template <typename T> inline OneUse_match<T> m_OneUse(const T &SubPattern) {
68  return SubPattern;
69 }
70 
71 template <typename Class> struct class_match {
72  template <typename ITy> bool match(ITy *V) { return isa<Class>(V); }
73 };
74 
75 /// Match an arbitrary value and ignore it.
77 
78 /// Match an arbitrary unary operation and ignore it.
81 }
82 
83 /// Match an arbitrary binary operation and ignore it.
86 }
87 
88 /// Matches any compare instruction and ignore it.
90 
91 struct undef_match {
92  static bool check(const Value *V) {
93  if (isa<UndefValue>(V))
94  return true;
95 
96  const auto *CA = dyn_cast<ConstantAggregate>(V);
97  if (!CA)
98  return false;
99 
102 
103  // Either UndefValue, PoisonValue, or an aggregate that only contains
104  // these is accepted by matcher.
105  // CheckValue returns false if CA cannot satisfy this constraint.
106  auto CheckValue = [&](const ConstantAggregate *CA) {
107  for (const Value *Op : CA->operand_values()) {
108  if (isa<UndefValue>(Op))
109  continue;
110 
111  const auto *CA = dyn_cast<ConstantAggregate>(Op);
112  if (!CA)
113  return false;
114  if (Seen.insert(CA).second)
115  Worklist.emplace_back(CA);
116  }
117 
118  return true;
119  };
120 
121  if (!CheckValue(CA))
122  return false;
123 
124  while (!Worklist.empty()) {
125  if (!CheckValue(Worklist.pop_back_val()))
126  return false;
127  }
128  return true;
129  }
130  template <typename ITy> bool match(ITy *V) { return check(V); }
131 };
132 
133 /// Match an arbitrary undef constant. This matches poison as well.
134 /// If this is an aggregate and contains a non-aggregate element that is
135 /// neither undef nor poison, the aggregate is not matched.
136 inline auto m_Undef() { return undef_match(); }
137 
138 /// Match an arbitrary poison constant.
140 
141 /// Match an arbitrary Constant and ignore it.
143 
144 /// Match an arbitrary ConstantInt and ignore it.
146  return class_match<ConstantInt>();
147 }
148 
149 /// Match an arbitrary ConstantFP and ignore it.
151  return class_match<ConstantFP>();
152 }
153 
154 /// Match an arbitrary ConstantExpr and ignore it.
156  return class_match<ConstantExpr>();
157 }
158 
159 /// Match an arbitrary basic block value and ignore it.
161  return class_match<BasicBlock>();
162 }
163 
164 /// Inverting matcher
165 template <typename Ty> struct match_unless {
166  Ty M;
167 
168  match_unless(const Ty &Matcher) : M(Matcher) {}
169 
170  template <typename ITy> bool match(ITy *V) { return !M.match(V); }
171 };
172 
173 /// Match if the inner matcher does *NOT* match.
174 template <typename Ty> inline match_unless<Ty> m_Unless(const Ty &M) {
175  return match_unless<Ty>(M);
176 }
177 
178 /// Matching combinators
179 template <typename LTy, typename RTy> struct match_combine_or {
180  LTy L;
181  RTy R;
182 
183  match_combine_or(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
184 
185  template <typename ITy> bool match(ITy *V) {
186  if (L.match(V))
187  return true;
188  if (R.match(V))
189  return true;
190  return false;
191  }
192 };
193 
194 template <typename LTy, typename RTy> struct match_combine_and {
195  LTy L;
196  RTy R;
197 
198  match_combine_and(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
199 
200  template <typename ITy> bool match(ITy *V) {
201  if (L.match(V))
202  if (R.match(V))
203  return true;
204  return false;
205  }
206 };
207 
208 /// Combine two pattern matchers matching L || R
209 template <typename LTy, typename RTy>
210 inline match_combine_or<LTy, RTy> m_CombineOr(const LTy &L, const RTy &R) {
211  return match_combine_or<LTy, RTy>(L, R);
212 }
213 
214 /// Combine two pattern matchers matching L && R
215 template <typename LTy, typename RTy>
216 inline match_combine_and<LTy, RTy> m_CombineAnd(const LTy &L, const RTy &R) {
217  return match_combine_and<LTy, RTy>(L, R);
218 }
219 
220 struct apint_match {
221  const APInt *&Res;
223 
225  : Res(Res), AllowUndef(AllowUndef) {}
226 
227  template <typename ITy> bool match(ITy *V) {
228  if (auto *CI = dyn_cast<ConstantInt>(V)) {
229  Res = &CI->getValue();
230  return true;
231  }
232  if (V->getType()->isVectorTy())
233  if (const auto *C = dyn_cast<Constant>(V))
234  if (auto *CI = dyn_cast_or_null<ConstantInt>(
235  C->getSplatValue(AllowUndef))) {
236  Res = &CI->getValue();
237  return true;
238  }
239  return false;
240  }
241 };
242 // Either constexpr if or renaming ConstantFP::getValueAPF to
243 // ConstantFP::getValue is needed to do it via single template
244 // function for both apint/apfloat.
246  const APFloat *&Res;
248 
250  : Res(Res), AllowUndef(AllowUndef) {}
251 
252  template <typename ITy> bool match(ITy *V) {
253  if (auto *CI = dyn_cast<ConstantFP>(V)) {
254  Res = &CI->getValueAPF();
255  return true;
256  }
257  if (V->getType()->isVectorTy())
258  if (const auto *C = dyn_cast<Constant>(V))
259  if (auto *CI = dyn_cast_or_null<ConstantFP>(
260  C->getSplatValue(AllowUndef))) {
261  Res = &CI->getValueAPF();
262  return true;
263  }
264  return false;
265  }
266 };
267 
268 /// Match a ConstantInt or splatted ConstantVector, binding the
269 /// specified pointer to the contained APInt.
270 inline apint_match m_APInt(const APInt *&Res) {
271  // Forbid undefs by default to maintain previous behavior.
272  return apint_match(Res, /* AllowUndef */ false);
273 }
274 
275 /// Match APInt while allowing undefs in splat vector constants.
276 inline apint_match m_APIntAllowUndef(const APInt *&Res) {
277  return apint_match(Res, /* AllowUndef */ true);
278 }
279 
280 /// Match APInt while forbidding undefs in splat vector constants.
281 inline apint_match m_APIntForbidUndef(const APInt *&Res) {
282  return apint_match(Res, /* AllowUndef */ false);
283 }
284 
285 /// Match a ConstantFP or splatted ConstantVector, binding the
286 /// specified pointer to the contained APFloat.
287 inline apfloat_match m_APFloat(const APFloat *&Res) {
288  // Forbid undefs by default to maintain previous behavior.
289  return apfloat_match(Res, /* AllowUndef */ false);
290 }
291 
292 /// Match APFloat while allowing undefs in splat vector constants.
294  return apfloat_match(Res, /* AllowUndef */ true);
295 }
296 
297 /// Match APFloat while forbidding undefs in splat vector constants.
299  return apfloat_match(Res, /* AllowUndef */ false);
300 }
301 
302 template <int64_t Val> struct constantint_match {
303  template <typename ITy> bool match(ITy *V) {
304  if (const auto *CI = dyn_cast<ConstantInt>(V)) {
305  const APInt &CIV = CI->getValue();
306  if (Val >= 0)
307  return CIV == static_cast<uint64_t>(Val);
308  // If Val is negative, and CI is shorter than it, truncate to the right
309  // number of bits. If it is larger, then we have to sign extend. Just
310  // compare their negated values.
311  return -CIV == -Val;
312  }
313  return false;
314  }
315 };
316 
317 /// Match a ConstantInt with a specific value.
318 template <int64_t Val> inline constantint_match<Val> m_ConstantInt() {
319  return constantint_match<Val>();
320 }
321 
322 /// This helper class is used to match constant scalars, vector splats,
323 /// and fixed width vectors that satisfy a specified predicate.
324 /// For fixed width vector constants, undefined elements are ignored.
325 template <typename Predicate, typename ConstantVal>
326 struct cstval_pred_ty : public Predicate {
327  template <typename ITy> bool match(ITy *V) {
328  if (const auto *CV = dyn_cast<ConstantVal>(V))
329  return this->isValue(CV->getValue());
330  if (const auto *VTy = dyn_cast<VectorType>(V->getType())) {
331  if (const auto *C = dyn_cast<Constant>(V)) {
332  if (const auto *CV = dyn_cast_or_null<ConstantVal>(C->getSplatValue()))
333  return this->isValue(CV->getValue());
334 
335  // Number of elements of a scalable vector unknown at compile time
336  auto *FVTy = dyn_cast<FixedVectorType>(VTy);
337  if (!FVTy)
338  return false;
339 
340  // Non-splat vector constant: check each element for a match.
341  unsigned NumElts = FVTy->getNumElements();
342  assert(NumElts != 0 && "Constant vector with no elements?");
343  bool HasNonUndefElements = false;
344  for (unsigned i = 0; i != NumElts; ++i) {
345  Constant *Elt = C->getAggregateElement(i);
346  if (!Elt)
347  return false;
348  if (isa<UndefValue>(Elt))
349  continue;
350  auto *CV = dyn_cast<ConstantVal>(Elt);
351  if (!CV || !this->isValue(CV->getValue()))
352  return false;
353  HasNonUndefElements = true;
354  }
355  return HasNonUndefElements;
356  }
357  }
358  return false;
359  }
360 };
361 
362 /// specialization of cstval_pred_ty for ConstantInt
363 template <typename Predicate>
365 
366 /// specialization of cstval_pred_ty for ConstantFP
367 template <typename Predicate>
369 
370 /// This helper class is used to match scalar and vector constants that
371 /// satisfy a specified predicate, and bind them to an APInt.
372 template <typename Predicate> struct api_pred_ty : public Predicate {
373  const APInt *&Res;
374 
375  api_pred_ty(const APInt *&R) : Res(R) {}
376 
377  template <typename ITy> bool match(ITy *V) {
378  if (const auto *CI = dyn_cast<ConstantInt>(V))
379  if (this->isValue(CI->getValue())) {
380  Res = &CI->getValue();
381  return true;
382  }
383  if (V->getType()->isVectorTy())
384  if (const auto *C = dyn_cast<Constant>(V))
385  if (auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue()))
386  if (this->isValue(CI->getValue())) {
387  Res = &CI->getValue();
388  return true;
389  }
390 
391  return false;
392  }
393 };
394 
395 /// This helper class is used to match scalar and vector constants that
396 /// satisfy a specified predicate, and bind them to an APFloat.
397 /// Undefs are allowed in splat vector constants.
398 template <typename Predicate> struct apf_pred_ty : public Predicate {
399  const APFloat *&Res;
400 
401  apf_pred_ty(const APFloat *&R) : Res(R) {}
402 
403  template <typename ITy> bool match(ITy *V) {
404  if (const auto *CI = dyn_cast<ConstantFP>(V))
405  if (this->isValue(CI->getValue())) {
406  Res = &CI->getValue();
407  return true;
408  }
409  if (V->getType()->isVectorTy())
410  if (const auto *C = dyn_cast<Constant>(V))
411  if (auto *CI = dyn_cast_or_null<ConstantFP>(
412  C->getSplatValue(/* AllowUndef */ true)))
413  if (this->isValue(CI->getValue())) {
414  Res = &CI->getValue();
415  return true;
416  }
417 
418  return false;
419  }
420 };
421 
422 ///////////////////////////////////////////////////////////////////////////////
423 //
424 // Encapsulate constant value queries for use in templated predicate matchers.
425 // This allows checking if constants match using compound predicates and works
426 // with vector constants, possibly with relaxed constraints. For example, ignore
427 // undef values.
428 //
429 ///////////////////////////////////////////////////////////////////////////////
430 
431 struct is_any_apint {
432  bool isValue(const APInt &C) { return true; }
433 };
434 /// Match an integer or vector with any integral constant.
435 /// For vectors, this includes constants with undefined elements.
437  return cst_pred_ty<is_any_apint>();
438 }
439 
440 struct is_all_ones {
441  bool isValue(const APInt &C) { return C.isAllOnes(); }
442 };
443 /// Match an integer or vector with all bits set.
444 /// For vectors, this includes constants with undefined elements.
446  return cst_pred_ty<is_all_ones>();
447 }
448 
450  bool isValue(const APInt &C) { return C.isMaxSignedValue(); }
451 };
452 /// Match an integer or vector with values having all bits except for the high
453 /// bit set (0x7f...).
454 /// For vectors, this includes constants with undefined elements.
457 }
459  return V;
460 }
461 
462 struct is_negative {
463  bool isValue(const APInt &C) { return C.isNegative(); }
464 };
465 /// Match an integer or vector of negative values.
466 /// For vectors, this includes constants with undefined elements.
468  return cst_pred_ty<is_negative>();
469 }
471  return V;
472 }
473 
475  bool isValue(const APInt &C) { return C.isNonNegative(); }
476 };
477 /// Match an integer or vector of non-negative values.
478 /// For vectors, this includes constants with undefined elements.
481 }
483  return V;
484 }
485 
487  bool isValue(const APInt &C) { return C.isStrictlyPositive(); }
488 };
489 /// Match an integer or vector of strictly positive values.
490 /// For vectors, this includes constants with undefined elements.
493 }
495  return V;
496 }
497 
499  bool isValue(const APInt &C) { return C.isNonPositive(); }
500 };
501 /// Match an integer or vector of non-positive values.
502 /// For vectors, this includes constants with undefined elements.
505 }
506 inline api_pred_ty<is_nonpositive> m_NonPositive(const APInt *&V) { return V; }
507 
508 struct is_one {
509  bool isValue(const APInt &C) { return C.isOne(); }
510 };
511 /// Match an integer 1 or a vector with all elements equal to 1.
512 /// For vectors, this includes constants with undefined elements.
514  return cst_pred_ty<is_one>();
515 }
516 
517 struct is_zero_int {
518  bool isValue(const APInt &C) { return C.isZero(); }
519 };
520 /// Match an integer 0 or a vector with all elements equal to 0.
521 /// For vectors, this includes constants with undefined elements.
523  return cst_pred_ty<is_zero_int>();
524 }
525 
526 struct is_zero {
527  template <typename ITy> bool match(ITy *V) {
528  auto *C = dyn_cast<Constant>(V);
529  // FIXME: this should be able to do something for scalable vectors
530  return C && (C->isNullValue() || cst_pred_ty<is_zero_int>().match(C));
531  }
532 };
533 /// Match any null constant or a vector with all elements equal to 0.
534 /// For vectors, this includes constants with undefined elements.
535 inline is_zero m_Zero() {
536  return is_zero();
537 }
538 
539 struct is_power2 {
540  bool isValue(const APInt &C) { return C.isPowerOf2(); }
541 };
542 /// Match an integer or vector power-of-2.
543 /// For vectors, this includes constants with undefined elements.
545  return cst_pred_ty<is_power2>();
546 }
548  return V;
549 }
550 
552  bool isValue(const APInt &C) { return C.isNegatedPowerOf2(); }
553 };
554 /// Match a integer or vector negated power-of-2.
555 /// For vectors, this includes constants with undefined elements.
558 }
560  return V;
561 }
562 
564  bool isValue(const APInt &C) { return !C || C.isPowerOf2(); }
565 };
566 /// Match an integer or vector of 0 or power-of-2 values.
567 /// For vectors, this includes constants with undefined elements.
570 }
572  return V;
573 }
574 
575 struct is_sign_mask {
576  bool isValue(const APInt &C) { return C.isSignMask(); }
577 };
578 /// Match an integer or vector with only the sign bit(s) set.
579 /// For vectors, this includes constants with undefined elements.
581  return cst_pred_ty<is_sign_mask>();
582 }
583 
585  bool isValue(const APInt &C) { return C.isMask(); }
586 };
587 /// Match an integer or vector with only the low bit(s) set.
588 /// For vectors, this includes constants with undefined elements.
591 }
593  return V;
594 }
595 
598  const APInt *Thr;
599  bool isValue(const APInt &C) { return ICmpInst::compare(C, *Thr, Pred); }
600 };
601 /// Match an integer or vector with every element comparing 'pred' (eg/ne/...)
602 /// to Threshold. For vectors, this includes constants with undefined elements.
606  P.Pred = Predicate;
607  P.Thr = &Threshold;
608  return P;
609 }
610 
611 struct is_nan {
612  bool isValue(const APFloat &C) { return C.isNaN(); }
613 };
614 /// Match an arbitrary NaN constant. This includes quiet and signalling nans.
615 /// For vectors, this includes constants with undefined elements.
617  return cstfp_pred_ty<is_nan>();
618 }
619 
620 struct is_nonnan {
621  bool isValue(const APFloat &C) { return !C.isNaN(); }
622 };
623 /// Match a non-NaN FP constant.
624 /// For vectors, this includes constants with undefined elements.
626  return cstfp_pred_ty<is_nonnan>();
627 }
628 
629 struct is_inf {
630  bool isValue(const APFloat &C) { return C.isInfinity(); }
631 };
632 /// Match a positive or negative infinity FP constant.
633 /// For vectors, this includes constants with undefined elements.
635  return cstfp_pred_ty<is_inf>();
636 }
637 
638 struct is_noninf {
639  bool isValue(const APFloat &C) { return !C.isInfinity(); }
640 };
641 /// Match a non-infinity FP constant, i.e. finite or NaN.
642 /// For vectors, this includes constants with undefined elements.
644  return cstfp_pred_ty<is_noninf>();
645 }
646 
647 struct is_finite {
648  bool isValue(const APFloat &C) { return C.isFinite(); }
649 };
650 /// Match a finite FP constant, i.e. not infinity or NaN.
651 /// For vectors, this includes constants with undefined elements.
653  return cstfp_pred_ty<is_finite>();
654 }
655 inline apf_pred_ty<is_finite> m_Finite(const APFloat *&V) { return V; }
656 
658  bool isValue(const APFloat &C) { return C.isFiniteNonZero(); }
659 };
660 /// Match a finite non-zero FP constant.
661 /// For vectors, this includes constants with undefined elements.
664 }
666  return V;
667 }
668 
670  bool isValue(const APFloat &C) { return C.isZero(); }
671 };
672 /// Match a floating-point negative zero or positive zero.
673 /// For vectors, this includes constants with undefined elements.
676 }
677 
679  bool isValue(const APFloat &C) { return C.isPosZero(); }
680 };
681 /// Match a floating-point positive zero.
682 /// For vectors, this includes constants with undefined elements.
685 }
686 
688  bool isValue(const APFloat &C) { return C.isNegZero(); }
689 };
690 /// Match a floating-point negative zero.
691 /// For vectors, this includes constants with undefined elements.
694 }
695 
697  bool isValue(const APFloat &C) { return C.isNonZero(); }
698 };
699 /// Match a floating-point non-zero.
700 /// For vectors, this includes constants with undefined elements.
703 }
704 
705 ///////////////////////////////////////////////////////////////////////////////
706 
707 template <typename Class> struct bind_ty {
708  Class *&VR;
709 
710  bind_ty(Class *&V) : VR(V) {}
711 
712  template <typename ITy> bool match(ITy *V) {
713  if (auto *CV = dyn_cast<Class>(V)) {
714  VR = CV;
715  return true;
716  }
717  return false;
718  }
719 };
720 
721 /// Match a value, capturing it if we match.
722 inline bind_ty<Value> m_Value(Value *&V) { return V; }
723 inline bind_ty<const Value> m_Value(const Value *&V) { return V; }
724 
725 /// Match an instruction, capturing it if we match.
727 /// Match a unary operator, capturing it if we match.
729 /// Match a binary operator, capturing it if we match.
731 /// Match a with overflow intrinsic, capturing it if we match.
735  return I;
736 }
737 
738 /// Match a Constant, capturing the value if we match.
739 inline bind_ty<Constant> m_Constant(Constant *&C) { return C; }
740 
741 /// Match a ConstantInt, capturing the value if we match.
742 inline bind_ty<ConstantInt> m_ConstantInt(ConstantInt *&CI) { return CI; }
743 
744 /// Match a ConstantFP, capturing the value if we match.
746 
747 /// Match a ConstantExpr, capturing the value if we match.
749 
750 /// Match a basic block value, capturing it if we match.
751 inline bind_ty<BasicBlock> m_BasicBlock(BasicBlock *&V) { return V; }
753  return V;
754 }
755 
756 /// Match an arbitrary immediate Constant and ignore it.
761 }
762 
763 /// Match an immediate Constant, capturing the value if we match.
768 }
769 
770 /// Match a specified Value*.
772  const Value *Val;
773 
774  specificval_ty(const Value *V) : Val(V) {}
775 
776  template <typename ITy> bool match(ITy *V) { return V == Val; }
777 };
778 
779 /// Match if we have a specific specified value.
780 inline specificval_ty m_Specific(const Value *V) { return V; }
781 
782 /// Stores a reference to the Value *, not the Value * itself,
783 /// thus can be used in commutative matchers.
784 template <typename Class> struct deferredval_ty {
785  Class *const &Val;
786 
787  deferredval_ty(Class *const &V) : Val(V) {}
788 
789  template <typename ITy> bool match(ITy *const V) { return V == Val; }
790 };
791 
792 /// Like m_Specific(), but works if the specific value to match is determined
793 /// as part of the same match() expression. For example:
794 /// m_Add(m_Value(X), m_Specific(X)) is incorrect, because m_Specific() will
795 /// bind X before the pattern match starts.
796 /// m_Add(m_Value(X), m_Deferred(X)) is correct, and will check against
797 /// whichever value m_Value(X) populated.
798 inline deferredval_ty<Value> m_Deferred(Value *const &V) { return V; }
800  return V;
801 }
802 
803 /// Match a specified floating point value or vector of all elements of
804 /// that value.
806  double Val;
807 
808  specific_fpval(double V) : Val(V) {}
809 
810  template <typename ITy> bool match(ITy *V) {
811  if (const auto *CFP = dyn_cast<ConstantFP>(V))
812  return CFP->isExactlyValue(Val);
813  if (V->getType()->isVectorTy())
814  if (const auto *C = dyn_cast<Constant>(V))
815  if (auto *CFP = dyn_cast_or_null<ConstantFP>(C->getSplatValue()))
816  return CFP->isExactlyValue(Val);
817  return false;
818  }
819 };
820 
821 /// Match a specific floating point value or vector with all elements
822 /// equal to the value.
823 inline specific_fpval m_SpecificFP(double V) { return specific_fpval(V); }
824 
825 /// Match a float 1.0 or vector with all elements equal to 1.0.
826 inline specific_fpval m_FPOne() { return m_SpecificFP(1.0); }
827 
830 
832 
833  template <typename ITy> bool match(ITy *V) {
834  if (const auto *CV = dyn_cast<ConstantInt>(V))
835  if (CV->getValue().ule(UINT64_MAX)) {
836  VR = CV->getZExtValue();
837  return true;
838  }
839  return false;
840  }
841 };
842 
843 /// Match a specified integer value or vector of all elements of that
844 /// value.
845 template <bool AllowUndefs>
848 
850 
851  template <typename ITy> bool match(ITy *V) {
852  const auto *CI = dyn_cast<ConstantInt>(V);
853  if (!CI && V->getType()->isVectorTy())
854  if (const auto *C = dyn_cast<Constant>(V))
855  CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowUndefs));
856 
857  return CI && APInt::isSameValue(CI->getValue(), Val);
858  }
859 };
860 
861 /// Match a specific integer value or vector with all elements equal to
862 /// the value.
865 }
866 
868  return m_SpecificInt(APInt(64, V));
869 }
870 
872  return specific_intval<true>(std::move(V));
873 }
874 
876  return m_SpecificIntAllowUndef(APInt(64, V));
877 }
878 
879 /// Match a ConstantInt and bind to its value. This does not match
880 /// ConstantInts wider than 64-bits.
882 
883 /// Match a specified basic block value.
886 
888 
889  template <typename ITy> bool match(ITy *V) {
890  const auto *BB = dyn_cast<BasicBlock>(V);
891  return BB && BB == Val;
892  }
893 };
894 
895 /// Match a specific basic block value.
897  return specific_bbval(BB);
898 }
899 
900 /// A commutative-friendly version of m_Specific().
902  return BB;
903 }
905 m_Deferred(const BasicBlock *const &BB) {
906  return BB;
907 }
908 
909 //===----------------------------------------------------------------------===//
910 // Matcher for any binary operator.
911 //
912 template <typename LHS_t, typename RHS_t, bool Commutable = false>
916 
917  // The evaluation order is always stable, regardless of Commutability.
918  // The LHS is always matched first.
919  AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
920 
921  template <typename OpTy> bool match(OpTy *V) {
922  if (auto *I = dyn_cast<BinaryOperator>(V))
923  return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
924  (Commutable && L.match(I->getOperand(1)) &&
925  R.match(I->getOperand(0)));
926  return false;
927  }
928 };
929 
930 template <typename LHS, typename RHS>
931 inline AnyBinaryOp_match<LHS, RHS> m_BinOp(const LHS &L, const RHS &R) {
932  return AnyBinaryOp_match<LHS, RHS>(L, R);
933 }
934 
935 //===----------------------------------------------------------------------===//
936 // Matcher for any unary operator.
937 // TODO fuse unary, binary matcher into n-ary matcher
938 //
939 template <typename OP_t> struct AnyUnaryOp_match {
940  OP_t X;
941 
942  AnyUnaryOp_match(const OP_t &X) : X(X) {}
943 
944  template <typename OpTy> bool match(OpTy *V) {
945  if (auto *I = dyn_cast<UnaryOperator>(V))
946  return X.match(I->getOperand(0));
947  return false;
948  }
949 };
950 
951 template <typename OP_t> inline AnyUnaryOp_match<OP_t> m_UnOp(const OP_t &X) {
952  return AnyUnaryOp_match<OP_t>(X);
953 }
954 
955 //===----------------------------------------------------------------------===//
956 // Matchers for specific binary operators.
957 //
958 
959 template <typename LHS_t, typename RHS_t, unsigned Opcode,
960  bool Commutable = false>
964 
965  // The evaluation order is always stable, regardless of Commutability.
966  // The LHS is always matched first.
967  BinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
968 
969  template <typename OpTy> inline bool match(unsigned Opc, OpTy *V) {
970  if (V->getValueID() == Value::InstructionVal + Opc) {
971  auto *I = cast<BinaryOperator>(V);
972  return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
973  (Commutable && L.match(I->getOperand(1)) &&
974  R.match(I->getOperand(0)));
975  }
976  if (auto *CE = dyn_cast<ConstantExpr>(V))
977  return CE->getOpcode() == Opc &&
978  ((L.match(CE->getOperand(0)) && R.match(CE->getOperand(1))) ||
979  (Commutable && L.match(CE->getOperand(1)) &&
980  R.match(CE->getOperand(0))));
981  return false;
982  }
983 
984  template <typename OpTy> bool match(OpTy *V) { return match(Opcode, V); }
985 };
986 
987 template <typename LHS, typename RHS>
989  const RHS &R) {
991 }
992 
993 template <typename LHS, typename RHS>
995  const RHS &R) {
997 }
998 
999 template <typename LHS, typename RHS>
1001  const RHS &R) {
1003 }
1004 
1005 template <typename LHS, typename RHS>
1007  const RHS &R) {
1009 }
1010 
1011 template <typename Op_t> struct FNeg_match {
1012  Op_t X;
1013 
1014  FNeg_match(const Op_t &Op) : X(Op) {}
1015  template <typename OpTy> bool match(OpTy *V) {
1016  auto *FPMO = dyn_cast<FPMathOperator>(V);
1017  if (!FPMO) return false;
1018 
1019  if (FPMO->getOpcode() == Instruction::FNeg)
1020  return X.match(FPMO->getOperand(0));
1021 
1022  if (FPMO->getOpcode() == Instruction::FSub) {
1023  if (FPMO->hasNoSignedZeros()) {
1024  // With 'nsz', any zero goes.
1025  if (!cstfp_pred_ty<is_any_zero_fp>().match(FPMO->getOperand(0)))
1026  return false;
1027  } else {
1028  // Without 'nsz', we need fsub -0.0, X exactly.
1029  if (!cstfp_pred_ty<is_neg_zero_fp>().match(FPMO->getOperand(0)))
1030  return false;
1031  }
1032 
1033  return X.match(FPMO->getOperand(1));
1034  }
1035 
1036  return false;
1037  }
1038 };
1039 
1040 /// Match 'fneg X' as 'fsub -0.0, X'.
1041 template <typename OpTy>
1042 inline FNeg_match<OpTy>
1043 m_FNeg(const OpTy &X) {
1044  return FNeg_match<OpTy>(X);
1045 }
1046 
1047 /// Match 'fneg X' as 'fsub +-0.0, X'.
1048 template <typename RHS>
1049 inline BinaryOp_match<cstfp_pred_ty<is_any_zero_fp>, RHS, Instruction::FSub>
1050 m_FNegNSZ(const RHS &X) {
1051  return m_FSub(m_AnyZeroFP(), X);
1052 }
1053 
1054 template <typename LHS, typename RHS>
1056  const RHS &R) {
1058 }
1059 
1060 template <typename LHS, typename RHS>
1062  const RHS &R) {
1064 }
1065 
1066 template <typename LHS, typename RHS>
1068  const RHS &R) {
1070 }
1071 
1072 template <typename LHS, typename RHS>
1074  const RHS &R) {
1076 }
1077 
1078 template <typename LHS, typename RHS>
1080  const RHS &R) {
1082 }
1083 
1084 template <typename LHS, typename RHS>
1086  const RHS &R) {
1088 }
1089 
1090 template <typename LHS, typename RHS>
1092  const RHS &R) {
1094 }
1095 
1096 template <typename LHS, typename RHS>
1098  const RHS &R) {
1100 }
1101 
1102 template <typename LHS, typename RHS>
1104  const RHS &R) {
1106 }
1107 
1108 template <typename LHS, typename RHS>
1110  const RHS &R) {
1112 }
1113 
1114 template <typename LHS, typename RHS>
1116  const RHS &R) {
1118 }
1119 
1120 template <typename LHS, typename RHS>
1122  const RHS &R) {
1124 }
1125 
1126 template <typename LHS, typename RHS>
1128  const RHS &R) {
1130 }
1131 
1132 template <typename LHS, typename RHS>
1134  const RHS &R) {
1136 }
1137 
1138 template <typename LHS_t, typename RHS_t, unsigned Opcode,
1139  unsigned WrapFlags = 0>
1143 
1145  : L(LHS), R(RHS) {}
1146 
1147  template <typename OpTy> bool match(OpTy *V) {
1148  if (auto *Op = dyn_cast<OverflowingBinaryOperator>(V)) {
1149  if (Op->getOpcode() != Opcode)
1150  return false;
1151  if ((WrapFlags & OverflowingBinaryOperator::NoUnsignedWrap) &&
1152  !Op->hasNoUnsignedWrap())
1153  return false;
1154  if ((WrapFlags & OverflowingBinaryOperator::NoSignedWrap) &&
1155  !Op->hasNoSignedWrap())
1156  return false;
1157  return L.match(Op->getOperand(0)) && R.match(Op->getOperand(1));
1158  }
1159  return false;
1160  }
1161 };
1162 
1163 template <typename LHS, typename RHS>
1166 m_NSWAdd(const LHS &L, const RHS &R) {
1169  L, R);
1170 }
1171 template <typename LHS, typename RHS>
1172 inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1174 m_NSWSub(const LHS &L, const RHS &R) {
1175  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1177  L, R);
1178 }
1179 template <typename LHS, typename RHS>
1182 m_NSWMul(const LHS &L, const RHS &R) {
1185  L, R);
1186 }
1187 template <typename LHS, typename RHS>
1188 inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1190 m_NSWShl(const LHS &L, const RHS &R) {
1191  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1193  L, R);
1194 }
1195 
1196 template <typename LHS, typename RHS>
1199 m_NUWAdd(const LHS &L, const RHS &R) {
1202  L, R);
1203 }
1204 template <typename LHS, typename RHS>
1205 inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1207 m_NUWSub(const LHS &L, const RHS &R) {
1208  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1210  L, R);
1211 }
1212 template <typename LHS, typename RHS>
1215 m_NUWMul(const LHS &L, const RHS &R) {
1218  L, R);
1219 }
1220 template <typename LHS, typename RHS>
1221 inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1223 m_NUWShl(const LHS &L, const RHS &R) {
1224  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1226  L, R);
1227 }
1228 
1229 template <typename LHS_t, typename RHS_t, bool Commutable = false>
1231  : public BinaryOp_match<LHS_t, RHS_t, 0, Commutable> {
1232  unsigned Opcode;
1233 
1234  SpecificBinaryOp_match(unsigned Opcode, const LHS_t &LHS, const RHS_t &RHS)
1236 
1237  template <typename OpTy> bool match(OpTy *V) {
1239  }
1240 };
1241 
1242 /// Matches a specific opcode.
1243 template <typename LHS, typename RHS>
1244 inline SpecificBinaryOp_match<LHS, RHS> m_BinOp(unsigned Opcode, const LHS &L,
1245  const RHS &R) {
1246  return SpecificBinaryOp_match<LHS, RHS>(Opcode, L, R);
1247 }
1248 
1249 //===----------------------------------------------------------------------===//
1250 // Class that matches a group of binary opcodes.
1251 //
1252 template <typename LHS_t, typename RHS_t, typename Predicate>
1256 
1257  BinOpPred_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1258 
1259  template <typename OpTy> bool match(OpTy *V) {
1260  if (auto *I = dyn_cast<Instruction>(V))
1261  return this->isOpType(I->getOpcode()) && L.match(I->getOperand(0)) &&
1262  R.match(I->getOperand(1));
1263  if (auto *CE = dyn_cast<ConstantExpr>(V))
1264  return this->isOpType(CE->getOpcode()) && L.match(CE->getOperand(0)) &&
1265  R.match(CE->getOperand(1));
1266  return false;
1267  }
1268 };
1269 
1270 struct is_shift_op {
1271  bool isOpType(unsigned Opcode) { return Instruction::isShift(Opcode); }
1272 };
1273 
1275  bool isOpType(unsigned Opcode) {
1276  return Opcode == Instruction::LShr || Opcode == Instruction::AShr;
1277  }
1278 };
1279 
1281  bool isOpType(unsigned Opcode) {
1282  return Opcode == Instruction::LShr || Opcode == Instruction::Shl;
1283  }
1284 };
1285 
1287  bool isOpType(unsigned Opcode) {
1288  return Instruction::isBitwiseLogicOp(Opcode);
1289  }
1290 };
1291 
1292 struct is_idiv_op {
1293  bool isOpType(unsigned Opcode) {
1294  return Opcode == Instruction::SDiv || Opcode == Instruction::UDiv;
1295  }
1296 };
1297 
1298 struct is_irem_op {
1299  bool isOpType(unsigned Opcode) {
1300  return Opcode == Instruction::SRem || Opcode == Instruction::URem;
1301  }
1302 };
1303 
1304 /// Matches shift operations.
1305 template <typename LHS, typename RHS>
1307  const RHS &R) {
1309 }
1310 
1311 /// Matches logical shift operations.
1312 template <typename LHS, typename RHS>
1314  const RHS &R) {
1316 }
1317 
1318 /// Matches logical shift operations.
1319 template <typename LHS, typename RHS>
1321 m_LogicalShift(const LHS &L, const RHS &R) {
1323 }
1324 
1325 /// Matches bitwise logic operations.
1326 template <typename LHS, typename RHS>
1328 m_BitwiseLogic(const LHS &L, const RHS &R) {
1330 }
1331 
1332 /// Matches integer division operations.
1333 template <typename LHS, typename RHS>
1335  const RHS &R) {
1337 }
1338 
1339 /// Matches integer remainder operations.
1340 template <typename LHS, typename RHS>
1342  const RHS &R) {
1344 }
1345 
1346 //===----------------------------------------------------------------------===//
1347 // Class that matches exact binary ops.
1348 //
1349 template <typename SubPattern_t> struct Exact_match {
1350  SubPattern_t SubPattern;
1351 
1352  Exact_match(const SubPattern_t &SP) : SubPattern(SP) {}
1353 
1354  template <typename OpTy> bool match(OpTy *V) {
1355  if (auto *PEO = dyn_cast<PossiblyExactOperator>(V))
1356  return PEO->isExact() && SubPattern.match(V);
1357  return false;
1358  }
1359 };
1360 
1361 template <typename T> inline Exact_match<T> m_Exact(const T &SubPattern) {
1362  return SubPattern;
1363 }
1364 
1365 //===----------------------------------------------------------------------===//
1366 // Matchers for CmpInst classes
1367 //
1368 
1369 template <typename LHS_t, typename RHS_t, typename Class, typename PredicateTy,
1370  bool Commutable = false>
1372  PredicateTy &Predicate;
1375 
1376  // The evaluation order is always stable, regardless of Commutability.
1377  // The LHS is always matched first.
1378  CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
1379  : Predicate(Pred), L(LHS), R(RHS) {}
1380 
1381  template <typename OpTy> bool match(OpTy *V) {
1382  if (auto *I = dyn_cast<Class>(V)) {
1383  if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
1384  Predicate = I->getPredicate();
1385  return true;
1386  } else if (Commutable && L.match(I->getOperand(1)) &&
1387  R.match(I->getOperand(0))) {
1388  Predicate = I->getSwappedPredicate();
1389  return true;
1390  }
1391  }
1392  return false;
1393  }
1394 };
1395 
1396 template <typename LHS, typename RHS>
1398 m_Cmp(CmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1400 }
1401 
1402 template <typename LHS, typename RHS>
1404 m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1406 }
1407 
1408 template <typename LHS, typename RHS>
1410 m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1412 }
1413 
1414 //===----------------------------------------------------------------------===//
1415 // Matchers for instructions with a given opcode and number of operands.
1416 //
1417 
1418 /// Matches instructions with Opcode and three operands.
1419 template <typename T0, unsigned Opcode> struct OneOps_match {
1420  T0 Op1;
1421 
1422  OneOps_match(const T0 &Op1) : Op1(Op1) {}
1423 
1424  template <typename OpTy> bool match(OpTy *V) {
1425  if (V->getValueID() == Value::InstructionVal + Opcode) {
1426  auto *I = cast<Instruction>(V);
1427  return Op1.match(I->getOperand(0));
1428  }
1429  return false;
1430  }
1431 };
1432 
1433 /// Matches instructions with Opcode and three operands.
1434 template <typename T0, typename T1, unsigned Opcode> struct TwoOps_match {
1435  T0 Op1;
1437 
1438  TwoOps_match(const T0 &Op1, const T1 &Op2) : Op1(Op1), Op2(Op2) {}
1439 
1440  template <typename OpTy> bool match(OpTy *V) {
1441  if (V->getValueID() == Value::InstructionVal + Opcode) {
1442  auto *I = cast<Instruction>(V);
1443  return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1));
1444  }
1445  return false;
1446  }
1447 };
1448 
1449 /// Matches instructions with Opcode and three operands.
1450 template <typename T0, typename T1, typename T2, unsigned Opcode>
1452  T0 Op1;
1454  T2 Op3;
1455 
1456  ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
1457  : Op1(Op1), Op2(Op2), Op3(Op3) {}
1458 
1459  template <typename OpTy> bool match(OpTy *V) {
1460  if (V->getValueID() == Value::InstructionVal + Opcode) {
1461  auto *I = cast<Instruction>(V);
1462  return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1463  Op3.match(I->getOperand(2));
1464  }
1465  return false;
1466  }
1467 };
1468 
1469 /// Matches SelectInst.
1470 template <typename Cond, typename LHS, typename RHS>
1472 m_Select(const Cond &C, const LHS &L, const RHS &R) {
1474 }
1475 
1476 /// This matches a select of two constants, e.g.:
1477 /// m_SelectCst<-1, 0>(m_Value(V))
1478 template <int64_t L, int64_t R, typename Cond>
1481 m_SelectCst(const Cond &C) {
1482  return m_Select(C, m_ConstantInt<L>(), m_ConstantInt<R>());
1483 }
1484 
1485 /// Matches FreezeInst.
1486 template <typename OpTy>
1489 }
1490 
1491 /// Matches InsertElementInst.
1492 template <typename Val_t, typename Elt_t, typename Idx_t>
1494 m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx) {
1496  Val, Elt, Idx);
1497 }
1498 
1499 /// Matches ExtractElementInst.
1500 template <typename Val_t, typename Idx_t>
1502 m_ExtractElt(const Val_t &Val, const Idx_t &Idx) {
1504 }
1505 
1506 /// Matches shuffle.
1507 template <typename T0, typename T1, typename T2> struct Shuffle_match {
1508  T0 Op1;
1510  T2 Mask;
1511 
1512  Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
1513  : Op1(Op1), Op2(Op2), Mask(Mask) {}
1514 
1515  template <typename OpTy> bool match(OpTy *V) {
1516  if (auto *I = dyn_cast<ShuffleVectorInst>(V)) {
1517  return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1518  Mask.match(I->getShuffleMask());
1519  }
1520  return false;
1521  }
1522 };
1523 
1524 struct m_Mask {
1528  MaskRef = Mask;
1529  return true;
1530  }
1531 };
1532 
1533 struct m_ZeroMask {
1535  return all_of(Mask, [](int Elem) { return Elem == 0 || Elem == -1; });
1536  }
1537 };
1538 
1542  bool match(ArrayRef<int> Mask) { return MaskRef == Mask; }
1543 };
1544 
1549  auto First = find_if(Mask, [](int Elem) { return Elem != -1; });
1550  if (First == Mask.end())
1551  return false;
1552  SplatIndex = *First;
1553  return all_of(Mask,
1554  [First](int Elem) { return Elem == *First || Elem == -1; });
1555  }
1556 };
1557 
1558 /// Matches ShuffleVectorInst independently of mask value.
1559 template <typename V1_t, typename V2_t>
1561 m_Shuffle(const V1_t &v1, const V2_t &v2) {
1563 }
1564 
1565 template <typename V1_t, typename V2_t, typename Mask_t>
1567 m_Shuffle(const V1_t &v1, const V2_t &v2, const Mask_t &mask) {
1568  return Shuffle_match<V1_t, V2_t, Mask_t>(v1, v2, mask);
1569 }
1570 
1571 /// Matches LoadInst.
1572 template <typename OpTy>
1575 }
1576 
1577 /// Matches StoreInst.
1578 template <typename ValueOpTy, typename PointerOpTy>
1580 m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp) {
1582  PointerOp);
1583 }
1584 
1585 //===----------------------------------------------------------------------===//
1586 // Matchers for CastInst classes
1587 //
1588 
1589 template <typename Op_t, unsigned Opcode> struct CastClass_match {
1590  Op_t Op;
1591 
1592  CastClass_match(const Op_t &OpMatch) : Op(OpMatch) {}
1593 
1594  template <typename OpTy> bool match(OpTy *V) {
1595  if (auto *O = dyn_cast<Operator>(V))
1596  return O->getOpcode() == Opcode && Op.match(O->getOperand(0));
1597  return false;
1598  }
1599 };
1600 
1601 /// Matches BitCast.
1602 template <typename OpTy>
1605 }
1606 
1607 /// Matches PtrToInt.
1608 template <typename OpTy>
1611 }
1612 
1613 /// Matches IntToPtr.
1614 template <typename OpTy>
1617 }
1618 
1619 /// Matches Trunc.
1620 template <typename OpTy>
1623 }
1624 
1625 template <typename OpTy>
1627 m_TruncOrSelf(const OpTy &Op) {
1628  return m_CombineOr(m_Trunc(Op), Op);
1629 }
1630 
1631 /// Matches SExt.
1632 template <typename OpTy>
1635 }
1636 
1637 /// Matches ZExt.
1638 template <typename OpTy>
1641 }
1642 
1643 template <typename OpTy>
1645 m_ZExtOrSelf(const OpTy &Op) {
1646  return m_CombineOr(m_ZExt(Op), Op);
1647 }
1648 
1649 template <typename OpTy>
1651 m_SExtOrSelf(const OpTy &Op) {
1652  return m_CombineOr(m_SExt(Op), Op);
1653 }
1654 
1655 template <typename OpTy>
1658 m_ZExtOrSExt(const OpTy &Op) {
1659  return m_CombineOr(m_ZExt(Op), m_SExt(Op));
1660 }
1661 
1662 template <typename OpTy>
1663 inline match_combine_or<
1666  OpTy>
1667 m_ZExtOrSExtOrSelf(const OpTy &Op) {
1668  return m_CombineOr(m_ZExtOrSExt(Op), Op);
1669 }
1670 
1671 template <typename OpTy>
1674 }
1675 
1676 template <typename OpTy>
1679 }
1680 
1681 template <typename OpTy>
1684 }
1685 
1686 template <typename OpTy>
1689 }
1690 
1691 template <typename OpTy>
1694 }
1695 
1696 template <typename OpTy>
1699 }
1700 
1701 //===----------------------------------------------------------------------===//
1702 // Matchers for control flow.
1703 //
1704 
1705 struct br_match {
1707 
1709 
1710  template <typename OpTy> bool match(OpTy *V) {
1711  if (auto *BI = dyn_cast<BranchInst>(V))
1712  if (BI->isUnconditional()) {
1713  Succ = BI->getSuccessor(0);
1714  return true;
1715  }
1716  return false;
1717  }
1718 };
1719 
1720 inline br_match m_UnconditionalBr(BasicBlock *&Succ) { return br_match(Succ); }
1721 
1722 template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1723 struct brc_match {
1724  Cond_t Cond;
1725  TrueBlock_t T;
1726  FalseBlock_t F;
1727 
1728  brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
1729  : Cond(C), T(t), F(f) {}
1730 
1731  template <typename OpTy> bool match(OpTy *V) {
1732  if (auto *BI = dyn_cast<BranchInst>(V))
1733  if (BI->isConditional() && Cond.match(BI->getCondition()))
1734  return T.match(BI->getSuccessor(0)) && F.match(BI->getSuccessor(1));
1735  return false;
1736  }
1737 };
1738 
1739 template <typename Cond_t>
1741 m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F) {
1743  C, m_BasicBlock(T), m_BasicBlock(F));
1744 }
1745 
1746 template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1748 m_Br(const Cond_t &C, const TrueBlock_t &T, const FalseBlock_t &F) {
1750 }
1751 
1752 //===----------------------------------------------------------------------===//
1753 // Matchers for max/min idioms, eg: "select (sgt x, y), x, y" -> smax(x,y).
1754 //
1755 
1756 template <typename CmpInst_t, typename LHS_t, typename RHS_t, typename Pred_t,
1757  bool Commutable = false>
1759  using PredType = Pred_t;
1762 
1763  // The evaluation order is always stable, regardless of Commutability.
1764  // The LHS is always matched first.
1765  MaxMin_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1766 
1767  template <typename OpTy> bool match(OpTy *V) {
1768  if (auto *II = dyn_cast<IntrinsicInst>(V)) {
1769  Intrinsic::ID IID = II->getIntrinsicID();
1774  Value *LHS = II->getOperand(0), *RHS = II->getOperand(1);
1775  return (L.match(LHS) && R.match(RHS)) ||
1776  (Commutable && L.match(RHS) && R.match(LHS));
1777  }
1778  }
1779  // Look for "(x pred y) ? x : y" or "(x pred y) ? y : x".
1780  auto *SI = dyn_cast<SelectInst>(V);
1781  if (!SI)
1782  return false;
1783  auto *Cmp = dyn_cast<CmpInst_t>(SI->getCondition());
1784  if (!Cmp)
1785  return false;
1786  // At this point we have a select conditioned on a comparison. Check that
1787  // it is the values returned by the select that are being compared.
1788  auto *TrueVal = SI->getTrueValue();
1789  auto *FalseVal = SI->getFalseValue();
1790  auto *LHS = Cmp->getOperand(0);
1791  auto *RHS = Cmp->getOperand(1);
1792  if ((TrueVal != LHS || FalseVal != RHS) &&
1793  (TrueVal != RHS || FalseVal != LHS))
1794  return false;
1795  typename CmpInst_t::Predicate Pred =
1796  LHS == TrueVal ? Cmp->getPredicate() : Cmp->getInversePredicate();
1797  // Does "(x pred y) ? x : y" represent the desired max/min operation?
1798  if (!Pred_t::match(Pred))
1799  return false;
1800  // It does! Bind the operands.
1801  return (L.match(LHS) && R.match(RHS)) ||
1802  (Commutable && L.match(RHS) && R.match(LHS));
1803  }
1804 };
1805 
1806 /// Helper class for identifying signed max predicates.
1808  static bool match(ICmpInst::Predicate Pred) {
1809  return Pred == CmpInst::ICMP_SGT || Pred == CmpInst::ICMP_SGE;
1810  }
1811 };
1812 
1813 /// Helper class for identifying signed min predicates.
1815  static bool match(ICmpInst::Predicate Pred) {
1816  return Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_SLE;
1817  }
1818 };
1819 
1820 /// Helper class for identifying unsigned max predicates.
1822  static bool match(ICmpInst::Predicate Pred) {
1823  return Pred == CmpInst::ICMP_UGT || Pred == CmpInst::ICMP_UGE;
1824  }
1825 };
1826 
1827 /// Helper class for identifying unsigned min predicates.
1829  static bool match(ICmpInst::Predicate Pred) {
1830  return Pred == CmpInst::ICMP_ULT || Pred == CmpInst::ICMP_ULE;
1831  }
1832 };
1833 
1834 /// Helper class for identifying ordered max predicates.
1836  static bool match(FCmpInst::Predicate Pred) {
1837  return Pred == CmpInst::FCMP_OGT || Pred == CmpInst::FCMP_OGE;
1838  }
1839 };
1840 
1841 /// Helper class for identifying ordered min predicates.
1843  static bool match(FCmpInst::Predicate Pred) {
1844  return Pred == CmpInst::FCMP_OLT || Pred == CmpInst::FCMP_OLE;
1845  }
1846 };
1847 
1848 /// Helper class for identifying unordered max predicates.
1850  static bool match(FCmpInst::Predicate Pred) {
1851  return Pred == CmpInst::FCMP_UGT || Pred == CmpInst::FCMP_UGE;
1852  }
1853 };
1854 
1855 /// Helper class for identifying unordered min predicates.
1857  static bool match(FCmpInst::Predicate Pred) {
1858  return Pred == CmpInst::FCMP_ULT || Pred == CmpInst::FCMP_ULE;
1859  }
1860 };
1861 
1862 template <typename LHS, typename RHS>
1864  const RHS &R) {
1866 }
1867 
1868 template <typename LHS, typename RHS>
1870  const RHS &R) {
1872 }
1873 
1874 template <typename LHS, typename RHS>
1876  const RHS &R) {
1878 }
1879 
1880 template <typename LHS, typename RHS>
1882  const RHS &R) {
1884 }
1885 
1886 template <typename LHS, typename RHS>
1887 inline match_combine_or<
1892 m_MaxOrMin(const LHS &L, const RHS &R) {
1893  return m_CombineOr(m_CombineOr(m_SMax(L, R), m_SMin(L, R)),
1894  m_CombineOr(m_UMax(L, R), m_UMin(L, R)));
1895 }
1896 
1897 /// Match an 'ordered' floating point maximum function.
1898 /// Floating point has one special value 'NaN'. Therefore, there is no total
1899 /// order. However, if we can ignore the 'NaN' value (for example, because of a
1900 /// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1901 /// semantics. In the presence of 'NaN' we have to preserve the original
1902 /// select(fcmp(ogt/ge, L, R), L, R) semantics matched by this predicate.
1903 ///
1904 /// max(L, R) iff L and R are not NaN
1905 /// m_OrdFMax(L, R) = R iff L or R are NaN
1906 template <typename LHS, typename RHS>
1908  const RHS &R) {
1910 }
1911 
1912 /// Match an 'ordered' floating point minimum function.
1913 /// Floating point has one special value 'NaN'. Therefore, there is no total
1914 /// order. However, if we can ignore the 'NaN' value (for example, because of a
1915 /// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1916 /// semantics. In the presence of 'NaN' we have to preserve the original
1917 /// select(fcmp(olt/le, L, R), L, R) semantics matched by this predicate.
1918 ///
1919 /// min(L, R) iff L and R are not NaN
1920 /// m_OrdFMin(L, R) = R iff L or R are NaN
1921 template <typename LHS, typename RHS>
1923  const RHS &R) {
1925 }
1926 
1927 /// Match an 'unordered' floating point maximum function.
1928 /// Floating point has one special value 'NaN'. Therefore, there is no total
1929 /// order. However, if we can ignore the 'NaN' value (for example, because of a
1930 /// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1931 /// semantics. In the presence of 'NaN' we have to preserve the original
1932 /// select(fcmp(ugt/ge, L, R), L, R) semantics matched by this predicate.
1933 ///
1934 /// max(L, R) iff L and R are not NaN
1935 /// m_UnordFMax(L, R) = L iff L or R are NaN
1936 template <typename LHS, typename RHS>
1938 m_UnordFMax(const LHS &L, const RHS &R) {
1940 }
1941 
1942 /// Match an 'unordered' floating point minimum function.
1943 /// Floating point has one special value 'NaN'. Therefore, there is no total
1944 /// order. However, if we can ignore the 'NaN' value (for example, because of a
1945 /// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1946 /// semantics. In the presence of 'NaN' we have to preserve the original
1947 /// select(fcmp(ult/le, L, R), L, R) semantics matched by this predicate.
1948 ///
1949 /// min(L, R) iff L and R are not NaN
1950 /// m_UnordFMin(L, R) = L iff L or R are NaN
1951 template <typename LHS, typename RHS>
1953 m_UnordFMin(const LHS &L, const RHS &R) {
1955 }
1956 
1957 //===----------------------------------------------------------------------===//
1958 // Matchers for overflow check patterns: e.g. (a + b) u< a, (a ^ -1) <u b
1959 // Note that S might be matched to other instructions than AddInst.
1960 //
1961 
1962 template <typename LHS_t, typename RHS_t, typename Sum_t>
1966  Sum_t S;
1967 
1968  UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
1969  : L(L), R(R), S(S) {}
1970 
1971  template <typename OpTy> bool match(OpTy *V) {
1972  Value *ICmpLHS, *ICmpRHS;
1973  ICmpInst::Predicate Pred;
1974  if (!m_ICmp(Pred, m_Value(ICmpLHS), m_Value(ICmpRHS)).match(V))
1975  return false;
1976 
1977  Value *AddLHS, *AddRHS;
1978  auto AddExpr = m_Add(m_Value(AddLHS), m_Value(AddRHS));
1979 
1980  // (a + b) u< a, (a + b) u< b
1981  if (Pred == ICmpInst::ICMP_ULT)
1982  if (AddExpr.match(ICmpLHS) && (ICmpRHS == AddLHS || ICmpRHS == AddRHS))
1983  return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
1984 
1985  // a >u (a + b), b >u (a + b)
1986  if (Pred == ICmpInst::ICMP_UGT)
1987  if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
1988  return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
1989 
1990  Value *Op1;
1991  auto XorExpr = m_OneUse(m_Xor(m_Value(Op1), m_AllOnes()));
1992  // (a ^ -1) <u b
1993  if (Pred == ICmpInst::ICMP_ULT) {
1994  if (XorExpr.match(ICmpLHS))
1995  return L.match(Op1) && R.match(ICmpRHS) && S.match(ICmpLHS);
1996  }
1997  // b > u (a ^ -1)
1998  if (Pred == ICmpInst::ICMP_UGT) {
1999  if (XorExpr.match(ICmpRHS))
2000  return L.match(Op1) && R.match(ICmpLHS) && S.match(ICmpRHS);
2001  }
2002 
2003  // Match special-case for increment-by-1.
2004  if (Pred == ICmpInst::ICMP_EQ) {
2005  // (a + 1) == 0
2006  // (1 + a) == 0
2007  if (AddExpr.match(ICmpLHS) && m_ZeroInt().match(ICmpRHS) &&
2008  (m_One().match(AddLHS) || m_One().match(AddRHS)))
2009  return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
2010  // 0 == (a + 1)
2011  // 0 == (1 + a)
2012  if (m_ZeroInt().match(ICmpLHS) && AddExpr.match(ICmpRHS) &&
2013  (m_One().match(AddLHS) || m_One().match(AddRHS)))
2014  return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
2015  }
2016 
2017  return false;
2018  }
2019 };
2020 
2021 /// Match an icmp instruction checking for unsigned overflow on addition.
2022 ///
2023 /// S is matched to the addition whose result is being checked for overflow, and
2024 /// L and R are matched to the LHS and RHS of S.
2025 template <typename LHS_t, typename RHS_t, typename Sum_t>
2027 m_UAddWithOverflow(const LHS_t &L, const RHS_t &R, const Sum_t &S) {
2029 }
2030 
2031 template <typename Opnd_t> struct Argument_match {
2032  unsigned OpI;
2033  Opnd_t Val;
2034 
2035  Argument_match(unsigned OpIdx, const Opnd_t &V) : OpI(OpIdx), Val(V) {}
2036 
2037  template <typename OpTy> bool match(OpTy *V) {
2038  // FIXME: Should likely be switched to use `CallBase`.
2039  if (const auto *CI = dyn_cast<CallInst>(V))
2040  return Val.match(CI->getArgOperand(OpI));
2041  return false;
2042  }
2043 };
2044 
2045 /// Match an argument.
2046 template <unsigned OpI, typename Opnd_t>
2047 inline Argument_match<Opnd_t> m_Argument(const Opnd_t &Op) {
2048  return Argument_match<Opnd_t>(OpI, Op);
2049 }
2050 
2051 /// Intrinsic matchers.
2053  unsigned ID;
2054 
2055  IntrinsicID_match(Intrinsic::ID IntrID) : ID(IntrID) {}
2056 
2057  template <typename OpTy> bool match(OpTy *V) {
2058  if (const auto *CI = dyn_cast<CallInst>(V))
2059  if (const auto *F = CI->getCalledFunction())
2060  return F->getIntrinsicID() == ID;
2061  return false;
2062  }
2063 };
2064 
2065 /// Intrinsic matches are combinations of ID matchers, and argument
2066 /// matchers. Higher arity matcher are defined recursively in terms of and-ing
2067 /// them with lower arity matchers. Here's some convenient typedefs for up to
2068 /// several arguments, and more can be added as needed
2069 template <typename T0 = void, typename T1 = void, typename T2 = void,
2070  typename T3 = void, typename T4 = void, typename T5 = void,
2071  typename T6 = void, typename T7 = void, typename T8 = void,
2072  typename T9 = void, typename T10 = void>
2074 template <typename T0> struct m_Intrinsic_Ty<T0> {
2076 };
2077 template <typename T0, typename T1> struct m_Intrinsic_Ty<T0, T1> {
2078  using Ty =
2080 };
2081 template <typename T0, typename T1, typename T2>
2082 struct m_Intrinsic_Ty<T0, T1, T2> {
2083  using Ty =
2086 };
2087 template <typename T0, typename T1, typename T2, typename T3>
2088 struct m_Intrinsic_Ty<T0, T1, T2, T3> {
2089  using Ty =
2092 };
2093 
2094 template <typename T0, typename T1, typename T2, typename T3, typename T4>
2095 struct m_Intrinsic_Ty<T0, T1, T2, T3, T4> {
2098 };
2099 
2100 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
2101 struct m_Intrinsic_Ty<T0, T1, T2, T3, T4, T5> {
2104 };
2105 
2106 /// Match intrinsic calls like this:
2107 /// m_Intrinsic<Intrinsic::fabs>(m_Value(X))
2108 template <Intrinsic::ID IntrID> inline IntrinsicID_match m_Intrinsic() {
2109  return IntrinsicID_match(IntrID);
2110 }
2111 
2112 /// Matches MaskedLoad Intrinsic.
2113 template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2115 m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2116  const Opnd3 &Op3) {
2117  return m_Intrinsic<Intrinsic::masked_load>(Op0, Op1, Op2, Op3);
2118 }
2119 
2120 /// Matches MaskedGather Intrinsic.
2121 template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2123 m_MaskedGather(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2124  const Opnd3 &Op3) {
2125  return m_Intrinsic<Intrinsic::masked_gather>(Op0, Op1, Op2, Op3);
2126 }
2127 
2128 template <Intrinsic::ID IntrID, typename T0>
2129 inline typename m_Intrinsic_Ty<T0>::Ty m_Intrinsic(const T0 &Op0) {
2130  return m_CombineAnd(m_Intrinsic<IntrID>(), m_Argument<0>(Op0));
2131 }
2132 
2133 template <Intrinsic::ID IntrID, typename T0, typename T1>
2134 inline typename m_Intrinsic_Ty<T0, T1>::Ty m_Intrinsic(const T0 &Op0,
2135  const T1 &Op1) {
2136  return m_CombineAnd(m_Intrinsic<IntrID>(Op0), m_Argument<1>(Op1));
2137 }
2138 
2139 template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2>
2140 inline typename m_Intrinsic_Ty<T0, T1, T2>::Ty
2141 m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2) {
2142  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1), m_Argument<2>(Op2));
2143 }
2144 
2145 template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2146  typename T3>
2147 inline typename m_Intrinsic_Ty<T0, T1, T2, T3>::Ty
2148 m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3) {
2149  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2), m_Argument<3>(Op3));
2150 }
2151 
2152 template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2153  typename T3, typename T4>
2155 m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2156  const T4 &Op4) {
2157  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3),
2158  m_Argument<4>(Op4));
2159 }
2160 
2161 template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2162  typename T3, typename T4, typename T5>
2164 m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2165  const T4 &Op4, const T5 &Op5) {
2166  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3, Op4),
2167  m_Argument<5>(Op5));
2168 }
2169 
2170 // Helper intrinsic matching specializations.
2171 template <typename Opnd0>
2172 inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BitReverse(const Opnd0 &Op0) {
2173  return m_Intrinsic<Intrinsic::bitreverse>(Op0);
2174 }
2175 
2176 template <typename Opnd0>
2177 inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BSwap(const Opnd0 &Op0) {
2178  return m_Intrinsic<Intrinsic::bswap>(Op0);
2179 }
2180 
2181 template <typename Opnd0>
2182 inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FAbs(const Opnd0 &Op0) {
2183  return m_Intrinsic<Intrinsic::fabs>(Op0);
2184 }
2185 
2186 template <typename Opnd0>
2187 inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FCanonicalize(const Opnd0 &Op0) {
2188  return m_Intrinsic<Intrinsic::canonicalize>(Op0);
2189 }
2190 
2191 template <typename Opnd0, typename Opnd1>
2192 inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMin(const Opnd0 &Op0,
2193  const Opnd1 &Op1) {
2194  return m_Intrinsic<Intrinsic::minnum>(Op0, Op1);
2195 }
2196 
2197 template <typename Opnd0, typename Opnd1>
2198 inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMax(const Opnd0 &Op0,
2199  const Opnd1 &Op1) {
2200  return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
2201 }
2202 
2203 template <typename Opnd0, typename Opnd1, typename Opnd2>
2205 m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2206  return m_Intrinsic<Intrinsic::fshl>(Op0, Op1, Op2);
2207 }
2208 
2209 template <typename Opnd0, typename Opnd1, typename Opnd2>
2211 m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2212  return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
2213 }
2214 
2215 //===----------------------------------------------------------------------===//
2216 // Matchers for two-operands operators with the operators in either order
2217 //
2218 
2219 /// Matches a BinaryOperator with LHS and RHS in either order.
2220 template <typename LHS, typename RHS>
2222  return AnyBinaryOp_match<LHS, RHS, true>(L, R);
2223 }
2224 
2225 /// Matches an ICmp with a predicate over LHS and RHS in either order.
2226 /// Swaps the predicate if operands are commuted.
2227 template <typename LHS, typename RHS>
2229 m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
2231  R);
2232 }
2233 
2234 /// Matches a specific opcode with LHS and RHS in either order.
2235 template <typename LHS, typename RHS>
2237 m_c_BinOp(unsigned Opcode, const LHS &L, const RHS &R) {
2238  return SpecificBinaryOp_match<LHS, RHS, true>(Opcode, L, R);
2239 }
2240 
2241 /// Matches a Add with LHS and RHS in either order.
2242 template <typename LHS, typename RHS>
2244  const RHS &R) {
2246 }
2247 
2248 /// Matches a Mul with LHS and RHS in either order.
2249 template <typename LHS, typename RHS>
2251  const RHS &R) {
2253 }
2254 
2255 /// Matches an And with LHS and RHS in either order.
2256 template <typename LHS, typename RHS>
2258  const RHS &R) {
2260 }
2261 
2262 /// Matches an Or with LHS and RHS in either order.
2263 template <typename LHS, typename RHS>
2265  const RHS &R) {
2267 }
2268 
2269 /// Matches an Xor with LHS and RHS in either order.
2270 template <typename LHS, typename RHS>
2272  const RHS &R) {
2274 }
2275 
2276 /// Matches a 'Neg' as 'sub 0, V'.
2277 template <typename ValTy>
2278 inline BinaryOp_match<cst_pred_ty<is_zero_int>, ValTy, Instruction::Sub>
2279 m_Neg(const ValTy &V) {
2280  return m_Sub(m_ZeroInt(), V);
2281 }
2282 
2283 /// Matches a 'Neg' as 'sub nsw 0, V'.
2284 template <typename ValTy>
2286  Instruction::Sub,
2288 m_NSWNeg(const ValTy &V) {
2289  return m_NSWSub(m_ZeroInt(), V);
2290 }
2291 
2292 /// Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
2293 template <typename ValTy>
2294 inline BinaryOp_match<ValTy, cst_pred_ty<is_all_ones>, Instruction::Xor, true>
2295 m_Not(const ValTy &V) {
2296  return m_c_Xor(V, m_AllOnes());
2297 }
2298 
2299 template <typename ValTy> struct NotForbidUndef_match {
2300  ValTy Val;
2301  NotForbidUndef_match(const ValTy &V) : Val(V) {}
2302 
2303  template <typename OpTy> bool match(OpTy *V) {
2304  // We do not use m_c_Xor because that could match an arbitrary APInt that is
2305  // not -1 as C and then fail to match the other operand if it is -1.
2306  // This code should still work even when both operands are constants.
2307  Value *X;
2308  const APInt *C;
2309  if (m_Xor(m_Value(X), m_APIntForbidUndef(C)).match(V) && C->isAllOnes())
2310  return Val.match(X);
2311  if (m_Xor(m_APIntForbidUndef(C), m_Value(X)).match(V) && C->isAllOnes())
2312  return Val.match(X);
2313  return false;
2314  }
2315 };
2316 
2317 /// Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'. For vectors, the
2318 /// constant value must be composed of only -1 scalar elements.
2319 template <typename ValTy>
2321  return NotForbidUndef_match<ValTy>(V);
2322 }
2323 
2324 /// Matches an SMin with LHS and RHS in either order.
2325 template <typename LHS, typename RHS>
2327 m_c_SMin(const LHS &L, const RHS &R) {
2329 }
2330 /// Matches an SMax with LHS and RHS in either order.
2331 template <typename LHS, typename RHS>
2333 m_c_SMax(const LHS &L, const RHS &R) {
2335 }
2336 /// Matches a UMin with LHS and RHS in either order.
2337 template <typename LHS, typename RHS>
2339 m_c_UMin(const LHS &L, const RHS &R) {
2341 }
2342 /// Matches a UMax with LHS and RHS in either order.
2343 template <typename LHS, typename RHS>
2345 m_c_UMax(const LHS &L, const RHS &R) {
2347 }
2348 
2349 template <typename LHS, typename RHS>
2350 inline match_combine_or<
2355 m_c_MaxOrMin(const LHS &L, const RHS &R) {
2356  return m_CombineOr(m_CombineOr(m_c_SMax(L, R), m_c_SMin(L, R)),
2357  m_CombineOr(m_c_UMax(L, R), m_c_UMin(L, R)));
2358 }
2359 
2360 /// Matches FAdd with LHS and RHS in either order.
2361 template <typename LHS, typename RHS>
2363 m_c_FAdd(const LHS &L, const RHS &R) {
2365 }
2366 
2367 /// Matches FMul with LHS and RHS in either order.
2368 template <typename LHS, typename RHS>
2370 m_c_FMul(const LHS &L, const RHS &R) {
2372 }
2373 
2374 template <typename Opnd_t> struct Signum_match {
2375  Opnd_t Val;
2376  Signum_match(const Opnd_t &V) : Val(V) {}
2377 
2378  template <typename OpTy> bool match(OpTy *V) {
2379  unsigned TypeSize = V->getType()->getScalarSizeInBits();
2380  if (TypeSize == 0)
2381  return false;
2382 
2383  unsigned ShiftWidth = TypeSize - 1;
2384  Value *OpL = nullptr, *OpR = nullptr;
2385 
2386  // This is the representation of signum we match:
2387  //
2388  // signum(x) == (x >> 63) | (-x >>u 63)
2389  //
2390  // An i1 value is its own signum, so it's correct to match
2391  //
2392  // signum(x) == (x >> 0) | (-x >>u 0)
2393  //
2394  // for i1 values.
2395 
2396  auto LHS = m_AShr(m_Value(OpL), m_SpecificInt(ShiftWidth));
2397  auto RHS = m_LShr(m_Neg(m_Value(OpR)), m_SpecificInt(ShiftWidth));
2398  auto Signum = m_Or(LHS, RHS);
2399 
2400  return Signum.match(V) && OpL == OpR && Val.match(OpL);
2401  }
2402 };
2403 
2404 /// Matches a signum pattern.
2405 ///
2406 /// signum(x) =
2407 /// x > 0 -> 1
2408 /// x == 0 -> 0
2409 /// x < 0 -> -1
2410 template <typename Val_t> inline Signum_match<Val_t> m_Signum(const Val_t &V) {
2411  return Signum_match<Val_t>(V);
2412 }
2413 
2414 template <int Ind, typename Opnd_t> struct ExtractValue_match {
2415  Opnd_t Val;
2416  ExtractValue_match(const Opnd_t &V) : Val(V) {}
2417 
2418  template <typename OpTy> bool match(OpTy *V) {
2419  if (auto *I = dyn_cast<ExtractValueInst>(V)) {
2420  // If Ind is -1, don't inspect indices
2421  if (Ind != -1 &&
2422  !(I->getNumIndices() == 1 && I->getIndices()[0] == (unsigned)Ind))
2423  return false;
2424  return Val.match(I->getAggregateOperand());
2425  }
2426  return false;
2427  }
2428 };
2429 
2430 /// Match a single index ExtractValue instruction.
2431 /// For example m_ExtractValue<1>(...)
2432 template <int Ind, typename Val_t>
2435 }
2436 
2437 /// Match an ExtractValue instruction with any index.
2438 /// For example m_ExtractValue(...)
2439 template <typename Val_t>
2440 inline ExtractValue_match<-1, Val_t> m_ExtractValue(const Val_t &V) {
2441  return ExtractValue_match<-1, Val_t>(V);
2442 }
2443 
2444 /// Matcher for a single index InsertValue instruction.
2445 template <int Ind, typename T0, typename T1> struct InsertValue_match {
2446  T0 Op0;
2448 
2449  InsertValue_match(const T0 &Op0, const T1 &Op1) : Op0(Op0), Op1(Op1) {}
2450 
2451  template <typename OpTy> bool match(OpTy *V) {
2452  if (auto *I = dyn_cast<InsertValueInst>(V)) {
2453  return Op0.match(I->getOperand(0)) && Op1.match(I->getOperand(1)) &&
2454  I->getNumIndices() == 1 && Ind == I->getIndices()[0];
2455  }
2456  return false;
2457  }
2458 };
2459 
2460 /// Matches a single index InsertValue instruction.
2461 template <int Ind, typename Val_t, typename Elt_t>
2463  const Elt_t &Elt) {
2464  return InsertValue_match<Ind, Val_t, Elt_t>(Val, Elt);
2465 }
2466 
2467 /// Matches patterns for `vscale`. This can either be a call to `llvm.vscale` or
2468 /// the constant expression
2469 /// `ptrtoint(gep <vscale x 1 x i8>, <vscale x 1 x i8>* null, i32 1>`
2470 /// under the right conditions determined by DataLayout.
2472  const DataLayout &DL;
2474 
2475  template <typename ITy> bool match(ITy *V) {
2476  if (m_Intrinsic<Intrinsic::vscale>().match(V))
2477  return true;
2478 
2479  Value *Ptr;
2480  if (m_PtrToInt(m_Value(Ptr)).match(V)) {
2481  if (auto *GEP = dyn_cast<GEPOperator>(Ptr)) {
2482  auto *DerefTy = GEP->getSourceElementType();
2483  if (GEP->getNumIndices() == 1 && isa<ScalableVectorType>(DerefTy) &&
2484  m_Zero().match(GEP->getPointerOperand()) &&
2485  m_SpecificInt(1).match(GEP->idx_begin()->get()) &&
2486  DL.getTypeAllocSizeInBits(DerefTy).getKnownMinSize() == 8)
2487  return true;
2488  }
2489  }
2490 
2491  return false;
2492  }
2493 };
2494 
2496  return VScaleVal_match(DL);
2497 }
2498 
2499 template <typename LHS, typename RHS, unsigned Opcode, bool Commutable = false>
2503 
2504  LogicalOp_match(const LHS &L, const RHS &R) : L(L), R(R) {}
2505 
2506  template <typename T> bool match(T *V) {
2507  auto *I = dyn_cast<Instruction>(V);
2508  if (!I || !I->getType()->isIntOrIntVectorTy(1))
2509  return false;
2510 
2511  if (I->getOpcode() == Opcode) {
2512  auto *Op0 = I->getOperand(0);
2513  auto *Op1 = I->getOperand(1);
2514  return (L.match(Op0) && R.match(Op1)) ||
2515  (Commutable && L.match(Op1) && R.match(Op0));
2516  }
2517 
2518  if (auto *Select = dyn_cast<SelectInst>(I)) {
2519  auto *Cond = Select->getCondition();
2520  auto *TVal = Select->getTrueValue();
2521  auto *FVal = Select->getFalseValue();
2522  if (Opcode == Instruction::And) {
2523  auto *C = dyn_cast<Constant>(FVal);
2524  if (C && C->isNullValue())
2525  return (L.match(Cond) && R.match(TVal)) ||
2526  (Commutable && L.match(TVal) && R.match(Cond));
2527  } else {
2528  assert(Opcode == Instruction::Or);
2529  auto *C = dyn_cast<Constant>(TVal);
2530  if (C && C->isOneValue())
2531  return (L.match(Cond) && R.match(FVal)) ||
2532  (Commutable && L.match(FVal) && R.match(Cond));
2533  }
2534  }
2535 
2536  return false;
2537  }
2538 };
2539 
2540 /// Matches L && R either in the form of L & R or L ? R : false.
2541 /// Note that the latter form is poison-blocking.
2542 template <typename LHS, typename RHS>
2544 m_LogicalAnd(const LHS &L, const RHS &R) {
2546 }
2547 
2548 /// Matches L && R where L and R are arbitrary values.
2549 inline auto m_LogicalAnd() { return m_LogicalAnd(m_Value(), m_Value()); }
2550 
2551 /// Matches L && R with LHS and RHS in either order.
2552 template <typename LHS, typename RHS>
2554 m_c_LogicalAnd(const LHS &L, const RHS &R) {
2556 }
2557 
2558 /// Matches L || R either in the form of L | R or L ? true : R.
2559 /// Note that the latter form is poison-blocking.
2560 template <typename LHS, typename RHS>
2562 m_LogicalOr(const LHS &L, const RHS &R) {
2564 }
2565 
2566 /// Matches L || R where L and R are arbitrary values.
2567 inline auto m_LogicalOr() { return m_LogicalOr(m_Value(), m_Value()); }
2568 
2569 /// Matches L || R with LHS and RHS in either order.
2570 template <typename LHS, typename RHS>
2572 m_c_LogicalOr(const LHS &L, const RHS &R) {
2574 }
2575 
2576 } // end namespace PatternMatch
2577 } // end namespace llvm
2578 
2579 #endif // LLVM_IR_PATTERNMATCH_H
llvm::PatternMatch::apint_match::AllowUndef
bool AllowUndef
Definition: PatternMatch.h:222
llvm::PatternMatch::api_pred_ty
This helper class is used to match scalar and vector constants that satisfy a specified predicate,...
Definition: PatternMatch.h:372
llvm::PatternMatch::specificval_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:776
llvm::PatternMatch::Signum_match
Definition: PatternMatch.h:2374
i
i
Definition: README.txt:29
llvm::PatternMatch::bind_const_intval_ty::bind_const_intval_ty
bind_const_intval_ty(uint64_t &V)
Definition: PatternMatch.h:831
llvm::PatternMatch::MaxMin_match
Definition: PatternMatch.h:1758
llvm::CmpInst::FCMP_ULE
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:734
llvm::PatternMatch::specific_intval::Val
APInt Val
Definition: PatternMatch.h:847
llvm::PatternMatch::m_APFloatForbidUndef
apfloat_match m_APFloatForbidUndef(const APFloat *&Res)
Match APFloat while forbidding undefs in splat vector constants.
Definition: PatternMatch.h:298
llvm::PatternMatch::m_Intrinsic
IntrinsicID_match m_Intrinsic()
Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X))
Definition: PatternMatch.h:2108
llvm::PatternMatch::m_Power2OrZero
cst_pred_ty< is_power2_or_zero > m_Power2OrZero()
Match an integer or vector of 0 or power-of-2 values.
Definition: PatternMatch.h:568
llvm::PatternMatch::is_pos_zero_fp
Definition: PatternMatch.h:678
llvm::PatternMatch::m_FShr
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
Definition: PatternMatch.h:2211
llvm::PatternMatch::is_finitenonzero::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:658
llvm::PatternMatch::m_MaskedGather
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2, Opnd3 >::Ty m_MaskedGather(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2, const Opnd3 &Op3)
Matches MaskedGather Intrinsic.
Definition: PatternMatch.h:2123
llvm::PatternMatch::is_nan::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:612
llvm::PatternMatch::m_SIToFP
CastClass_match< OpTy, Instruction::SIToFP > m_SIToFP(const OpTy &Op)
Definition: PatternMatch.h:1677
llvm::PatternMatch::SpecificBinaryOp_match::SpecificBinaryOp_match
SpecificBinaryOp_match(unsigned Opcode, const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:1234
llvm::PatternMatch::is_zero_int::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:518
llvm::PatternMatch::m_NonNegative
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
Definition: PatternMatch.h:479
llvm::PatternMatch::is_power2_or_zero::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:564
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::PatternMatch::ofmax_pred_ty::match
static bool match(FCmpInst::Predicate Pred)
Definition: PatternMatch.h:1836
llvm::PatternMatch::bind_ty
Definition: PatternMatch.h:707
llvm::PatternMatch::BinaryOp_match
Definition: PatternMatch.h:961
llvm::PatternMatch::Signum_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2378
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::CmpInst::ICMP_EQ
@ ICMP_EQ
equal
Definition: InstrTypes.h:740
llvm::PatternMatch::is_neg_zero_fp
Definition: PatternMatch.h:687
llvm::PatternMatch::m_TruncOrSelf
match_combine_or< CastClass_match< OpTy, Instruction::Trunc >, OpTy > m_TruncOrSelf(const OpTy &Op)
Definition: PatternMatch.h:1627
llvm::PatternMatch::class_match::match
bool match(ITy *V)
Definition: PatternMatch.h:72
llvm::PatternMatch::m_Mask
Definition: PatternMatch.h:1524
llvm::PatternMatch::BinOpPred_match::L
LHS_t L
Definition: PatternMatch.h:1254
llvm::PatternMatch::cstval_pred_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:327
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
llvm::PatternMatch::m_UAddWithOverflow
UAddWithOverflow_match< LHS_t, RHS_t, Sum_t > m_UAddWithOverflow(const LHS_t &L, const RHS_t &R, const Sum_t &S)
Match an icmp instruction checking for unsigned overflow on addition.
Definition: PatternMatch.h:2027
llvm::PatternMatch::m_SpecificFP
specific_fpval m_SpecificFP(double V)
Match a specific floating point value or vector with all elements equal to the value.
Definition: PatternMatch.h:823
llvm::PatternMatch::is_any_apint::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:432
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:719
llvm::PatternMatch::AnyUnaryOp_match::X
OP_t X
Definition: PatternMatch.h:940
llvm::PatternMatch::Exact_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1354
IntrinsicInst.h
llvm::PatternMatch::ThreeOps_match
Matches instructions with Opcode and three operands.
Definition: PatternMatch.h:1451
llvm::PatternMatch::TwoOps_match::Op2
T1 Op2
Definition: PatternMatch.h:1436
llvm::ICmpInst::compare
static bool compare(const APInt &LHS, const APInt &RHS, ICmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
Definition: Instructions.cpp:4162
llvm::PatternMatch::m_NegatedPower2
cst_pred_ty< is_negated_power2 > m_NegatedPower2()
Match a integer or vector negated power-of-2.
Definition: PatternMatch.h:556
llvm::PatternMatch::CmpClass_match::CmpClass_match
CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:1378
llvm::PatternMatch::NotForbidUndef_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2303
llvm::PatternMatch::ExtractValue_match::Val
Opnd_t Val
Definition: PatternMatch.h:2415
llvm::PatternMatch::match_unless::M
Ty M
Definition: PatternMatch.h:166
llvm::PatternMatch::match_combine_and::match_combine_and
match_combine_and(const LTy &Left, const RTy &Right)
Definition: PatternMatch.h:198
llvm::OverflowingBinaryOperator::NoSignedWrap
@ NoSignedWrap
Definition: Operator.h:77
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::PatternMatch::m_NaN
cstfp_pred_ty< is_nan > m_NaN()
Match an arbitrary NaN constant.
Definition: PatternMatch.h:616
llvm::PatternMatch::undef_match::match
bool match(ITy *V)
Definition: PatternMatch.h:130
llvm::PatternMatch::m_LShr
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1127
llvm::PatternMatch::is_one::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:509
llvm::PatternMatch::Shuffle_match::Mask
T2 Mask
Definition: PatternMatch.h:1510
llvm::PatternMatch::m_Mask::m_Mask
m_Mask(ArrayRef< int > &MaskRef)
Definition: PatternMatch.h:1526
llvm::PatternMatch::specificval_ty::specificval_ty
specificval_ty(const Value *V)
Definition: PatternMatch.h:774
llvm::PatternMatch::m_SplatOrUndefMask
Definition: PatternMatch.h:1545
llvm::PatternMatch::deferredval_ty
Stores a reference to the Value *, not the Value * itself, thus can be used in commutative matchers.
Definition: PatternMatch.h:784
llvm::PatternMatch::m_FPOne
specific_fpval m_FPOne()
Match a float 1.0 or vector with all elements equal to 1.0.
Definition: PatternMatch.h:826
llvm::PatternMatch::AnyBinaryOp_match
Definition: PatternMatch.h:913
llvm::PatternMatch::Shuffle_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1515
llvm::PatternMatch::m_InsertElt
ThreeOps_match< Val_t, Elt_t, Idx_t, Instruction::InsertElement > m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx)
Matches InsertElementInst.
Definition: PatternMatch.h:1494
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
llvm::PatternMatch::undef_match
Definition: PatternMatch.h:91
llvm::PatternMatch::m_SpecificMask
Definition: PatternMatch.h:1539
llvm::PatternMatch::m_Freeze
OneOps_match< OpTy, Instruction::Freeze > m_Freeze(const OpTy &Op)
Matches FreezeInst.
Definition: PatternMatch.h:1487
llvm::PatternMatch::m_FRem
BinaryOp_match< LHS, RHS, Instruction::FRem > m_FRem(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1097
llvm::PatternMatch::m_Add
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:988
llvm::PatternMatch::m_MaxSignedValue
cst_pred_ty< is_maxsignedvalue > m_MaxSignedValue()
Match an integer or vector with values having all bits except for the high bit set (0x7f....
Definition: PatternMatch.h:455
llvm::MCID::Commutable
@ Commutable
Definition: MCInstrDesc.h:173
llvm::PatternMatch::specific_fpval::Val
double Val
Definition: PatternMatch.h:806
llvm::PatternMatch::m_Load
OneOps_match< OpTy, Instruction::Load > m_Load(const OpTy &Op)
Matches LoadInst.
Definition: PatternMatch.h:1573
llvm::PatternMatch::match_combine_or::R
RTy R
Definition: PatternMatch.h:181
llvm::PatternMatch::m_CombineOr
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
Definition: PatternMatch.h:210
llvm::PatternMatch::SpecificBinaryOp_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1237
llvm::PatternMatch::ThreeOps_match::ThreeOps_match
ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
Definition: PatternMatch.h:1456
llvm::PatternMatch::br_match::br_match
br_match(BasicBlock *&Succ)
Definition: PatternMatch.h:1708
llvm::PatternMatch::m_SplatOrUndefMask::m_SplatOrUndefMask
m_SplatOrUndefMask(int &SplatIndex)
Definition: PatternMatch.h:1547
llvm::ConstantAggregate
Base class for aggregate constants (with operands).
Definition: Constants.h:385
llvm::PatternMatch::BinaryOp_match::L
LHS_t L
Definition: PatternMatch.h:962
llvm::PatternMatch::m_APFloat
apfloat_match m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
Definition: PatternMatch.h:287
Right
Vector Shift Left Right
Definition: README_P9.txt:118
llvm::PatternMatch::m_Br
brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > > m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
Definition: PatternMatch.h:1741
llvm::PatternMatch::m_BitReverse
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse(const Opnd0 &Op0)
Definition: PatternMatch.h:2172
llvm::PatternMatch::CastClass_match
Definition: PatternMatch.h:1589
llvm::PatternMatch::is_right_shift_op
Definition: PatternMatch.h:1274
llvm::PatternMatch::MaxMin_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1767
llvm::PatternMatch::apf_pred_ty::apf_pred_ty
apf_pred_ty(const APFloat *&R)
Definition: PatternMatch.h:401
APInt.h
llvm::PatternMatch::OneOps_match::Op1
T0 Op1
Definition: PatternMatch.h:1420
llvm::PatternMatch::m_FCanonicalize
m_Intrinsic_Ty< Opnd0 >::Ty m_FCanonicalize(const Opnd0 &Op0)
Definition: PatternMatch.h:2187
llvm::PatternMatch::m_NegZeroFP
cstfp_pred_ty< is_neg_zero_fp > m_NegZeroFP()
Match a floating-point negative zero.
Definition: PatternMatch.h:692
llvm::PatternMatch::m_NUWShl
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1223
llvm::CmpInst::ICMP_SGT
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:746
llvm::PatternMatch::SpecificBinaryOp_match
Definition: PatternMatch.h:1230
llvm::PatternMatch::MaxMin_match::L
LHS_t L
Definition: PatternMatch.h:1760
llvm::PatternMatch::specific_intval
Match a specified integer value or vector of all elements of that value.
Definition: PatternMatch.h:846
llvm::PatternMatch::smin_pred_ty::match
static bool match(ICmpInst::Predicate Pred)
Definition: PatternMatch.h:1815
llvm::PatternMatch::icmp_pred_with_threshold::Thr
const APInt * Thr
Definition: PatternMatch.h:598
llvm::PatternMatch::m_FPToUI
CastClass_match< OpTy, Instruction::FPToUI > m_FPToUI(const OpTy &Op)
Definition: PatternMatch.h:1682
llvm::PatternMatch::constantint_match::match
bool match(ITy *V)
Definition: PatternMatch.h:303
llvm::PatternMatch::m_UnordFMin
MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > m_UnordFMin(const LHS &L, const RHS &R)
Match an 'unordered' floating point minimum function.
Definition: PatternMatch.h:1953
llvm::Instruction::isShift
bool isShift() const
Definition: Instruction.h:164
llvm::PatternMatch::OneOps_match
Matches instructions with Opcode and three operands.
Definition: PatternMatch.h:1419
llvm::PatternMatch::is_maxsignedvalue
Definition: PatternMatch.h:449
llvm::PatternMatch::is_negative::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:463
llvm::PatternMatch::BinOpPred_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1259
T1
#define T1
Definition: Mips16ISelLowering.cpp:340
llvm::PatternMatch::CastClass_match::CastClass_match
CastClass_match(const Op_t &OpMatch)
Definition: PatternMatch.h:1592
llvm::PatternMatch::m_ZExtOrSExtOrSelf
match_combine_or< match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > >, OpTy > m_ZExtOrSExtOrSelf(const OpTy &Op)
Definition: PatternMatch.h:1667
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::PatternMatch::m_BinOp
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
Definition: PatternMatch.h:84
llvm::SmallPtrSet
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:450
llvm::PatternMatch::TwoOps_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1440
llvm::PatternMatch::m_SplatOrUndefMask::match
bool match(ArrayRef< int > Mask)
Definition: PatternMatch.h:1548
llvm::PatternMatch::m_AShr
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1133
llvm::tgtok::FalseVal
@ FalseVal
Definition: TGLexer.h:61
llvm::PatternMatch::InsertValue_match
Matcher for a single index InsertValue instruction.
Definition: PatternMatch.h:2445
llvm::PatternMatch::m_SpecificBB
specific_bbval m_SpecificBB(BasicBlock *BB)
Match a specific basic block value.
Definition: PatternMatch.h:896
Operator.h
llvm::PatternMatch::is_negated_power2
Definition: PatternMatch.h:551
llvm::CmpInst::ICMP_SLE
@ ICMP_SLE
signed less or equal
Definition: InstrTypes.h:749
llvm::PatternMatch::LogicalOp_match::LogicalOp_match
LogicalOp_match(const LHS &L, const RHS &R)
Definition: PatternMatch.h:2504
llvm::PatternMatch::IntrinsicID_match::IntrinsicID_match
IntrinsicID_match(Intrinsic::ID IntrID)
Definition: PatternMatch.h:2055
llvm::PatternMatch::OneOps_match::OneOps_match
OneOps_match(const T0 &Op1)
Definition: PatternMatch.h:1422
llvm::SmallVectorImpl::pop_back_val
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:654
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::PatternMatch::BinaryOp_match::BinaryOp_match
BinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:967
llvm::PatternMatch::bind_const_intval_ty
Definition: PatternMatch.h:828
llvm::PatternMatch::m_c_And
BinaryOp_match< LHS, RHS, Instruction::And, true > m_c_And(const LHS &L, const RHS &R)
Matches an And with LHS and RHS in either order.
Definition: PatternMatch.h:2257
llvm::PatternMatch::m_Mask::match
bool match(ArrayRef< int > Mask)
Definition: PatternMatch.h:1527
llvm::UnaryOperator
Definition: InstrTypes.h:101
llvm::PatternMatch::m_Not
BinaryOp_match< ValTy, cst_pred_ty< is_all_ones >, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
Definition: PatternMatch.h:2295
llvm::PatternMatch::m_BitCast
CastClass_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
Definition: PatternMatch.h:1603
llvm::PatternMatch::ThreeOps_match::Op1
T0 Op1
Definition: PatternMatch.h:1452
llvm::PatternMatch::VScaleVal_match::match
bool match(ITy *V)
Definition: PatternMatch.h:2475
llvm::PatternMatch::m_VScale
VScaleVal_match m_VScale(const DataLayout &DL)
Definition: PatternMatch.h:2495
llvm::CmpInst::FCMP_OGT
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:723
llvm::PatternMatch::bind_const_intval_ty::VR
uint64_t & VR
Definition: PatternMatch.h:829
llvm::PatternMatch::apfloat_match
Definition: PatternMatch.h:245
llvm::PatternMatch::m_Deferred
deferredval_ty< Value > m_Deferred(Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match()...
Definition: PatternMatch.h:798
llvm::PatternMatch::m_ConstantFP
class_match< ConstantFP > m_ConstantFP()
Match an arbitrary ConstantFP and ignore it.
Definition: PatternMatch.h:150
llvm::APIntOps::umin
const APInt & umin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be unsigned.
Definition: APInt.h:2149
llvm::PatternMatch::m_FDiv
BinaryOp_match< LHS, RHS, Instruction::FDiv > m_FDiv(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1079
llvm::PatternMatch::ExtractValue_match::ExtractValue_match
ExtractValue_match(const Opnd_t &V)
Definition: PatternMatch.h:2416
llvm::PatternMatch::m_c_MaxOrMin
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > > > m_c_MaxOrMin(const LHS &L, const RHS &R)
Definition: PatternMatch.h:2355
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::PatternMatch::m_FAdd
BinaryOp_match< LHS, RHS, Instruction::FAdd > m_FAdd(const LHS &L, const RHS &R)
Definition: PatternMatch.h:994
llvm::PatternMatch::umax_pred_ty::match
static bool match(ICmpInst::Predicate Pred)
Definition: PatternMatch.h:1822
llvm::PatternMatch::m_FSub
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1006
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
llvm::PatternMatch::m_Unless
match_unless< Ty > m_Unless(const Ty &M)
Match if the inner matcher does NOT match.
Definition: PatternMatch.h:174
llvm::PatternMatch::MaxMin_match::R
RHS_t R
Definition: PatternMatch.h:1761
llvm::PatternMatch::AnyUnaryOp_match
Definition: PatternMatch.h:939
llvm::PatternMatch::m_c_ICmp
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate, true > m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
Definition: PatternMatch.h:2229
llvm::PatternMatch::is_power2_or_zero
Definition: PatternMatch.h:563
llvm::PatternMatch::m_OneUse
OneUse_match< T > m_OneUse(const T &SubPattern)
Definition: PatternMatch.h:67
llvm::DataLayout::getTypeAllocSizeInBits
TypeSize getTypeAllocSizeInBits(Type *Ty) const
Returns the offset in bits between successive objects of the specified type, including alignment padd...
Definition: DataLayout.h:519
llvm::CmpInst::FCMP_ULT
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:733
llvm::PatternMatch::Signum_match::Val
Opnd_t Val
Definition: PatternMatch.h:2375
llvm::PatternMatch::cstval_pred_ty
This helper class is used to match constant scalars, vector splats, and fixed width vectors that sati...
Definition: PatternMatch.h:326
llvm::PatternMatch::match_combine_and
Definition: PatternMatch.h:194
llvm::AlignStyle::Left
@ Left
llvm::PatternMatch::is_strictlypositive
Definition: PatternMatch.h:486
llvm::BitmaskEnumDetail::Mask
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
Instruction.h
llvm::PatternMatch::m_APInt
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
Definition: PatternMatch.h:270
llvm::PatternMatch::m_c_BinOp
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
Definition: PatternMatch.h:2221
llvm::PatternMatch::m_UMax
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1875
llvm::PatternMatch::m_OrdFMin
MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty > m_OrdFMin(const LHS &L, const RHS &R)
Match an 'ordered' floating point minimum function.
Definition: PatternMatch.h:1922
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
llvm::PatternMatch::is_maxsignedvalue::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:450
llvm::PatternMatch::FNeg_match
Definition: PatternMatch.h:1011
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::all_of
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1605
llvm::PatternMatch::m_LowBitMask
cst_pred_ty< is_lowbit_mask > m_LowBitMask()
Match an integer or vector with only the low bit(s) set.
Definition: PatternMatch.h:589
llvm::PatternMatch::m_UIToFP
CastClass_match< OpTy, Instruction::UIToFP > m_UIToFP(const OpTy &Op)
Definition: PatternMatch.h:1672
llvm::PatternMatch::is_finite::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:648
llvm::PatternMatch::is_idiv_op::isOpType
bool isOpType(unsigned Opcode)
Definition: PatternMatch.h:1293
llvm::PatternMatch::m_Select
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
Definition: PatternMatch.h:1472
llvm::PatternMatch::AnyBinaryOp_match::AnyBinaryOp_match
AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:919
llvm::PatternMatch::smax_pred_ty::match
static bool match(ICmpInst::Predicate Pred)
Definition: PatternMatch.h:1808
llvm::PatternMatch::smin_pred_ty
Helper class for identifying signed min predicates.
Definition: PatternMatch.h:1814
llvm::PatternMatch::m_ZExtOrSExt
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > > m_ZExtOrSExt(const OpTy &Op)
Definition: PatternMatch.h:1658
Constants.h
llvm::PatternMatch::match
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
llvm::PatternMatch::TwoOps_match
Matches instructions with Opcode and three operands.
Definition: PatternMatch.h:1434
llvm::PatternMatch::NotForbidUndef_match::NotForbidUndef_match
NotForbidUndef_match(const ValTy &V)
Definition: PatternMatch.h:2301
llvm::PatternMatch::ufmax_pred_ty
Helper class for identifying unordered max predicates.
Definition: PatternMatch.h:1849
llvm::PatternMatch::is_lowbit_mask::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:585
llvm::PatternMatch::Shuffle_match::Shuffle_match
Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
Definition: PatternMatch.h:1512
llvm::PatternMatch::m_FShl
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
Definition: PatternMatch.h:2205
llvm::PatternMatch::match_combine_and::R
RTy R
Definition: PatternMatch.h:196
f
Itanium Name Demangler i e convert the string _Z1fv into f()". You can also use the CRTP base ManglingParser to perform some simple analysis on the mangled name
llvm::PatternMatch::specific_bbval
Match a specified basic block value.
Definition: PatternMatch.h:884
llvm::PatternMatch::specific_bbval::match
bool match(ITy *V)
Definition: PatternMatch.h:889
llvm::PatternMatch::m_Exact
Exact_match< T > m_Exact(const T &SubPattern)
Definition: PatternMatch.h:1361
llvm::PatternMatch::AnyUnaryOp_match::AnyUnaryOp_match
AnyUnaryOp_match(const OP_t &X)
Definition: PatternMatch.h:942
llvm::PatternMatch::m_UnOp
class_match< UnaryOperator > m_UnOp()
Match an arbitrary unary operation and ignore it.
Definition: PatternMatch.h:79
llvm::PatternMatch::m_SpecificIntAllowUndef
specific_intval< true > m_SpecificIntAllowUndef(APInt V)
Definition: PatternMatch.h:871
Intrinsics.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::CmpInst::ICMP_ULE
@ ICMP_ULE
unsigned less or equal
Definition: InstrTypes.h:745
InstrTypes.h
llvm::PatternMatch::apfloat_match::apfloat_match
apfloat_match(const APFloat *&Res, bool AllowUndef)
Definition: PatternMatch.h:249
llvm::PatternMatch::Exact_match
Definition: PatternMatch.h:1349
llvm::PatternMatch::CastClass_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1594
llvm::PatternMatch::match_combine_or
Matching combinators.
Definition: PatternMatch.h:179
llvm::PatternMatch::BinaryOp_match::R
RHS_t R
Definition: PatternMatch.h:963
llvm::PatternMatch::m_PosZeroFP
cstfp_pred_ty< is_pos_zero_fp > m_PosZeroFP()
Match a floating-point positive zero.
Definition: PatternMatch.h:683
llvm::PatternMatch::m_NonNaN
cstfp_pred_ty< is_nonnan > m_NonNaN()
Match a non-NaN FP constant.
Definition: PatternMatch.h:625
llvm::PatternMatch::is_lowbit_mask
Definition: PatternMatch.h:584
llvm::CmpInst::FCMP_UGE
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:732
t
bitcast float %x to i32 %s=and i32 %t, 2147483647 %d=bitcast i32 %s to float ret float %d } declare float @fabsf(float %n) define float @bar(float %x) nounwind { %d=call float @fabsf(float %x) ret float %d } This IR(from PR6194):target datalayout="e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple="x86_64-apple-darwin10.0.0" %0=type { double, double } %struct.float3=type { float, float, float } define void @test(%0, %struct.float3 *nocapture %res) nounwind noinline ssp { entry:%tmp18=extractvalue %0 %0, 0 t
Definition: README-SSE.txt:788
llvm::PatternMatch::deferredval_ty::Val
Class *const & Val
Definition: PatternMatch.h:785
llvm::PatternMatch::is_bitwiselogic_op
Definition: PatternMatch.h:1286
UINT64_MAX
#define UINT64_MAX
Definition: DataTypes.h:77
llvm::PatternMatch::m_Instruction
bind_ty< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
Definition: PatternMatch.h:726
llvm::PatternMatch::AnyBinaryOp_match::L
LHS_t L
Definition: PatternMatch.h:914
llvm::PatternMatch::class_match
Definition: PatternMatch.h:71
llvm::PatternMatch::bind_ty::bind_ty
bind_ty(Class *&V)
Definition: PatternMatch.h:710
llvm::PatternMatch::m_ZExt
CastClass_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
Definition: PatternMatch.h:1639
llvm::PatternMatch::m_c_Add
BinaryOp_match< LHS, RHS, Instruction::Add, true > m_c_Add(const LHS &L, const RHS &R)
Matches a Add with LHS and RHS in either order.
Definition: PatternMatch.h:2243
First
into llvm powi allowing the code generator to produce balanced multiplication trees First
Definition: README.txt:54
llvm::PatternMatch::is_negated_power2::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:552
llvm::PatternMatch::CmpClass_match::Predicate
PredicateTy & Predicate
Definition: PatternMatch.h:1372
llvm::PatternMatch::m_MaxOrMin
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > > > m_MaxOrMin(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1892
llvm::PatternMatch::m_FNeg
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
Definition: PatternMatch.h:1043
llvm::PatternMatch::ufmin_pred_ty
Helper class for identifying unordered min predicates.
Definition: PatternMatch.h:1856
llvm::PatternMatch::deferredval_ty::deferredval_ty
deferredval_ty(Class *const &V)
Definition: PatternMatch.h:787
llvm::PatternMatch::m_SDiv
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1073
llvm::PatternMatch::m_ConstantInt
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:145
llvm::PatternMatch::is_idiv_op
Definition: PatternMatch.h:1292
llvm::Instruction
Definition: Instruction.h:42
llvm::PatternMatch::m_IDiv
BinOpPred_match< LHS, RHS, is_idiv_op > m_IDiv(const LHS &L, const RHS &R)
Matches integer division operations.
Definition: PatternMatch.h:1334
llvm::PatternMatch::m_NSWMul
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > m_NSWMul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1182
llvm::PatternMatch::icmp_pred_with_threshold::Pred
ICmpInst::Predicate Pred
Definition: PatternMatch.h:597
llvm::PatternMatch::m_UMin
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1881
llvm::PatternMatch::m_c_Or
BinaryOp_match< LHS, RHS, Instruction::Or, true > m_c_Or(const LHS &L, const RHS &R)
Matches an Or with LHS and RHS in either order.
Definition: PatternMatch.h:2264
llvm::PatternMatch::UAddWithOverflow_match::R
RHS_t R
Definition: PatternMatch.h:1965
RHS_t
llvm::PatternMatch::br_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1710
llvm::ConstantFP
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:257
APFloat.h
llvm::PatternMatch::brc_match::Cond
Cond_t Cond
Definition: PatternMatch.h:1724
llvm::PatternMatch::m_NSWSub
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1174
llvm::PatternMatch::apint_match
Definition: PatternMatch.h:220
llvm::PatternMatch::CmpClass_match::R
RHS_t R
Definition: PatternMatch.h:1374
llvm::PatternMatch::apint_match::match
bool match(ITy *V)
Definition: PatternMatch.h:227
llvm::PatternMatch::BinOpPred_match::R
RHS_t R
Definition: PatternMatch.h:1255
llvm::PatternMatch::m_UnordFMax
MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > m_UnordFMax(const LHS &L, const RHS &R)
Match an 'unordered' floating point maximum function.
Definition: PatternMatch.h:1938
llvm::PatternMatch::is_pos_zero_fp::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:679
llvm::CmpInst::FCMP_OLT
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:725
llvm::PatternMatch::m_NonPositive
cst_pred_ty< is_nonpositive > m_NonPositive()
Match an integer or vector of non-positive values.
Definition: PatternMatch.h:503
llvm::PatternMatch::m_URem
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1085
llvm::PatternMatch::OneUse_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:62
llvm::PatternMatch::is_right_shift_op::isOpType
bool isOpType(unsigned Opcode)
Definition: PatternMatch.h:1275
llvm::PatternMatch::apfloat_match::AllowUndef
bool AllowUndef
Definition: PatternMatch.h:247
llvm::PatternMatch::m_APIntAllowUndef
apint_match m_APIntAllowUndef(const APInt *&Res)
Match APInt while allowing undefs in splat vector constants.
Definition: PatternMatch.h:276
llvm::PatternMatch::VScaleVal_match
Matches patterns for vscale.
Definition: PatternMatch.h:2471
LHS_t
llvm::PatternMatch::specificval_ty
Match a specified Value*.
Definition: PatternMatch.h:771
llvm::PatternMatch::is_inf
Definition: PatternMatch.h:629
llvm::PatternMatch::m_Shift
BinOpPred_match< LHS, RHS, is_shift_op > m_Shift(const LHS &L, const RHS &R)
Matches shift operations.
Definition: PatternMatch.h:1306
llvm::PatternMatch::is_sign_mask::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:576
llvm::PatternMatch::Argument_match::Val
Opnd_t Val
Definition: PatternMatch.h:2033
llvm::PatternMatch::SpecificBinaryOp_match::Opcode
unsigned Opcode
Definition: PatternMatch.h:1232
llvm::PatternMatch::is_zero
Definition: PatternMatch.h:526
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::PatternMatch::m_c_UMax
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true > m_c_UMax(const LHS &L, const RHS &R)
Matches a UMax with LHS and RHS in either order.
Definition: PatternMatch.h:2345
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::PatternMatch::m_One
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:513
llvm::PatternMatch::is_logical_shift_op
Definition: PatternMatch.h:1280
llvm::PatternMatch::Shuffle_match::Op1
T0 Op1
Definition: PatternMatch.h:1508
llvm::PatternMatch::bind_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:712
llvm::PatternMatch::FNeg_match::FNeg_match
FNeg_match(const Op_t &Op)
Definition: PatternMatch.h:1014
llvm::PatternMatch::m_ExtractElt
TwoOps_match< Val_t, Idx_t, Instruction::ExtractElement > m_ExtractElt(const Val_t &Val, const Idx_t &Idx)
Matches ExtractElementInst.
Definition: PatternMatch.h:1502
llvm::PatternMatch::m_NSWAdd
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1166
llvm::PatternMatch::ufmin_pred_ty::match
static bool match(FCmpInst::Predicate Pred)
Definition: PatternMatch.h:1857
llvm::PatternMatch::m_Power2
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
Definition: PatternMatch.h:544
llvm::PatternMatch::m_Xor
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1115
llvm::PatternMatch::m_Shr
BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)
Matches logical shift operations.
Definition: PatternMatch.h:1313
llvm::PatternMatch::api_pred_ty::api_pred_ty
api_pred_ty(const APInt *&R)
Definition: PatternMatch.h:375
llvm::PatternMatch::m_FMax
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMax(const Opnd0 &Op0, const Opnd1 &Op1)
Definition: PatternMatch.h:2198
llvm::PatternMatch::OverflowingBinaryOp_match::R
RHS_t R
Definition: PatternMatch.h:1142
llvm::PatternMatch::m_FPTrunc
CastClass_match< OpTy, Instruction::FPTrunc > m_FPTrunc(const OpTy &Op)
Definition: PatternMatch.h:1692
llvm::PatternMatch::m_ZExtOrSelf
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, OpTy > m_ZExtOrSelf(const OpTy &Op)
Definition: PatternMatch.h:1645
llvm::PatternMatch::ExtractValue_match
Definition: PatternMatch.h:2414
llvm::PatternMatch::is_nonpositive
Definition: PatternMatch.h:498
llvm::APFloat
Definition: APFloat.h:700
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:239
llvm::PPC::Predicate
Predicate
Predicate - These are "(BI << 5) | BO" for various predicates.
Definition: PPCPredicates.h:26
llvm::PatternMatch::TwoOps_match::TwoOps_match
TwoOps_match(const T0 &Op1, const T1 &Op2)
Definition: PatternMatch.h:1438
llvm::PatternMatch::m_Zero
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
Definition: PatternMatch.h:535
llvm::PatternMatch::NotForbidUndef_match::Val
ValTy Val
Definition: PatternMatch.h:2300
llvm::PatternMatch::m_NUWAdd
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1199
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::PatternMatch::is_power2
Definition: PatternMatch.h:539
llvm::PatternMatch::match_combine_or::L
LTy L
Definition: PatternMatch.h:180
llvm::PatternMatch::m_UnconditionalBr
br_match m_UnconditionalBr(BasicBlock *&Succ)
Definition: PatternMatch.h:1720
llvm::PatternMatch::LogicalOp_match::match
bool match(T *V)
Definition: PatternMatch.h:2506
llvm::PatternMatch::m_ImmConstant
match_combine_and< class_match< Constant >, match_unless< class_match< ConstantExpr > > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
Definition: PatternMatch.h:759
llvm::PatternMatch::apf_pred_ty
This helper class is used to match scalar and vector constants that satisfy a specified predicate,...
Definition: PatternMatch.h:398
llvm::PatternMatch::smax_pred_ty
Helper class for identifying signed max predicates.
Definition: PatternMatch.h:1807
uint64_t
llvm::PatternMatch::m_LogicalOr
LogicalOp_match< LHS, RHS, Instruction::Or > m_LogicalOr(const LHS &L, const RHS &R)
Matches L || R either in the form of L | R or L ? true : R.
Definition: PatternMatch.h:2562
llvm::PatternMatch::m_Inf
cstfp_pred_ty< is_inf > m_Inf()
Match a positive or negative infinity FP constant.
Definition: PatternMatch.h:634
llvm::PatternMatch::is_finitenonzero
Definition: PatternMatch.h:657
llvm::PatternMatch::is_non_zero_fp
Definition: PatternMatch.h:696
llvm::PatternMatch::m_SpecificMask::match
bool match(ArrayRef< int > Mask)
Definition: PatternMatch.h:1542
llvm::PatternMatch::bind_const_intval_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:833
llvm::PatternMatch::specific_intval::specific_intval
specific_intval(APInt V)
Definition: PatternMatch.h:849
llvm::PatternMatch::match_combine_and::L
LTy L
Definition: PatternMatch.h:195
llvm::PatternMatch::IntrinsicID_match::ID
unsigned ID
Definition: PatternMatch.h:2053
llvm::PatternMatch::Argument_match::Argument_match
Argument_match(unsigned OpIdx, const Opnd_t &V)
Definition: PatternMatch.h:2035
llvm::PatternMatch::m_Or
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1109
llvm::PatternMatch::m_AllOnes
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
Definition: PatternMatch.h:445
llvm::PatternMatch::m_NonInf
cstfp_pred_ty< is_noninf > m_NonInf()
Match a non-infinity FP constant, i.e.
Definition: PatternMatch.h:643
llvm::PatternMatch::UAddWithOverflow_match::S
Sum_t S
Definition: PatternMatch.h:1966
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::PatternMatch::icmp_pred_with_threshold
Definition: PatternMatch.h:596
llvm::PatternMatch::InsertValue_match::Op0
T0 Op0
Definition: PatternMatch.h:2446
llvm::PatternMatch::m_Store
TwoOps_match< ValueOpTy, PointerOpTy, Instruction::Store > m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp)
Matches StoreInst.
Definition: PatternMatch.h:1580
llvm::PatternMatch::UAddWithOverflow_match
Definition: PatternMatch.h:1963
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::PatternMatch::is_all_ones
Definition: PatternMatch.h:440
llvm::PatternMatch::m_FAbs
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
Definition: PatternMatch.h:2182
llvm::PatternMatch::m_MaskedLoad
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2, Opnd3 >::Ty m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2, const Opnd3 &Op3)
Matches MaskedLoad Intrinsic.
Definition: PatternMatch.h:2115
llvm::PatternMatch::m_And
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1103
llvm::PatternMatch::LogicalOp_match::R
RHS R
Definition: PatternMatch.h:2502
llvm::PatternMatch::specific_bbval::Val
BasicBlock * Val
Definition: PatternMatch.h:885
llvm::PatternMatch::MaxMin_match::PredType
Pred_t PredType
Definition: PatternMatch.h:1759
llvm::PatternMatch::m_SRem
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1091
llvm::PatternMatch::AnyBinaryOp_match::R
RHS_t R
Definition: PatternMatch.h:915
llvm::PatternMatch::is_one
Definition: PatternMatch.h:508
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::PatternMatch::OverflowingBinaryOp_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1147
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1663
llvm::PatternMatch::OneUse_match::OneUse_match
OneUse_match(const SubPattern_t &SP)
Definition: PatternMatch.h:60
llvm::PatternMatch::m_Sub
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1000
llvm::PatternMatch::MaxMin_match::MaxMin_match
MaxMin_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:1765
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::PatternMatch::OneOps_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1424
llvm::CmpInst::FCMP_OGE
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:724
llvm::PatternMatch::is_inf::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:630
llvm::PatternMatch::BinaryOp_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:984
llvm::PatternMatch::UAddWithOverflow_match::L
LHS_t L
Definition: PatternMatch.h:1964
llvm::PatternMatch::Shuffle_match::Op2
T1 Op2
Definition: PatternMatch.h:1509
llvm::PatternMatch::umin_pred_ty
Helper class for identifying unsigned min predicates.
Definition: PatternMatch.h:1828
llvm::PatternMatch::Shuffle_match
Matches shuffle.
Definition: PatternMatch.h:1507
llvm::CmpInst::ICMP_UGE
@ ICMP_UGE
unsigned greater or equal
Definition: InstrTypes.h:743
llvm::PatternMatch::m_NotForbidUndef
NotForbidUndef_match< ValTy > m_NotForbidUndef(const ValTy &V)
Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'.
Definition: PatternMatch.h:2320
llvm::PatternMatch::brc_match
Definition: PatternMatch.h:1723
llvm::PatternMatch::m_ZeroMask
Definition: PatternMatch.h:1533
llvm::PatternMatch::specificval_ty::Val
const Value * Val
Definition: PatternMatch.h:772
llvm::PatternMatch::m_WithOverflowInst
bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
Definition: PatternMatch.h:732
llvm::PatternMatch::m_SMin
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1869
llvm::PatternMatch::bind_ty::VR
Class *& VR
Definition: PatternMatch.h:708
llvm::PatternMatch::m_Negative
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
Definition: PatternMatch.h:467
llvm::PatternMatch::specific_fpval::match
bool match(ITy *V)
Definition: PatternMatch.h:810
llvm::PatternMatch::is_finite
Definition: PatternMatch.h:647
llvm::PatternMatch::m_Constant
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
Definition: PatternMatch.h:142
llvm::PatternMatch::is_nonnegative::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:475
llvm::PatternMatch::apf_pred_ty::Res
const APFloat *& Res
Definition: PatternMatch.h:399
llvm::PatternMatch::AnyUnaryOp_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:944
llvm::PatternMatch::m_Value
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:76
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::CmpInst::ICMP_SLT
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:748
llvm::APIntOps::smin
const APInt & smin(const APInt &A, const APInt &B)
Determine the smaller of two APInts considered to be signed.
Definition: APInt.h:2139
llvm::PatternMatch::m_SExt
CastClass_match< OpTy, Instruction::SExt > m_SExt(const OpTy &Op)
Matches SExt.
Definition: PatternMatch.h:1633
llvm::PatternMatch::is_nan
Definition: PatternMatch.h:611
llvm::PatternMatch::specific_fpval
Match a specified floating point value or vector of all elements of that value.
Definition: PatternMatch.h:805
llvm::PatternMatch::LogicalOp_match
Definition: PatternMatch.h:2500
llvm::PatternMatch::m_SpecificMask::m_SpecificMask
m_SpecificMask(ArrayRef< int > &MaskRef)
Definition: PatternMatch.h:1541
llvm::PatternMatch::FNeg_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1015
llvm::PatternMatch::m_SpecificInt
specific_intval< false > m_SpecificInt(APInt V)
Match a specific integer value or vector with all elements equal to the value.
Definition: PatternMatch.h:863
llvm::PatternMatch::m_CombineAnd
match_combine_and< LTy, RTy > m_CombineAnd(const LTy &L, const RTy &R)
Combine two pattern matchers matching L && R.
Definition: PatternMatch.h:216
llvm::PatternMatch::m_NUWMul
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWMul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1215
llvm::ArrayRef< int >
llvm::PatternMatch::FNeg_match::X
Op_t X
Definition: PatternMatch.h:1012
llvm::BinaryOperator
Definition: InstrTypes.h:188
llvm::PatternMatch::is_nonnan::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:621
llvm::PatternMatch::VScaleVal_match::DL
const DataLayout & DL
Definition: PatternMatch.h:2472
Mul
BinaryOperator * Mul
Definition: X86PartialReduction.cpp:70
llvm::PatternMatch::is_noninf
Definition: PatternMatch.h:638
DataLayout.h
llvm::PatternMatch::m_SpecificInt_ICMP
cst_pred_ty< icmp_pred_with_threshold > m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold)
Match an integer or vector with every element comparing 'pred' (eg/ne/...) to Threshold.
Definition: PatternMatch.h:604
llvm::PatternMatch::match
bool match(ArrayRef< int > Mask, const Pattern &P)
Definition: PatternMatch.h:53
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:178
llvm::PatternMatch::ThreeOps_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1459
llvm::PatternMatch::m_Undef
auto m_Undef()
Match an arbitrary undef constant.
Definition: PatternMatch.h:136
llvm::CmpInst::ICMP_ULT
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:744
llvm::PatternMatch::brc_match::T
TrueBlock_t T
Definition: PatternMatch.h:1725
llvm::Constant::getAggregateElement
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:410
llvm::PatternMatch::ThreeOps_match::Op2
T1 Op2
Definition: PatternMatch.h:1453
llvm::PatternMatch::is_sign_mask
Definition: PatternMatch.h:575
llvm::PatternMatch::m_Shuffle
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
Definition: PatternMatch.h:1561
llvm::PatternMatch::Exact_match::SubPattern
SubPattern_t SubPattern
Definition: PatternMatch.h:1350
llvm::PatternMatch::m_FiniteNonZero
cstfp_pred_ty< is_finitenonzero > m_FiniteNonZero()
Match a finite non-zero FP constant.
Definition: PatternMatch.h:662
llvm::PatternMatch::m_NonZeroFP
cstfp_pred_ty< is_non_zero_fp > m_NonZeroFP()
Match a floating-point non-zero.
Definition: PatternMatch.h:701
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::PatternMatch::is_irem_op
Definition: PatternMatch.h:1298
llvm::PatternMatch::icmp_pred_with_threshold::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:599
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::PatternMatch::m_Argument
Argument_match< Opnd_t > m_Argument(const Opnd_t &Op)
Match an argument.
Definition: PatternMatch.h:2047
v2
llvm lib Support Unix the directory structure underneath this directory could look like only those directories actually needing to be created should be created further subdirectories could be created to reflect versions of the various standards For under SUS there could be v2
Definition: README.txt:15
llvm::PatternMatch::apint_match::Res
const APInt *& Res
Definition: PatternMatch.h:221
llvm::WithOverflowInst
Represents an op.with.overflow intrinsic.
Definition: IntrinsicInst.h:677
llvm::PatternMatch::Argument_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2037
llvm::PatternMatch::is_irem_op::isOpType
bool isOpType(unsigned Opcode)
Definition: PatternMatch.h:1299
llvm::PatternMatch::match_combine_or::match
bool match(ITy *V)
Definition: PatternMatch.h:185
llvm::PatternMatch::m_IRem
BinOpPred_match< LHS, RHS, is_irem_op > m_IRem(const LHS &L, const RHS &R)
Matches integer remainder operations.
Definition: PatternMatch.h:1341
llvm::PatternMatch::m_SMax
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1863
llvm::PatternMatch::UAddWithOverflow_match::UAddWithOverflow_match
UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
Definition: PatternMatch.h:1968
llvm::PatternMatch::VScaleVal_match::VScaleVal_match
VScaleVal_match(const DataLayout &DL)
Definition: PatternMatch.h:2473
llvm::PatternMatch::m_Poison
class_match< PoisonValue > m_Poison()
Match an arbitrary poison constant.
Definition: PatternMatch.h:139
llvm::PatternMatch::is_power2::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:540
llvm::PatternMatch::m_SpecificMask::MaskRef
ArrayRef< int > & MaskRef
Definition: PatternMatch.h:1540
llvm::PatternMatch::m_OrdFMax
MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty > m_OrdFMax(const LHS &L, const RHS &R)
Match an 'ordered' floating point maximum function.
Definition: PatternMatch.h:1907
llvm::PatternMatch::constantint_match
Definition: PatternMatch.h:302
llvm::PatternMatch::deferredval_ty::match
bool match(ITy *const V)
Definition: PatternMatch.h:789
llvm::find_if
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1632
llvm::PatternMatch::m_c_SMax
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true > m_c_SMax(const LHS &L, const RHS &R)
Matches an SMax with LHS and RHS in either order.
Definition: PatternMatch.h:2333
llvm::PatternMatch::is_negative
Definition: PatternMatch.h:462
llvm::PatternMatch::m_StrictlyPositive
cst_pred_ty< is_strictlypositive > m_StrictlyPositive()
Match an integer or vector of strictly positive values.
Definition: PatternMatch.h:491
llvm::PatternMatch::m_FMin
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMin(const Opnd0 &Op0, const Opnd1 &Op1)
Definition: PatternMatch.h:2192
llvm::MCID::Select
@ Select
Definition: MCInstrDesc.h:164
llvm::PatternMatch::InsertValue_match::Op1
T1 Op1
Definition: PatternMatch.h:2447
llvm::PatternMatch::LogicalOp_match::L
LHS L
Definition: PatternMatch.h:2501
llvm::PatternMatch::m_BitwiseLogic
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
Definition: PatternMatch.h:1328
llvm::PatternMatch::m_FPExt
CastClass_match< OpTy, Instruction::FPExt > m_FPExt(const OpTy &Op)
Definition: PatternMatch.h:1697
llvm::APIntOps::umax
const APInt & umax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be unsigned.
Definition: APInt.h:2154
llvm::CmpInst::FCMP_UGT
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:731
llvm::PatternMatch::IntrinsicID_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2057
Constant.h
llvm::PatternMatch::m_SExtOrSelf
match_combine_or< CastClass_match< OpTy, Instruction::SExt >, OpTy > m_SExtOrSelf(const OpTy &Op)
Definition: PatternMatch.h:1651
llvm::X86II::T8
@ T8
Definition: X86BaseInfo.h:808
llvm::PatternMatch::InsertValue_match::InsertValue_match
InsertValue_match(const T0 &Op0, const T1 &Op1)
Definition: PatternMatch.h:2449
llvm::ConstantExpr
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:971
llvm::PatternMatch::is_bitwiselogic_op::isOpType
bool isOpType(unsigned Opcode)
Definition: PatternMatch.h:1287
llvm::PatternMatch::is_noninf::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:639
std
Definition: BitVector.h:851
llvm::PatternMatch::m_UDiv
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1067
llvm::PatternMatch::is_all_ones::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:441
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:341
v1
llvm lib Support Unix the directory structure underneath this directory could look like only those directories actually needing to be created should be created further subdirectories could be created to reflect versions of the various standards For under SUS there could be v1
Definition: README.txt:15
llvm::PatternMatch::BinOpPred_match
Definition: PatternMatch.h:1253
llvm::PatternMatch::m_FPToSI
CastClass_match< OpTy, Instruction::FPToSI > m_FPToSI(const OpTy &Op)
Definition: PatternMatch.h:1687
llvm::PatternMatch::m_c_SMin
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > m_c_SMin(const LHS &L, const RHS &R)
Matches an SMin with LHS and RHS in either order.
Definition: PatternMatch.h:2327
llvm::PatternMatch::m_ZeroMask::match
bool match(ArrayRef< int > Mask)
Definition: PatternMatch.h:1534
llvm::TypeSize
Definition: TypeSize.h:421
llvm::PatternMatch::undef_match::check
static bool check(const Value *V)
Definition: PatternMatch.h:92
llvm::PatternMatch::specific_fpval::specific_fpval
specific_fpval(double V)
Definition: PatternMatch.h:808
Casting.h
llvm::PatternMatch::m_SignMask
cst_pred_ty< is_sign_mask > m_SignMask()
Match an integer or vector with only the sign bit(s) set.
Definition: PatternMatch.h:580
llvm::APInt::isSameValue
static bool isSameValue(const APInt &I1, const APInt &I2)
Determine if two APInts have the same value, after zero-extending one of them (if needed!...
Definition: APInt.h:534
llvm::PatternMatch::CmpClass_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1381
llvm::PatternMatch::m_NSWShl
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > m_NSWShl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1190
llvm::PatternMatch::m_BSwap
m_Intrinsic_Ty< Opnd0 >::Ty m_BSwap(const Opnd0 &Op0)
Definition: PatternMatch.h:2177
llvm::PatternMatch::ExtractValue_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2418
llvm::PatternMatch::m_c_LogicalAnd
LogicalOp_match< LHS, RHS, Instruction::And, true > m_c_LogicalAnd(const LHS &L, const RHS &R)
Matches L && R with LHS and RHS in either order.
Definition: PatternMatch.h:2554
llvm::PatternMatch::umax_pred_ty
Helper class for identifying unsigned max predicates.
Definition: PatternMatch.h:1821
llvm::PatternMatch::m_ExtractValue
ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)
Match a single index ExtractValue instruction.
Definition: PatternMatch.h:2433
llvm::PatternMatch::m_c_Mul
BinaryOp_match< LHS, RHS, Instruction::Mul, true > m_c_Mul(const LHS &L, const RHS &R)
Matches a Mul with LHS and RHS in either order.
Definition: PatternMatch.h:2250
llvm::PatternMatch::BinOpPred_match::BinOpPred_match
BinOpPred_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:1257
llvm::PatternMatch::m_ZeroInt
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
Definition: PatternMatch.h:522
llvm::PatternMatch::is_any_apint
Definition: PatternMatch.h:431
llvm::PatternMatch::m_PtrToInt
CastClass_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
Definition: PatternMatch.h:1609
llvm::CmpInst::ICMP_SGE
@ ICMP_SGE
signed greater or equal
Definition: InstrTypes.h:747
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:185
llvm::PatternMatch::m_Signum
Signum_match< Val_t > m_Signum(const Val_t &V)
Matches a signum pattern.
Definition: PatternMatch.h:2410
llvm::Instruction::isBitwiseLogicOp
bool isBitwiseLogicOp() const
Return true if this is and/or/xor.
Definition: Instruction.h:217
llvm::PatternMatch::is_non_zero_fp::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:697
llvm::PatternMatch::m_APFloatAllowUndef
apfloat_match m_APFloatAllowUndef(const APFloat *&Res)
Match APFloat while allowing undefs in splat vector constants.
Definition: PatternMatch.h:293
llvm::PatternMatch::InsertValue_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2451
llvm::PatternMatch::m_c_Xor
BinaryOp_match< LHS, RHS, Instruction::Xor, true > m_c_Xor(const LHS &L, const RHS &R)
Matches an Xor with LHS and RHS in either order.
Definition: PatternMatch.h:2271
llvm::PatternMatch::brc_match::brc_match
brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
Definition: PatternMatch.h:1728
llvm::PatternMatch::m_Mask::MaskRef
ArrayRef< int > & MaskRef
Definition: PatternMatch.h:1525
llvm::PatternMatch::m_LogicalShift
BinOpPred_match< LHS, RHS, is_logical_shift_op > m_LogicalShift(const LHS &L, const RHS &R)
Matches logical shift operations.
Definition: PatternMatch.h:1321
llvm::PatternMatch::api_pred_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:377
llvm::PatternMatch::ThreeOps_match::Op3
T2 Op3
Definition: PatternMatch.h:1454
llvm::PatternMatch::m_AnyZeroFP
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
Definition: PatternMatch.h:674
llvm::PatternMatch::m_NUWSub
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWSub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1207
llvm::PatternMatch::Argument_match
Definition: PatternMatch.h:2031
llvm::PatternMatch::br_match::Succ
BasicBlock *& Succ
Definition: PatternMatch.h:1706
llvm::PatternMatch::ofmax_pred_ty
Helper class for identifying ordered max predicates.
Definition: PatternMatch.h:1835
llvm::PatternMatch::OverflowingBinaryOp_match::OverflowingBinaryOp_match
OverflowingBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:1144
llvm::PatternMatch::m_ConstantExpr
class_match< ConstantExpr > m_ConstantExpr()
Match an arbitrary ConstantExpr and ignore it.
Definition: PatternMatch.h:155
llvm::PatternMatch::is_shift_op
Definition: PatternMatch.h:1270
llvm::PatternMatch::m_Intrinsic_Ty
Intrinsic matches are combinations of ID matchers, and argument matchers.
Definition: PatternMatch.h:2073
llvm::PatternMatch::m_c_FMul
BinaryOp_match< LHS, RHS, Instruction::FMul, true > m_c_FMul(const LHS &L, const RHS &R)
Matches FMul with LHS and RHS in either order.
Definition: PatternMatch.h:2370
Instructions.h
llvm::Pattern
Definition: FileCheckImpl.h:614
llvm::PatternMatch::m_c_FAdd
BinaryOp_match< LHS, RHS, Instruction::FAdd, true > m_c_FAdd(const LHS &L, const RHS &R)
Matches FAdd with LHS and RHS in either order.
Definition: PatternMatch.h:2363
llvm::PatternMatch::m_AnyIntegralConstant
cst_pred_ty< is_any_apint > m_AnyIntegralConstant()
Match an integer or vector with any integral constant.
Definition: PatternMatch.h:436
llvm::PatternMatch::apint_match::apint_match
apint_match(const APInt *&Res, bool AllowUndef)
Definition: PatternMatch.h:224
llvm::PatternMatch::m_Specific
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:780
llvm::PatternMatch::m_ICmp
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Definition: PatternMatch.h:1404
llvm::CmpInst::ICMP_UGT
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:742
llvm::PatternMatch::OverflowingBinaryOp_match::L
LHS_t L
Definition: PatternMatch.h:1141
llvm::PatternMatch::brc_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1731
llvm::PatternMatch::m_SplatOrUndefMask::SplatIndex
int & SplatIndex
Definition: PatternMatch.h:1546
llvm::PatternMatch::TwoOps_match::Op1
T0 Op1
Definition: PatternMatch.h:1435
llvm::PatternMatch::Signum_match::Signum_match
Signum_match(const Opnd_t &V)
Definition: PatternMatch.h:2376
llvm::PatternMatch::is_shift_op::isOpType
bool isOpType(unsigned Opcode)
Definition: PatternMatch.h:1271
llvm::PatternMatch::CmpClass_match::L
LHS_t L
Definition: PatternMatch.h:1373
llvm::PatternMatch::specific_intval::match
bool match(ITy *V)
Definition: PatternMatch.h:851
llvm::PatternMatch::is_nonpositive::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:499
llvm::PatternMatch::m_NSWNeg
OverflowingBinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWNeg(const ValTy &V)
Matches a 'Neg' as 'sub nsw 0, V'.
Definition: PatternMatch.h:2288
llvm::PatternMatch::BinaryOp_match::match
bool match(unsigned Opc, OpTy *V)
Definition: PatternMatch.h:969
llvm::PatternMatch::UAddWithOverflow_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1971
llvm::TypeSize::getKnownMinSize
ScalarTy getKnownMinSize() const
Definition: TypeSize.h:431
llvm::PatternMatch::match_unless::match
bool match(ITy *V)
Definition: PatternMatch.h:170
llvm::PatternMatch::api_pred_ty::Res
const APInt *& Res
Definition: PatternMatch.h:373
llvm::CmpInst::FCMP_OLE
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:726
llvm::PatternMatch::m_FCmp
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Definition: PatternMatch.h:1410
llvm::PatternMatch::ofmin_pred_ty
Helper class for identifying ordered min predicates.
Definition: PatternMatch.h:1842
llvm::PatternMatch::m_IntToPtr
CastClass_match< OpTy, Instruction::IntToPtr > m_IntToPtr(const OpTy &Op)
Matches IntToPtr.
Definition: PatternMatch.h:1615
llvm::PatternMatch::m_Neg
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
Definition: PatternMatch.h:2279
llvm::PatternMatch::m_InsertValue
InsertValue_match< Ind, Val_t, Elt_t > m_InsertValue(const Val_t &Val, const Elt_t &Elt)
Matches a single index InsertValue instruction.
Definition: PatternMatch.h:2462
llvm::PatternMatch::is_neg_zero_fp::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:688
llvm::PatternMatch::specific_bbval::specific_bbval
specific_bbval(BasicBlock *Val)
Definition: PatternMatch.h:887
llvm::PatternMatch::is_any_zero_fp
Definition: PatternMatch.h:669
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::PatternMatch::match_unless
Inverting matcher.
Definition: PatternMatch.h:165
GEP
Hexagon Common GEP
Definition: HexagonCommonGEP.cpp:172
llvm::PatternMatch::is_strictlypositive::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:487
llvm::PatternMatch::match_combine_or::match_combine_or
match_combine_or(const LTy &Left, const RTy &Right)
Definition: PatternMatch.h:183
llvm::PatternMatch::is_nonnegative
Definition: PatternMatch.h:474
llvm::PatternMatch::CmpClass_match
Definition: PatternMatch.h:1371
llvm::PatternMatch::Argument_match::OpI
unsigned OpI
Definition: PatternMatch.h:2032
llvm::PatternMatch::m_APIntForbidUndef
apint_match m_APIntForbidUndef(const APInt *&Res)
Match APInt while forbidding undefs in splat vector constants.
Definition: PatternMatch.h:281
llvm::PatternMatch::m_BasicBlock
class_match< BasicBlock > m_BasicBlock()
Match an arbitrary basic block value and ignore it.
Definition: PatternMatch.h:160
llvm::PatternMatch::umin_pred_ty::match
static bool match(ICmpInst::Predicate Pred)
Definition: PatternMatch.h:1829
llvm::PatternMatch::m_Finite
cstfp_pred_ty< is_finite > m_Finite()
Match a finite FP constant, i.e.
Definition: PatternMatch.h:652
llvm::PatternMatch::NotForbidUndef_match
Definition: PatternMatch.h:2299
llvm::PatternMatch::is_zero_int
Definition: PatternMatch.h:517
llvm::PatternMatch::apfloat_match::Res
const APFloat *& Res
Definition: PatternMatch.h:246
llvm::PatternMatch::match_unless::match_unless
match_unless(const Ty &Matcher)
Definition: PatternMatch.h:168
llvm::PatternMatch::m_Trunc
CastClass_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
Definition: PatternMatch.h:1621
llvm::PatternMatch::match_combine_and::match
bool match(ITy *V)
Definition: PatternMatch.h:200
llvm::PatternMatch::is_nonnan
Definition: PatternMatch.h:620
llvm::PatternMatch::apfloat_match::match
bool match(ITy *V)
Definition: PatternMatch.h:252
llvm::PatternMatch::CastClass_match::Op
Op_t Op
Definition: PatternMatch.h:1590
llvm::PatternMatch::ofmin_pred_ty::match
static bool match(FCmpInst::Predicate Pred)
Definition: PatternMatch.h:1843
llvm::PatternMatch::m_SelectCst
ThreeOps_match< Cond, constantint_match< L >, constantint_match< R >, Instruction::Select > m_SelectCst(const Cond &C)
This matches a select of two constants, e.g.
Definition: PatternMatch.h:1481
llvm::PatternMatch::m_FMul
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1061
llvm::tgtok::TrueVal
@ TrueVal
Definition: TGLexer.h:61
llvm::PatternMatch::is_any_zero_fp::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:670
Value.h
llvm::PatternMatch::m_c_LogicalOr
LogicalOp_match< LHS, RHS, Instruction::Or, true > m_c_LogicalOr(const LHS &L, const RHS &R)
Matches L || R with LHS and RHS in either order.
Definition: PatternMatch.h:2572
llvm::PatternMatch::m_Cmp
class_match< CmpInst > m_Cmp()
Matches any compare instruction and ignore it.
Definition: PatternMatch.h:89
llvm::PatternMatch::is_logical_shift_op::isOpType
bool isOpType(unsigned Opcode)
Definition: PatternMatch.h:1281
llvm::OverflowingBinaryOperator::NoUnsignedWrap
@ NoUnsignedWrap
Definition: Operator.h:76
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::PatternMatch::m_Shl
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1121
llvm::PatternMatch::m_FNegNSZ
BinaryOp_match< cstfp_pred_ty< is_any_zero_fp >, RHS, Instruction::FSub > m_FNegNSZ(const RHS &X)
Match 'fneg X' as 'fsub +-0.0, X'.
Definition: PatternMatch.h:1050
llvm::PatternMatch::OneUse_match
Definition: PatternMatch.h:57
llvm::APIntOps::smax
const APInt & smax(const APInt &A, const APInt &B)
Determine the larger of two APInts considered to be signed.
Definition: APInt.h:2144
llvm::PatternMatch::m_LogicalAnd
LogicalOp_match< LHS, RHS, Instruction::And > m_LogicalAnd(const LHS &L, const RHS &R)
Matches L && R either in the form of L & R or L ? R : false.
Definition: PatternMatch.h:2544
llvm::PatternMatch::Exact_match::Exact_match
Exact_match(const SubPattern_t &SP)
Definition: PatternMatch.h:1352
llvm::PatternMatch::apf_pred_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:403
llvm::PatternMatch::OneUse_match::SubPattern
SubPattern_t SubPattern
Definition: PatternMatch.h:58
llvm::PatternMatch::AnyBinaryOp_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:921
llvm::PatternMatch::m_c_UMin
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > m_c_UMin(const LHS &L, const RHS &R)
Matches a UMin with LHS and RHS in either order.
Definition: PatternMatch.h:2339
llvm::PatternMatch::m_Mul
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1055
llvm::PatternMatch::ufmax_pred_ty::match
static bool match(FCmpInst::Predicate Pred)
Definition: PatternMatch.h:1850
llvm::PatternMatch::is_zero::match
bool match(ITy *V)
Definition: PatternMatch.h:527
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:927
llvm::PatternMatch::OverflowingBinaryOp_match
Definition: PatternMatch.h:1140
llvm::PatternMatch::IntrinsicID_match
Intrinsic matchers.
Definition: PatternMatch.h:2052
llvm::SmallPtrSetImpl::insert
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:365
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37
llvm::PatternMatch::br_match
Definition: PatternMatch.h:1705
llvm::PatternMatch::brc_match::F
FalseBlock_t F
Definition: PatternMatch.h:1726