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  return class_match<PoisonValue>();
141 }
142 
143 /// Match an arbitrary Constant and ignore it.
145 
146 /// Match an arbitrary ConstantInt and ignore it.
148  return class_match<ConstantInt>();
149 }
150 
151 /// Match an arbitrary ConstantFP and ignore it.
153  return class_match<ConstantFP>();
154 }
155 
156 /// Match an arbitrary ConstantExpr and ignore it.
158  return class_match<ConstantExpr>();
159 }
160 
161 /// Match an arbitrary basic block value and ignore it.
163  return class_match<BasicBlock>();
164 }
165 
166 /// Inverting matcher
167 template <typename Ty> struct match_unless {
168  Ty M;
169 
170  match_unless(const Ty &Matcher) : M(Matcher) {}
171 
172  template <typename ITy> bool match(ITy *V) { return !M.match(V); }
173 };
174 
175 /// Match if the inner matcher does *NOT* match.
176 template <typename Ty> inline match_unless<Ty> m_Unless(const Ty &M) {
177  return match_unless<Ty>(M);
178 }
179 
180 /// Matching combinators
181 template <typename LTy, typename RTy> struct match_combine_or {
182  LTy L;
183  RTy R;
184 
185  match_combine_or(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
186 
187  template <typename ITy> bool match(ITy *V) {
188  if (L.match(V))
189  return true;
190  if (R.match(V))
191  return true;
192  return false;
193  }
194 };
195 
196 template <typename LTy, typename RTy> struct match_combine_and {
197  LTy L;
198  RTy R;
199 
200  match_combine_and(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
201 
202  template <typename ITy> bool match(ITy *V) {
203  if (L.match(V))
204  if (R.match(V))
205  return true;
206  return false;
207  }
208 };
209 
210 /// Combine two pattern matchers matching L || R
211 template <typename LTy, typename RTy>
212 inline match_combine_or<LTy, RTy> m_CombineOr(const LTy &L, const RTy &R) {
213  return match_combine_or<LTy, RTy>(L, R);
214 }
215 
216 /// Combine two pattern matchers matching L && R
217 template <typename LTy, typename RTy>
218 inline match_combine_and<LTy, RTy> m_CombineAnd(const LTy &L, const RTy &R) {
219  return match_combine_and<LTy, RTy>(L, R);
220 }
221 
222 struct apint_match {
223  const APInt *&Res;
225 
227  : Res(Res), AllowUndef(AllowUndef) {}
228 
229  template <typename ITy> bool match(ITy *V) {
230  if (auto *CI = dyn_cast<ConstantInt>(V)) {
231  Res = &CI->getValue();
232  return true;
233  }
234  if (V->getType()->isVectorTy())
235  if (const auto *C = dyn_cast<Constant>(V))
236  if (auto *CI =
237  dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowUndef))) {
238  Res = &CI->getValue();
239  return true;
240  }
241  return false;
242  }
243 };
244 // Either constexpr if or renaming ConstantFP::getValueAPF to
245 // ConstantFP::getValue is needed to do it via single template
246 // function for both apint/apfloat.
248  const APFloat *&Res;
250 
252  : Res(Res), AllowUndef(AllowUndef) {}
253 
254  template <typename ITy> bool match(ITy *V) {
255  if (auto *CI = dyn_cast<ConstantFP>(V)) {
256  Res = &CI->getValueAPF();
257  return true;
258  }
259  if (V->getType()->isVectorTy())
260  if (const auto *C = dyn_cast<Constant>(V))
261  if (auto *CI =
262  dyn_cast_or_null<ConstantFP>(C->getSplatValue(AllowUndef))) {
263  Res = &CI->getValueAPF();
264  return true;
265  }
266  return false;
267  }
268 };
269 
270 /// Match a ConstantInt or splatted ConstantVector, binding the
271 /// specified pointer to the contained APInt.
272 inline apint_match m_APInt(const APInt *&Res) {
273  // Forbid undefs by default to maintain previous behavior.
274  return apint_match(Res, /* AllowUndef */ false);
275 }
276 
277 /// Match APInt while allowing undefs in splat vector constants.
278 inline apint_match m_APIntAllowUndef(const APInt *&Res) {
279  return apint_match(Res, /* AllowUndef */ true);
280 }
281 
282 /// Match APInt while forbidding undefs in splat vector constants.
283 inline apint_match m_APIntForbidUndef(const APInt *&Res) {
284  return apint_match(Res, /* AllowUndef */ false);
285 }
286 
287 /// Match a ConstantFP or splatted ConstantVector, binding the
288 /// specified pointer to the contained APFloat.
289 inline apfloat_match m_APFloat(const APFloat *&Res) {
290  // Forbid undefs by default to maintain previous behavior.
291  return apfloat_match(Res, /* AllowUndef */ false);
292 }
293 
294 /// Match APFloat while allowing undefs in splat vector constants.
296  return apfloat_match(Res, /* AllowUndef */ true);
297 }
298 
299 /// Match APFloat while forbidding undefs in splat vector constants.
301  return apfloat_match(Res, /* AllowUndef */ false);
302 }
303 
304 template <int64_t Val> struct constantint_match {
305  template <typename ITy> bool match(ITy *V) {
306  if (const auto *CI = dyn_cast<ConstantInt>(V)) {
307  const APInt &CIV = CI->getValue();
308  if (Val >= 0)
309  return CIV == static_cast<uint64_t>(Val);
310  // If Val is negative, and CI is shorter than it, truncate to the right
311  // number of bits. If it is larger, then we have to sign extend. Just
312  // compare their negated values.
313  return -CIV == -Val;
314  }
315  return false;
316  }
317 };
318 
319 /// Match a ConstantInt with a specific value.
320 template <int64_t Val> inline constantint_match<Val> m_ConstantInt() {
321  return constantint_match<Val>();
322 }
323 
324 /// This helper class is used to match constant scalars, vector splats,
325 /// and fixed width vectors that satisfy a specified predicate.
326 /// For fixed width vector constants, undefined elements are ignored.
327 template <typename Predicate, typename ConstantVal>
328 struct cstval_pred_ty : public Predicate {
329  template <typename ITy> bool match(ITy *V) {
330  if (const auto *CV = dyn_cast<ConstantVal>(V))
331  return this->isValue(CV->getValue());
332  if (const auto *VTy = dyn_cast<VectorType>(V->getType())) {
333  if (const auto *C = dyn_cast<Constant>(V)) {
334  if (const auto *CV = dyn_cast_or_null<ConstantVal>(C->getSplatValue()))
335  return this->isValue(CV->getValue());
336 
337  // Number of elements of a scalable vector unknown at compile time
338  auto *FVTy = dyn_cast<FixedVectorType>(VTy);
339  if (!FVTy)
340  return false;
341 
342  // Non-splat vector constant: check each element for a match.
343  unsigned NumElts = FVTy->getNumElements();
344  assert(NumElts != 0 && "Constant vector with no elements?");
345  bool HasNonUndefElements = false;
346  for (unsigned i = 0; i != NumElts; ++i) {
347  Constant *Elt = C->getAggregateElement(i);
348  if (!Elt)
349  return false;
350  if (isa<UndefValue>(Elt))
351  continue;
352  auto *CV = dyn_cast<ConstantVal>(Elt);
353  if (!CV || !this->isValue(CV->getValue()))
354  return false;
355  HasNonUndefElements = true;
356  }
357  return HasNonUndefElements;
358  }
359  }
360  return false;
361  }
362 };
363 
364 /// specialization of cstval_pred_ty for ConstantInt
365 template <typename Predicate>
367 
368 /// specialization of cstval_pred_ty for ConstantFP
369 template <typename Predicate>
371 
372 /// This helper class is used to match scalar and vector constants that
373 /// satisfy a specified predicate, and bind them to an APInt.
374 template <typename Predicate> struct api_pred_ty : public Predicate {
375  const APInt *&Res;
376 
377  api_pred_ty(const APInt *&R) : Res(R) {}
378 
379  template <typename ITy> bool match(ITy *V) {
380  if (const auto *CI = dyn_cast<ConstantInt>(V))
381  if (this->isValue(CI->getValue())) {
382  Res = &CI->getValue();
383  return true;
384  }
385  if (V->getType()->isVectorTy())
386  if (const auto *C = dyn_cast<Constant>(V))
387  if (auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue()))
388  if (this->isValue(CI->getValue())) {
389  Res = &CI->getValue();
390  return true;
391  }
392 
393  return false;
394  }
395 };
396 
397 /// This helper class is used to match scalar and vector constants that
398 /// satisfy a specified predicate, and bind them to an APFloat.
399 /// Undefs are allowed in splat vector constants.
400 template <typename Predicate> struct apf_pred_ty : public Predicate {
401  const APFloat *&Res;
402 
403  apf_pred_ty(const APFloat *&R) : Res(R) {}
404 
405  template <typename ITy> bool match(ITy *V) {
406  if (const auto *CI = dyn_cast<ConstantFP>(V))
407  if (this->isValue(CI->getValue())) {
408  Res = &CI->getValue();
409  return true;
410  }
411  if (V->getType()->isVectorTy())
412  if (const auto *C = dyn_cast<Constant>(V))
413  if (auto *CI = dyn_cast_or_null<ConstantFP>(
414  C->getSplatValue(/* AllowUndef */ true)))
415  if (this->isValue(CI->getValue())) {
416  Res = &CI->getValue();
417  return true;
418  }
419 
420  return false;
421  }
422 };
423 
424 ///////////////////////////////////////////////////////////////////////////////
425 //
426 // Encapsulate constant value queries for use in templated predicate matchers.
427 // This allows checking if constants match using compound predicates and works
428 // with vector constants, possibly with relaxed constraints. For example, ignore
429 // undef values.
430 //
431 ///////////////////////////////////////////////////////////////////////////////
432 
433 struct is_any_apint {
434  bool isValue(const APInt &C) { return true; }
435 };
436 /// Match an integer or vector with any integral constant.
437 /// For vectors, this includes constants with undefined elements.
439  return cst_pred_ty<is_any_apint>();
440 }
441 
442 struct is_all_ones {
443  bool isValue(const APInt &C) { return C.isAllOnes(); }
444 };
445 /// Match an integer or vector with all bits set.
446 /// For vectors, this includes constants with undefined elements.
448  return cst_pred_ty<is_all_ones>();
449 }
450 
452  bool isValue(const APInt &C) { return C.isMaxSignedValue(); }
453 };
454 /// Match an integer or vector with values having all bits except for the high
455 /// bit set (0x7f...).
456 /// For vectors, this includes constants with undefined elements.
459 }
461  return V;
462 }
463 
464 struct is_negative {
465  bool isValue(const APInt &C) { return C.isNegative(); }
466 };
467 /// Match an integer or vector of negative values.
468 /// For vectors, this includes constants with undefined elements.
470  return cst_pred_ty<is_negative>();
471 }
472 inline api_pred_ty<is_negative> m_Negative(const APInt *&V) { return V; }
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 }
482 inline api_pred_ty<is_nonnegative> m_NonNegative(const APInt *&V) { return V; }
483 
485  bool isValue(const APInt &C) { return C.isStrictlyPositive(); }
486 };
487 /// Match an integer or vector of strictly positive values.
488 /// For vectors, this includes constants with undefined elements.
491 }
493  return V;
494 }
495 
497  bool isValue(const APInt &C) { return C.isNonPositive(); }
498 };
499 /// Match an integer or vector of non-positive values.
500 /// For vectors, this includes constants with undefined elements.
503 }
504 inline api_pred_ty<is_nonpositive> m_NonPositive(const APInt *&V) { return V; }
505 
506 struct is_one {
507  bool isValue(const APInt &C) { return C.isOne(); }
508 };
509 /// Match an integer 1 or a vector with all elements equal to 1.
510 /// For vectors, this includes constants with undefined elements.
512 
513 struct is_zero_int {
514  bool isValue(const APInt &C) { return C.isZero(); }
515 };
516 /// Match an integer 0 or a vector with all elements equal to 0.
517 /// For vectors, this includes constants with undefined elements.
519  return cst_pred_ty<is_zero_int>();
520 }
521 
522 struct is_zero {
523  template <typename ITy> bool match(ITy *V) {
524  auto *C = dyn_cast<Constant>(V);
525  // FIXME: this should be able to do something for scalable vectors
526  return C && (C->isNullValue() || cst_pred_ty<is_zero_int>().match(C));
527  }
528 };
529 /// Match any null constant or a vector with all elements equal to 0.
530 /// For vectors, this includes constants with undefined elements.
531 inline is_zero m_Zero() { return is_zero(); }
532 
533 struct is_power2 {
534  bool isValue(const APInt &C) { return C.isPowerOf2(); }
535 };
536 /// Match an integer or vector power-of-2.
537 /// For vectors, this includes constants with undefined elements.
539 inline api_pred_ty<is_power2> m_Power2(const APInt *&V) { return V; }
540 
542  bool isValue(const APInt &C) { return C.isNegatedPowerOf2(); }
543 };
544 /// Match a integer or vector negated power-of-2.
545 /// For vectors, this includes constants with undefined elements.
548 }
550  return V;
551 }
552 
554  bool isValue(const APInt &C) { return !C || C.isPowerOf2(); }
555 };
556 /// Match an integer or vector of 0 or power-of-2 values.
557 /// For vectors, this includes constants with undefined elements.
560 }
562  return V;
563 }
564 
565 struct is_sign_mask {
566  bool isValue(const APInt &C) { return C.isSignMask(); }
567 };
568 /// Match an integer or vector with only the sign bit(s) set.
569 /// For vectors, this includes constants with undefined elements.
571  return cst_pred_ty<is_sign_mask>();
572 }
573 
575  bool isValue(const APInt &C) { return C.isMask(); }
576 };
577 /// Match an integer or vector with only the low bit(s) set.
578 /// For vectors, this includes constants with undefined elements.
581 }
582 inline api_pred_ty<is_lowbit_mask> m_LowBitMask(const APInt *&V) { return V; }
583 
586  const APInt *Thr;
587  bool isValue(const APInt &C) { return ICmpInst::compare(C, *Thr, Pred); }
588 };
589 /// Match an integer or vector with every element comparing 'pred' (eg/ne/...)
590 /// to Threshold. For vectors, this includes constants with undefined elements.
594  P.Pred = Predicate;
595  P.Thr = &Threshold;
596  return P;
597 }
598 
599 struct is_nan {
600  bool isValue(const APFloat &C) { return C.isNaN(); }
601 };
602 /// Match an arbitrary NaN constant. This includes quiet and signalling nans.
603 /// For vectors, this includes constants with undefined elements.
605 
606 struct is_nonnan {
607  bool isValue(const APFloat &C) { return !C.isNaN(); }
608 };
609 /// Match a non-NaN FP constant.
610 /// For vectors, this includes constants with undefined elements.
612  return cstfp_pred_ty<is_nonnan>();
613 }
614 
615 struct is_inf {
616  bool isValue(const APFloat &C) { return C.isInfinity(); }
617 };
618 /// Match a positive or negative infinity FP constant.
619 /// For vectors, this includes constants with undefined elements.
621 
622 struct is_noninf {
623  bool isValue(const APFloat &C) { return !C.isInfinity(); }
624 };
625 /// Match a non-infinity FP constant, i.e. finite or NaN.
626 /// For vectors, this includes constants with undefined elements.
628  return cstfp_pred_ty<is_noninf>();
629 }
630 
631 struct is_finite {
632  bool isValue(const APFloat &C) { return C.isFinite(); }
633 };
634 /// Match a finite FP constant, i.e. not infinity or NaN.
635 /// For vectors, this includes constants with undefined elements.
637  return cstfp_pred_ty<is_finite>();
638 }
639 inline apf_pred_ty<is_finite> m_Finite(const APFloat *&V) { return V; }
640 
642  bool isValue(const APFloat &C) { return C.isFiniteNonZero(); }
643 };
644 /// Match a finite non-zero FP constant.
645 /// For vectors, this includes constants with undefined elements.
648 }
650  return V;
651 }
652 
654  bool isValue(const APFloat &C) { return C.isZero(); }
655 };
656 /// Match a floating-point negative zero or positive zero.
657 /// For vectors, this includes constants with undefined elements.
660 }
661 
663  bool isValue(const APFloat &C) { return C.isPosZero(); }
664 };
665 /// Match a floating-point positive zero.
666 /// For vectors, this includes constants with undefined elements.
669 }
670 
672  bool isValue(const APFloat &C) { return C.isNegZero(); }
673 };
674 /// Match a floating-point negative zero.
675 /// For vectors, this includes constants with undefined elements.
678 }
679 
681  bool isValue(const APFloat &C) { return C.isNonZero(); }
682 };
683 /// Match a floating-point non-zero.
684 /// For vectors, this includes constants with undefined elements.
687 }
688 
689 ///////////////////////////////////////////////////////////////////////////////
690 
691 template <typename Class> struct bind_ty {
692  Class *&VR;
693 
694  bind_ty(Class *&V) : VR(V) {}
695 
696  template <typename ITy> bool match(ITy *V) {
697  if (auto *CV = dyn_cast<Class>(V)) {
698  VR = CV;
699  return true;
700  }
701  return false;
702  }
703 };
704 
705 /// Match a value, capturing it if we match.
706 inline bind_ty<Value> m_Value(Value *&V) { return V; }
707 inline bind_ty<const Value> m_Value(const Value *&V) { return V; }
708 
709 /// Match an instruction, capturing it if we match.
711 /// Match a unary operator, capturing it if we match.
713 /// Match a binary operator, capturing it if we match.
715 /// Match a with overflow intrinsic, capturing it if we match.
717  return I;
718 }
721  return I;
722 }
723 
724 /// Match a Constant, capturing the value if we match.
725 inline bind_ty<Constant> m_Constant(Constant *&C) { return C; }
726 
727 /// Match a ConstantInt, capturing the value if we match.
728 inline bind_ty<ConstantInt> m_ConstantInt(ConstantInt *&CI) { return CI; }
729 
730 /// Match a ConstantFP, capturing the value if we match.
732 
733 /// Match a ConstantExpr, capturing the value if we match.
735 
736 /// Match a basic block value, capturing it if we match.
737 inline bind_ty<BasicBlock> m_BasicBlock(BasicBlock *&V) { return V; }
739  return V;
740 }
741 
742 /// Match an arbitrary immediate Constant and ignore it.
747 }
748 
749 /// Match an immediate Constant, capturing the value if we match.
754 }
755 
756 /// Match a specified Value*.
758  const Value *Val;
759 
760  specificval_ty(const Value *V) : Val(V) {}
761 
762  template <typename ITy> bool match(ITy *V) { return V == Val; }
763 };
764 
765 /// Match if we have a specific specified value.
766 inline specificval_ty m_Specific(const Value *V) { return V; }
767 
768 /// Stores a reference to the Value *, not the Value * itself,
769 /// thus can be used in commutative matchers.
770 template <typename Class> struct deferredval_ty {
771  Class *const &Val;
772 
773  deferredval_ty(Class *const &V) : Val(V) {}
774 
775  template <typename ITy> bool match(ITy *const V) { return V == Val; }
776 };
777 
778 /// Like m_Specific(), but works if the specific value to match is determined
779 /// as part of the same match() expression. For example:
780 /// m_Add(m_Value(X), m_Specific(X)) is incorrect, because m_Specific() will
781 /// bind X before the pattern match starts.
782 /// m_Add(m_Value(X), m_Deferred(X)) is correct, and will check against
783 /// whichever value m_Value(X) populated.
784 inline deferredval_ty<Value> m_Deferred(Value *const &V) { return V; }
786  return V;
787 }
788 
789 /// Match a specified floating point value or vector of all elements of
790 /// that value.
792  double Val;
793 
794  specific_fpval(double V) : Val(V) {}
795 
796  template <typename ITy> bool match(ITy *V) {
797  if (const auto *CFP = dyn_cast<ConstantFP>(V))
798  return CFP->isExactlyValue(Val);
799  if (V->getType()->isVectorTy())
800  if (const auto *C = dyn_cast<Constant>(V))
801  if (auto *CFP = dyn_cast_or_null<ConstantFP>(C->getSplatValue()))
802  return CFP->isExactlyValue(Val);
803  return false;
804  }
805 };
806 
807 /// Match a specific floating point value or vector with all elements
808 /// equal to the value.
809 inline specific_fpval m_SpecificFP(double V) { return specific_fpval(V); }
810 
811 /// Match a float 1.0 or vector with all elements equal to 1.0.
812 inline specific_fpval m_FPOne() { return m_SpecificFP(1.0); }
813 
816 
818 
819  template <typename ITy> bool match(ITy *V) {
820  if (const auto *CV = dyn_cast<ConstantInt>(V))
821  if (CV->getValue().ule(UINT64_MAX)) {
822  VR = CV->getZExtValue();
823  return true;
824  }
825  return false;
826  }
827 };
828 
829 /// Match a specified integer value or vector of all elements of that
830 /// value.
831 template <bool AllowUndefs> struct specific_intval {
833 
835 
836  template <typename ITy> bool match(ITy *V) {
837  const auto *CI = dyn_cast<ConstantInt>(V);
838  if (!CI && V->getType()->isVectorTy())
839  if (const auto *C = dyn_cast<Constant>(V))
840  CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowUndefs));
841 
842  return CI && APInt::isSameValue(CI->getValue(), Val);
843  }
844 };
845 
846 /// Match a specific integer value or vector with all elements equal to
847 /// the value.
850 }
851 
853  return m_SpecificInt(APInt(64, V));
854 }
855 
857  return specific_intval<true>(std::move(V));
858 }
859 
861  return m_SpecificIntAllowUndef(APInt(64, V));
862 }
863 
864 /// Match a ConstantInt and bind to its value. This does not match
865 /// ConstantInts wider than 64-bits.
867 
868 /// Match a specified basic block value.
871 
873 
874  template <typename ITy> bool match(ITy *V) {
875  const auto *BB = dyn_cast<BasicBlock>(V);
876  return BB && BB == Val;
877  }
878 };
879 
880 /// Match a specific basic block value.
882  return specific_bbval(BB);
883 }
884 
885 /// A commutative-friendly version of m_Specific().
887  return BB;
888 }
890 m_Deferred(const BasicBlock *const &BB) {
891  return BB;
892 }
893 
894 //===----------------------------------------------------------------------===//
895 // Matcher for any binary operator.
896 //
897 template <typename LHS_t, typename RHS_t, bool Commutable = false>
901 
902  // The evaluation order is always stable, regardless of Commutability.
903  // The LHS is always matched first.
904  AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
905 
906  template <typename OpTy> bool match(OpTy *V) {
907  if (auto *I = dyn_cast<BinaryOperator>(V))
908  return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
909  (Commutable && L.match(I->getOperand(1)) &&
910  R.match(I->getOperand(0)));
911  return false;
912  }
913 };
914 
915 template <typename LHS, typename RHS>
916 inline AnyBinaryOp_match<LHS, RHS> m_BinOp(const LHS &L, const RHS &R) {
917  return AnyBinaryOp_match<LHS, RHS>(L, R);
918 }
919 
920 //===----------------------------------------------------------------------===//
921 // Matcher for any unary operator.
922 // TODO fuse unary, binary matcher into n-ary matcher
923 //
924 template <typename OP_t> struct AnyUnaryOp_match {
925  OP_t X;
926 
927  AnyUnaryOp_match(const OP_t &X) : X(X) {}
928 
929  template <typename OpTy> bool match(OpTy *V) {
930  if (auto *I = dyn_cast<UnaryOperator>(V))
931  return X.match(I->getOperand(0));
932  return false;
933  }
934 };
935 
936 template <typename OP_t> inline AnyUnaryOp_match<OP_t> m_UnOp(const OP_t &X) {
937  return AnyUnaryOp_match<OP_t>(X);
938 }
939 
940 //===----------------------------------------------------------------------===//
941 // Matchers for specific binary operators.
942 //
943 
944 template <typename LHS_t, typename RHS_t, unsigned Opcode,
945  bool Commutable = false>
949 
950  // The evaluation order is always stable, regardless of Commutability.
951  // The LHS is always matched first.
952  BinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
953 
954  template <typename OpTy> inline bool match(unsigned Opc, OpTy *V) {
955  if (V->getValueID() == Value::InstructionVal + Opc) {
956  auto *I = cast<BinaryOperator>(V);
957  return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
958  (Commutable && L.match(I->getOperand(1)) &&
959  R.match(I->getOperand(0)));
960  }
961  if (auto *CE = dyn_cast<ConstantExpr>(V))
962  return CE->getOpcode() == Opc &&
963  ((L.match(CE->getOperand(0)) && R.match(CE->getOperand(1))) ||
964  (Commutable && L.match(CE->getOperand(1)) &&
965  R.match(CE->getOperand(0))));
966  return false;
967  }
968 
969  template <typename OpTy> bool match(OpTy *V) { return match(Opcode, V); }
970 };
971 
972 template <typename LHS, typename RHS>
974  const RHS &R) {
976 }
977 
978 template <typename LHS, typename RHS>
980  const RHS &R) {
982 }
983 
984 template <typename LHS, typename RHS>
986  const RHS &R) {
988 }
989 
990 template <typename LHS, typename RHS>
992  const RHS &R) {
994 }
995 
996 template <typename Op_t> struct FNeg_match {
997  Op_t X;
998 
999  FNeg_match(const Op_t &Op) : X(Op) {}
1000  template <typename OpTy> bool match(OpTy *V) {
1001  auto *FPMO = dyn_cast<FPMathOperator>(V);
1002  if (!FPMO)
1003  return false;
1004 
1005  if (FPMO->getOpcode() == Instruction::FNeg)
1006  return X.match(FPMO->getOperand(0));
1007 
1008  if (FPMO->getOpcode() == Instruction::FSub) {
1009  if (FPMO->hasNoSignedZeros()) {
1010  // With 'nsz', any zero goes.
1011  if (!cstfp_pred_ty<is_any_zero_fp>().match(FPMO->getOperand(0)))
1012  return false;
1013  } else {
1014  // Without 'nsz', we need fsub -0.0, X exactly.
1015  if (!cstfp_pred_ty<is_neg_zero_fp>().match(FPMO->getOperand(0)))
1016  return false;
1017  }
1018 
1019  return X.match(FPMO->getOperand(1));
1020  }
1021 
1022  return false;
1023  }
1024 };
1025 
1026 /// Match 'fneg X' as 'fsub -0.0, X'.
1027 template <typename OpTy> inline FNeg_match<OpTy> m_FNeg(const OpTy &X) {
1028  return FNeg_match<OpTy>(X);
1029 }
1030 
1031 /// Match 'fneg X' as 'fsub +-0.0, X'.
1032 template <typename RHS>
1033 inline BinaryOp_match<cstfp_pred_ty<is_any_zero_fp>, RHS, Instruction::FSub>
1034 m_FNegNSZ(const RHS &X) {
1035  return m_FSub(m_AnyZeroFP(), X);
1036 }
1037 
1038 template <typename LHS, typename RHS>
1040  const RHS &R) {
1042 }
1043 
1044 template <typename LHS, typename RHS>
1046  const RHS &R) {
1048 }
1049 
1050 template <typename LHS, typename RHS>
1052  const RHS &R) {
1054 }
1055 
1056 template <typename LHS, typename RHS>
1058  const RHS &R) {
1060 }
1061 
1062 template <typename LHS, typename RHS>
1064  const RHS &R) {
1066 }
1067 
1068 template <typename LHS, typename RHS>
1070  const RHS &R) {
1072 }
1073 
1074 template <typename LHS, typename RHS>
1076  const RHS &R) {
1078 }
1079 
1080 template <typename LHS, typename RHS>
1082  const RHS &R) {
1084 }
1085 
1086 template <typename LHS, typename RHS>
1088  const RHS &R) {
1090 }
1091 
1092 template <typename LHS, typename RHS>
1094  const RHS &R) {
1096 }
1097 
1098 template <typename LHS, typename RHS>
1100  const RHS &R) {
1102 }
1103 
1104 template <typename LHS, typename RHS>
1106  const RHS &R) {
1108 }
1109 
1110 template <typename LHS, typename RHS>
1112  const RHS &R) {
1114 }
1115 
1116 template <typename LHS, typename RHS>
1118  const RHS &R) {
1120 }
1121 
1122 template <typename LHS_t, typename RHS_t, unsigned Opcode,
1123  unsigned WrapFlags = 0>
1127 
1129  : L(LHS), R(RHS) {}
1130 
1131  template <typename OpTy> bool match(OpTy *V) {
1132  if (auto *Op = dyn_cast<OverflowingBinaryOperator>(V)) {
1133  if (Op->getOpcode() != Opcode)
1134  return false;
1135  if ((WrapFlags & OverflowingBinaryOperator::NoUnsignedWrap) &&
1136  !Op->hasNoUnsignedWrap())
1137  return false;
1138  if ((WrapFlags & OverflowingBinaryOperator::NoSignedWrap) &&
1139  !Op->hasNoSignedWrap())
1140  return false;
1141  return L.match(Op->getOperand(0)) && R.match(Op->getOperand(1));
1142  }
1143  return false;
1144  }
1145 };
1146 
1147 template <typename LHS, typename RHS>
1150 m_NSWAdd(const LHS &L, const RHS &R) {
1153  R);
1154 }
1155 template <typename LHS, typename RHS>
1156 inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1158 m_NSWSub(const LHS &L, const RHS &R) {
1159  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1161  R);
1162 }
1163 template <typename LHS, typename RHS>
1166 m_NSWMul(const LHS &L, const RHS &R) {
1169  R);
1170 }
1171 template <typename LHS, typename RHS>
1172 inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1174 m_NSWShl(const LHS &L, const RHS &R) {
1175  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1177  R);
1178 }
1179 
1180 template <typename LHS, typename RHS>
1183 m_NUWAdd(const LHS &L, const RHS &R) {
1186  L, R);
1187 }
1188 template <typename LHS, typename RHS>
1189 inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1191 m_NUWSub(const LHS &L, const RHS &R) {
1192  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1194  L, R);
1195 }
1196 template <typename LHS, typename RHS>
1199 m_NUWMul(const LHS &L, const RHS &R) {
1202  L, R);
1203 }
1204 template <typename LHS, typename RHS>
1205 inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1207 m_NUWShl(const LHS &L, const RHS &R) {
1208  return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1210  L, R);
1211 }
1212 
1213 template <typename LHS_t, typename RHS_t, bool Commutable = false>
1215  : public BinaryOp_match<LHS_t, RHS_t, 0, Commutable> {
1216  unsigned Opcode;
1217 
1218  SpecificBinaryOp_match(unsigned Opcode, const LHS_t &LHS, const RHS_t &RHS)
1220 
1221  template <typename OpTy> bool match(OpTy *V) {
1223  }
1224 };
1225 
1226 /// Matches a specific opcode.
1227 template <typename LHS, typename RHS>
1228 inline SpecificBinaryOp_match<LHS, RHS> m_BinOp(unsigned Opcode, const LHS &L,
1229  const RHS &R) {
1230  return SpecificBinaryOp_match<LHS, RHS>(Opcode, L, R);
1231 }
1232 
1233 //===----------------------------------------------------------------------===//
1234 // Class that matches a group of binary opcodes.
1235 //
1236 template <typename LHS_t, typename RHS_t, typename Predicate>
1240 
1241  BinOpPred_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1242 
1243  template <typename OpTy> bool match(OpTy *V) {
1244  if (auto *I = dyn_cast<Instruction>(V))
1245  return this->isOpType(I->getOpcode()) && L.match(I->getOperand(0)) &&
1246  R.match(I->getOperand(1));
1247  if (auto *CE = dyn_cast<ConstantExpr>(V))
1248  return this->isOpType(CE->getOpcode()) && L.match(CE->getOperand(0)) &&
1249  R.match(CE->getOperand(1));
1250  return false;
1251  }
1252 };
1253 
1254 struct is_shift_op {
1255  bool isOpType(unsigned Opcode) { return Instruction::isShift(Opcode); }
1256 };
1257 
1259  bool isOpType(unsigned Opcode) {
1260  return Opcode == Instruction::LShr || Opcode == Instruction::AShr;
1261  }
1262 };
1263 
1265  bool isOpType(unsigned Opcode) {
1266  return Opcode == Instruction::LShr || Opcode == Instruction::Shl;
1267  }
1268 };
1269 
1271  bool isOpType(unsigned Opcode) {
1272  return Instruction::isBitwiseLogicOp(Opcode);
1273  }
1274 };
1275 
1276 struct is_idiv_op {
1277  bool isOpType(unsigned Opcode) {
1278  return Opcode == Instruction::SDiv || Opcode == Instruction::UDiv;
1279  }
1280 };
1281 
1282 struct is_irem_op {
1283  bool isOpType(unsigned Opcode) {
1284  return Opcode == Instruction::SRem || Opcode == Instruction::URem;
1285  }
1286 };
1287 
1288 /// Matches shift operations.
1289 template <typename LHS, typename RHS>
1291  const RHS &R) {
1293 }
1294 
1295 /// Matches logical shift operations.
1296 template <typename LHS, typename RHS>
1298  const RHS &R) {
1300 }
1301 
1302 /// Matches logical shift operations.
1303 template <typename LHS, typename RHS>
1305 m_LogicalShift(const LHS &L, const RHS &R) {
1307 }
1308 
1309 /// Matches bitwise logic operations.
1310 template <typename LHS, typename RHS>
1312 m_BitwiseLogic(const LHS &L, const RHS &R) {
1314 }
1315 
1316 /// Matches integer division operations.
1317 template <typename LHS, typename RHS>
1319  const RHS &R) {
1321 }
1322 
1323 /// Matches integer remainder operations.
1324 template <typename LHS, typename RHS>
1326  const RHS &R) {
1328 }
1329 
1330 //===----------------------------------------------------------------------===//
1331 // Class that matches exact binary ops.
1332 //
1333 template <typename SubPattern_t> struct Exact_match {
1334  SubPattern_t SubPattern;
1335 
1336  Exact_match(const SubPattern_t &SP) : SubPattern(SP) {}
1337 
1338  template <typename OpTy> bool match(OpTy *V) {
1339  if (auto *PEO = dyn_cast<PossiblyExactOperator>(V))
1340  return PEO->isExact() && SubPattern.match(V);
1341  return false;
1342  }
1343 };
1344 
1345 template <typename T> inline Exact_match<T> m_Exact(const T &SubPattern) {
1346  return SubPattern;
1347 }
1348 
1349 //===----------------------------------------------------------------------===//
1350 // Matchers for CmpInst classes
1351 //
1352 
1353 template <typename LHS_t, typename RHS_t, typename Class, typename PredicateTy,
1354  bool Commutable = false>
1356  PredicateTy &Predicate;
1359 
1360  // The evaluation order is always stable, regardless of Commutability.
1361  // The LHS is always matched first.
1362  CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
1363  : Predicate(Pred), L(LHS), R(RHS) {}
1364 
1365  template <typename OpTy> bool match(OpTy *V) {
1366  if (auto *I = dyn_cast<Class>(V)) {
1367  if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
1368  Predicate = I->getPredicate();
1369  return true;
1370  } else if (Commutable && L.match(I->getOperand(1)) &&
1371  R.match(I->getOperand(0))) {
1372  Predicate = I->getSwappedPredicate();
1373  return true;
1374  }
1375  }
1376  return false;
1377  }
1378 };
1379 
1380 template <typename LHS, typename RHS>
1382 m_Cmp(CmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1384 }
1385 
1386 template <typename LHS, typename RHS>
1388 m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1390 }
1391 
1392 template <typename LHS, typename RHS>
1394 m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1396 }
1397 
1398 //===----------------------------------------------------------------------===//
1399 // Matchers for instructions with a given opcode and number of operands.
1400 //
1401 
1402 /// Matches instructions with Opcode and three operands.
1403 template <typename T0, unsigned Opcode> struct OneOps_match {
1404  T0 Op1;
1405 
1406  OneOps_match(const T0 &Op1) : Op1(Op1) {}
1407 
1408  template <typename OpTy> bool match(OpTy *V) {
1409  if (V->getValueID() == Value::InstructionVal + Opcode) {
1410  auto *I = cast<Instruction>(V);
1411  return Op1.match(I->getOperand(0));
1412  }
1413  return false;
1414  }
1415 };
1416 
1417 /// Matches instructions with Opcode and three operands.
1418 template <typename T0, typename T1, unsigned Opcode> struct TwoOps_match {
1419  T0 Op1;
1421 
1422  TwoOps_match(const T0 &Op1, const T1 &Op2) : Op1(Op1), Op2(Op2) {}
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)) && Op2.match(I->getOperand(1));
1428  }
1429  return false;
1430  }
1431 };
1432 
1433 /// Matches instructions with Opcode and three operands.
1434 template <typename T0, typename T1, typename T2, unsigned Opcode>
1436  T0 Op1;
1438  T2 Op3;
1439 
1440  ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
1441  : Op1(Op1), Op2(Op2), Op3(Op3) {}
1442 
1443  template <typename OpTy> bool match(OpTy *V) {
1444  if (V->getValueID() == Value::InstructionVal + Opcode) {
1445  auto *I = cast<Instruction>(V);
1446  return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1447  Op3.match(I->getOperand(2));
1448  }
1449  return false;
1450  }
1451 };
1452 
1453 /// Matches SelectInst.
1454 template <typename Cond, typename LHS, typename RHS>
1456 m_Select(const Cond &C, const LHS &L, const RHS &R) {
1458 }
1459 
1460 /// This matches a select of two constants, e.g.:
1461 /// m_SelectCst<-1, 0>(m_Value(V))
1462 template <int64_t L, int64_t R, typename Cond>
1465 m_SelectCst(const Cond &C) {
1466  return m_Select(C, m_ConstantInt<L>(), m_ConstantInt<R>());
1467 }
1468 
1469 /// Matches FreezeInst.
1470 template <typename OpTy>
1473 }
1474 
1475 /// Matches InsertElementInst.
1476 template <typename Val_t, typename Elt_t, typename Idx_t>
1478 m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx) {
1480  Val, Elt, Idx);
1481 }
1482 
1483 /// Matches ExtractElementInst.
1484 template <typename Val_t, typename Idx_t>
1486 m_ExtractElt(const Val_t &Val, const Idx_t &Idx) {
1488 }
1489 
1490 /// Matches shuffle.
1491 template <typename T0, typename T1, typename T2> struct Shuffle_match {
1492  T0 Op1;
1494  T2 Mask;
1495 
1496  Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
1497  : Op1(Op1), Op2(Op2), Mask(Mask) {}
1498 
1499  template <typename OpTy> bool match(OpTy *V) {
1500  if (auto *I = dyn_cast<ShuffleVectorInst>(V)) {
1501  return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1502  Mask.match(I->getShuffleMask());
1503  }
1504  return false;
1505  }
1506 };
1507 
1508 struct m_Mask {
1512  MaskRef = Mask;
1513  return true;
1514  }
1515 };
1516 
1517 struct m_ZeroMask {
1519  return all_of(Mask, [](int Elem) { return Elem == 0 || Elem == -1; });
1520  }
1521 };
1522 
1526  bool match(ArrayRef<int> Mask) { return MaskRef == Mask; }
1527 };
1528 
1533  auto First = find_if(Mask, [](int Elem) { return Elem != -1; });
1534  if (First == Mask.end())
1535  return false;
1536  SplatIndex = *First;
1537  return all_of(Mask,
1538  [First](int Elem) { return Elem == *First || Elem == -1; });
1539  }
1540 };
1541 
1542 /// Matches ShuffleVectorInst independently of mask value.
1543 template <typename V1_t, typename V2_t>
1545 m_Shuffle(const V1_t &v1, const V2_t &v2) {
1547 }
1548 
1549 template <typename V1_t, typename V2_t, typename Mask_t>
1551 m_Shuffle(const V1_t &v1, const V2_t &v2, const Mask_t &mask) {
1552  return Shuffle_match<V1_t, V2_t, Mask_t>(v1, v2, mask);
1553 }
1554 
1555 /// Matches LoadInst.
1556 template <typename OpTy>
1559 }
1560 
1561 /// Matches StoreInst.
1562 template <typename ValueOpTy, typename PointerOpTy>
1564 m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp) {
1566  PointerOp);
1567 }
1568 
1569 //===----------------------------------------------------------------------===//
1570 // Matchers for CastInst classes
1571 //
1572 
1573 template <typename Op_t, unsigned Opcode> struct CastClass_match {
1574  Op_t Op;
1575 
1576  CastClass_match(const Op_t &OpMatch) : Op(OpMatch) {}
1577 
1578  template <typename OpTy> bool match(OpTy *V) {
1579  if (auto *O = dyn_cast<Operator>(V))
1580  return O->getOpcode() == Opcode && Op.match(O->getOperand(0));
1581  return false;
1582  }
1583 };
1584 
1585 /// Matches BitCast.
1586 template <typename OpTy>
1589 }
1590 
1591 /// Matches PtrToInt.
1592 template <typename OpTy>
1595 }
1596 
1597 /// Matches IntToPtr.
1598 template <typename OpTy>
1601 }
1602 
1603 /// Matches Trunc.
1604 template <typename OpTy>
1607 }
1608 
1609 template <typename OpTy>
1611 m_TruncOrSelf(const OpTy &Op) {
1612  return m_CombineOr(m_Trunc(Op), Op);
1613 }
1614 
1615 /// Matches SExt.
1616 template <typename OpTy>
1619 }
1620 
1621 /// Matches ZExt.
1622 template <typename OpTy>
1625 }
1626 
1627 template <typename OpTy>
1629 m_ZExtOrSelf(const OpTy &Op) {
1630  return m_CombineOr(m_ZExt(Op), Op);
1631 }
1632 
1633 template <typename OpTy>
1635 m_SExtOrSelf(const OpTy &Op) {
1636  return m_CombineOr(m_SExt(Op), Op);
1637 }
1638 
1639 template <typename OpTy>
1642 m_ZExtOrSExt(const OpTy &Op) {
1643  return m_CombineOr(m_ZExt(Op), m_SExt(Op));
1644 }
1645 
1646 template <typename OpTy>
1647 inline match_combine_or<
1650  OpTy>
1651 m_ZExtOrSExtOrSelf(const OpTy &Op) {
1652  return m_CombineOr(m_ZExtOrSExt(Op), Op);
1653 }
1654 
1655 template <typename OpTy>
1658 }
1659 
1660 template <typename OpTy>
1663 }
1664 
1665 template <typename OpTy>
1668 }
1669 
1670 template <typename OpTy>
1673 }
1674 
1675 template <typename OpTy>
1678 }
1679 
1680 template <typename OpTy>
1683 }
1684 
1685 //===----------------------------------------------------------------------===//
1686 // Matchers for control flow.
1687 //
1688 
1689 struct br_match {
1691 
1693 
1694  template <typename OpTy> bool match(OpTy *V) {
1695  if (auto *BI = dyn_cast<BranchInst>(V))
1696  if (BI->isUnconditional()) {
1697  Succ = BI->getSuccessor(0);
1698  return true;
1699  }
1700  return false;
1701  }
1702 };
1703 
1704 inline br_match m_UnconditionalBr(BasicBlock *&Succ) { return br_match(Succ); }
1705 
1706 template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1707 struct brc_match {
1708  Cond_t Cond;
1709  TrueBlock_t T;
1710  FalseBlock_t F;
1711 
1712  brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
1713  : Cond(C), T(t), F(f) {}
1714 
1715  template <typename OpTy> bool match(OpTy *V) {
1716  if (auto *BI = dyn_cast<BranchInst>(V))
1717  if (BI->isConditional() && Cond.match(BI->getCondition()))
1718  return T.match(BI->getSuccessor(0)) && F.match(BI->getSuccessor(1));
1719  return false;
1720  }
1721 };
1722 
1723 template <typename Cond_t>
1725 m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F) {
1727  C, m_BasicBlock(T), m_BasicBlock(F));
1728 }
1729 
1730 template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1732 m_Br(const Cond_t &C, const TrueBlock_t &T, const FalseBlock_t &F) {
1734 }
1735 
1736 //===----------------------------------------------------------------------===//
1737 // Matchers for max/min idioms, eg: "select (sgt x, y), x, y" -> smax(x,y).
1738 //
1739 
1740 template <typename CmpInst_t, typename LHS_t, typename RHS_t, typename Pred_t,
1741  bool Commutable = false>
1743  using PredType = Pred_t;
1746 
1747  // The evaluation order is always stable, regardless of Commutability.
1748  // The LHS is always matched first.
1749  MaxMin_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1750 
1751  template <typename OpTy> bool match(OpTy *V) {
1752  if (auto *II = dyn_cast<IntrinsicInst>(V)) {
1753  Intrinsic::ID IID = II->getIntrinsicID();
1758  Value *LHS = II->getOperand(0), *RHS = II->getOperand(1);
1759  return (L.match(LHS) && R.match(RHS)) ||
1760  (Commutable && L.match(RHS) && R.match(LHS));
1761  }
1762  }
1763  // Look for "(x pred y) ? x : y" or "(x pred y) ? y : x".
1764  auto *SI = dyn_cast<SelectInst>(V);
1765  if (!SI)
1766  return false;
1767  auto *Cmp = dyn_cast<CmpInst_t>(SI->getCondition());
1768  if (!Cmp)
1769  return false;
1770  // At this point we have a select conditioned on a comparison. Check that
1771  // it is the values returned by the select that are being compared.
1772  auto *TrueVal = SI->getTrueValue();
1773  auto *FalseVal = SI->getFalseValue();
1774  auto *LHS = Cmp->getOperand(0);
1775  auto *RHS = Cmp->getOperand(1);
1776  if ((TrueVal != LHS || FalseVal != RHS) &&
1777  (TrueVal != RHS || FalseVal != LHS))
1778  return false;
1779  typename CmpInst_t::Predicate Pred =
1780  LHS == TrueVal ? Cmp->getPredicate() : Cmp->getInversePredicate();
1781  // Does "(x pred y) ? x : y" represent the desired max/min operation?
1782  if (!Pred_t::match(Pred))
1783  return false;
1784  // It does! Bind the operands.
1785  return (L.match(LHS) && R.match(RHS)) ||
1786  (Commutable && L.match(RHS) && R.match(LHS));
1787  }
1788 };
1789 
1790 /// Helper class for identifying signed max predicates.
1792  static bool match(ICmpInst::Predicate Pred) {
1793  return Pred == CmpInst::ICMP_SGT || Pred == CmpInst::ICMP_SGE;
1794  }
1795 };
1796 
1797 /// Helper class for identifying signed min predicates.
1799  static bool match(ICmpInst::Predicate Pred) {
1800  return Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_SLE;
1801  }
1802 };
1803 
1804 /// Helper class for identifying unsigned max predicates.
1806  static bool match(ICmpInst::Predicate Pred) {
1807  return Pred == CmpInst::ICMP_UGT || Pred == CmpInst::ICMP_UGE;
1808  }
1809 };
1810 
1811 /// Helper class for identifying unsigned min predicates.
1813  static bool match(ICmpInst::Predicate Pred) {
1814  return Pred == CmpInst::ICMP_ULT || Pred == CmpInst::ICMP_ULE;
1815  }
1816 };
1817 
1818 /// Helper class for identifying ordered max predicates.
1820  static bool match(FCmpInst::Predicate Pred) {
1821  return Pred == CmpInst::FCMP_OGT || Pred == CmpInst::FCMP_OGE;
1822  }
1823 };
1824 
1825 /// Helper class for identifying ordered min predicates.
1827  static bool match(FCmpInst::Predicate Pred) {
1828  return Pred == CmpInst::FCMP_OLT || Pred == CmpInst::FCMP_OLE;
1829  }
1830 };
1831 
1832 /// Helper class for identifying unordered max predicates.
1834  static bool match(FCmpInst::Predicate Pred) {
1835  return Pred == CmpInst::FCMP_UGT || Pred == CmpInst::FCMP_UGE;
1836  }
1837 };
1838 
1839 /// Helper class for identifying unordered min predicates.
1841  static bool match(FCmpInst::Predicate Pred) {
1842  return Pred == CmpInst::FCMP_ULT || Pred == CmpInst::FCMP_ULE;
1843  }
1844 };
1845 
1846 template <typename LHS, typename RHS>
1848  const RHS &R) {
1850 }
1851 
1852 template <typename LHS, typename RHS>
1854  const RHS &R) {
1856 }
1857 
1858 template <typename LHS, typename RHS>
1860  const RHS &R) {
1862 }
1863 
1864 template <typename LHS, typename RHS>
1866  const RHS &R) {
1868 }
1869 
1870 template <typename LHS, typename RHS>
1871 inline match_combine_or<
1876 m_MaxOrMin(const LHS &L, const RHS &R) {
1877  return m_CombineOr(m_CombineOr(m_SMax(L, R), m_SMin(L, R)),
1878  m_CombineOr(m_UMax(L, R), m_UMin(L, R)));
1879 }
1880 
1881 /// Match an 'ordered' floating point maximum function.
1882 /// Floating point has one special value 'NaN'. Therefore, there is no total
1883 /// order. However, if we can ignore the 'NaN' value (for example, because of a
1884 /// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1885 /// semantics. In the presence of 'NaN' we have to preserve the original
1886 /// select(fcmp(ogt/ge, L, R), L, R) semantics matched by this predicate.
1887 ///
1888 /// max(L, R) iff L and R are not NaN
1889 /// m_OrdFMax(L, R) = R iff L or R are NaN
1890 template <typename LHS, typename RHS>
1892  const RHS &R) {
1894 }
1895 
1896 /// Match an 'ordered' floating point minimum function.
1897 /// Floating point has one special value 'NaN'. Therefore, there is no total
1898 /// order. However, if we can ignore the 'NaN' value (for example, because of a
1899 /// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1900 /// semantics. In the presence of 'NaN' we have to preserve the original
1901 /// select(fcmp(olt/le, L, R), L, R) semantics matched by this predicate.
1902 ///
1903 /// min(L, R) iff L and R are not NaN
1904 /// m_OrdFMin(L, R) = R iff L or R are NaN
1905 template <typename LHS, typename RHS>
1907  const RHS &R) {
1909 }
1910 
1911 /// Match an 'unordered' floating point maximum function.
1912 /// Floating point has one special value 'NaN'. Therefore, there is no total
1913 /// order. However, if we can ignore the 'NaN' value (for example, because of a
1914 /// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1915 /// semantics. In the presence of 'NaN' we have to preserve the original
1916 /// select(fcmp(ugt/ge, L, R), L, R) semantics matched by this predicate.
1917 ///
1918 /// max(L, R) iff L and R are not NaN
1919 /// m_UnordFMax(L, R) = L iff L or R are NaN
1920 template <typename LHS, typename RHS>
1922 m_UnordFMax(const LHS &L, const RHS &R) {
1924 }
1925 
1926 /// Match an 'unordered' floating point minimum function.
1927 /// Floating point has one special value 'NaN'. Therefore, there is no total
1928 /// order. However, if we can ignore the 'NaN' value (for example, because of a
1929 /// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1930 /// semantics. In the presence of 'NaN' we have to preserve the original
1931 /// select(fcmp(ult/le, L, R), L, R) semantics matched by this predicate.
1932 ///
1933 /// min(L, R) iff L and R are not NaN
1934 /// m_UnordFMin(L, R) = L iff L or R are NaN
1935 template <typename LHS, typename RHS>
1937 m_UnordFMin(const LHS &L, const RHS &R) {
1939 }
1940 
1941 //===----------------------------------------------------------------------===//
1942 // Matchers for overflow check patterns: e.g. (a + b) u< a, (a ^ -1) <u b
1943 // Note that S might be matched to other instructions than AddInst.
1944 //
1945 
1946 template <typename LHS_t, typename RHS_t, typename Sum_t>
1950  Sum_t S;
1951 
1952  UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
1953  : L(L), R(R), S(S) {}
1954 
1955  template <typename OpTy> bool match(OpTy *V) {
1956  Value *ICmpLHS, *ICmpRHS;
1957  ICmpInst::Predicate Pred;
1958  if (!m_ICmp(Pred, m_Value(ICmpLHS), m_Value(ICmpRHS)).match(V))
1959  return false;
1960 
1961  Value *AddLHS, *AddRHS;
1962  auto AddExpr = m_Add(m_Value(AddLHS), m_Value(AddRHS));
1963 
1964  // (a + b) u< a, (a + b) u< b
1965  if (Pred == ICmpInst::ICMP_ULT)
1966  if (AddExpr.match(ICmpLHS) && (ICmpRHS == AddLHS || ICmpRHS == AddRHS))
1967  return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
1968 
1969  // a >u (a + b), b >u (a + b)
1970  if (Pred == ICmpInst::ICMP_UGT)
1971  if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
1972  return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
1973 
1974  Value *Op1;
1975  auto XorExpr = m_OneUse(m_Xor(m_Value(Op1), m_AllOnes()));
1976  // (a ^ -1) <u b
1977  if (Pred == ICmpInst::ICMP_ULT) {
1978  if (XorExpr.match(ICmpLHS))
1979  return L.match(Op1) && R.match(ICmpRHS) && S.match(ICmpLHS);
1980  }
1981  // b > u (a ^ -1)
1982  if (Pred == ICmpInst::ICMP_UGT) {
1983  if (XorExpr.match(ICmpRHS))
1984  return L.match(Op1) && R.match(ICmpLHS) && S.match(ICmpRHS);
1985  }
1986 
1987  // Match special-case for increment-by-1.
1988  if (Pred == ICmpInst::ICMP_EQ) {
1989  // (a + 1) == 0
1990  // (1 + a) == 0
1991  if (AddExpr.match(ICmpLHS) && m_ZeroInt().match(ICmpRHS) &&
1992  (m_One().match(AddLHS) || m_One().match(AddRHS)))
1993  return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
1994  // 0 == (a + 1)
1995  // 0 == (1 + a)
1996  if (m_ZeroInt().match(ICmpLHS) && AddExpr.match(ICmpRHS) &&
1997  (m_One().match(AddLHS) || m_One().match(AddRHS)))
1998  return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
1999  }
2000 
2001  return false;
2002  }
2003 };
2004 
2005 /// Match an icmp instruction checking for unsigned overflow on addition.
2006 ///
2007 /// S is matched to the addition whose result is being checked for overflow, and
2008 /// L and R are matched to the LHS and RHS of S.
2009 template <typename LHS_t, typename RHS_t, typename Sum_t>
2011 m_UAddWithOverflow(const LHS_t &L, const RHS_t &R, const Sum_t &S) {
2013 }
2014 
2015 template <typename Opnd_t> struct Argument_match {
2016  unsigned OpI;
2017  Opnd_t Val;
2018 
2019  Argument_match(unsigned OpIdx, const Opnd_t &V) : OpI(OpIdx), Val(V) {}
2020 
2021  template <typename OpTy> bool match(OpTy *V) {
2022  // FIXME: Should likely be switched to use `CallBase`.
2023  if (const auto *CI = dyn_cast<CallInst>(V))
2024  return Val.match(CI->getArgOperand(OpI));
2025  return false;
2026  }
2027 };
2028 
2029 /// Match an argument.
2030 template <unsigned OpI, typename Opnd_t>
2031 inline Argument_match<Opnd_t> m_Argument(const Opnd_t &Op) {
2032  return Argument_match<Opnd_t>(OpI, Op);
2033 }
2034 
2035 /// Intrinsic matchers.
2037  unsigned ID;
2038 
2039  IntrinsicID_match(Intrinsic::ID IntrID) : ID(IntrID) {}
2040 
2041  template <typename OpTy> bool match(OpTy *V) {
2042  if (const auto *CI = dyn_cast<CallInst>(V))
2043  if (const auto *F = CI->getCalledFunction())
2044  return F->getIntrinsicID() == ID;
2045  return false;
2046  }
2047 };
2048 
2049 /// Intrinsic matches are combinations of ID matchers, and argument
2050 /// matchers. Higher arity matcher are defined recursively in terms of and-ing
2051 /// them with lower arity matchers. Here's some convenient typedefs for up to
2052 /// several arguments, and more can be added as needed
2053 template <typename T0 = void, typename T1 = void, typename T2 = void,
2054  typename T3 = void, typename T4 = void, typename T5 = void,
2055  typename T6 = void, typename T7 = void, typename T8 = void,
2056  typename T9 = void, typename T10 = void>
2058 template <typename T0> struct m_Intrinsic_Ty<T0> {
2060 };
2061 template <typename T0, typename T1> struct m_Intrinsic_Ty<T0, T1> {
2062  using Ty =
2064 };
2065 template <typename T0, typename T1, typename T2>
2066 struct m_Intrinsic_Ty<T0, T1, T2> {
2069 };
2070 template <typename T0, typename T1, typename T2, typename T3>
2071 struct m_Intrinsic_Ty<T0, T1, T2, T3> {
2074 };
2075 
2076 template <typename T0, typename T1, typename T2, typename T3, typename T4>
2077 struct m_Intrinsic_Ty<T0, T1, T2, T3, T4> {
2080 };
2081 
2082 template <typename T0, typename T1, typename T2, typename T3, typename T4,
2083  typename T5>
2084 struct m_Intrinsic_Ty<T0, T1, T2, T3, T4, T5> {
2087 };
2088 
2089 /// Match intrinsic calls like this:
2090 /// m_Intrinsic<Intrinsic::fabs>(m_Value(X))
2091 template <Intrinsic::ID IntrID> inline IntrinsicID_match m_Intrinsic() {
2092  return IntrinsicID_match(IntrID);
2093 }
2094 
2095 /// Matches MaskedLoad Intrinsic.
2096 template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2098 m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2099  const Opnd3 &Op3) {
2100  return m_Intrinsic<Intrinsic::masked_load>(Op0, Op1, Op2, Op3);
2101 }
2102 
2103 /// Matches MaskedGather Intrinsic.
2104 template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2106 m_MaskedGather(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2107  const Opnd3 &Op3) {
2108  return m_Intrinsic<Intrinsic::masked_gather>(Op0, Op1, Op2, Op3);
2109 }
2110 
2111 template <Intrinsic::ID IntrID, typename T0>
2112 inline typename m_Intrinsic_Ty<T0>::Ty m_Intrinsic(const T0 &Op0) {
2113  return m_CombineAnd(m_Intrinsic<IntrID>(), m_Argument<0>(Op0));
2114 }
2115 
2116 template <Intrinsic::ID IntrID, typename T0, typename T1>
2117 inline typename m_Intrinsic_Ty<T0, T1>::Ty m_Intrinsic(const T0 &Op0,
2118  const T1 &Op1) {
2119  return m_CombineAnd(m_Intrinsic<IntrID>(Op0), m_Argument<1>(Op1));
2120 }
2121 
2122 template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2>
2123 inline typename m_Intrinsic_Ty<T0, T1, T2>::Ty
2124 m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2) {
2125  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1), m_Argument<2>(Op2));
2126 }
2127 
2128 template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2129  typename T3>
2130 inline typename m_Intrinsic_Ty<T0, T1, T2, T3>::Ty
2131 m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3) {
2132  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2), m_Argument<3>(Op3));
2133 }
2134 
2135 template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2136  typename T3, typename T4>
2138 m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2139  const T4 &Op4) {
2140  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3),
2141  m_Argument<4>(Op4));
2142 }
2143 
2144 template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2145  typename T3, typename T4, typename T5>
2147 m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2148  const T4 &Op4, const T5 &Op5) {
2149  return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3, Op4),
2150  m_Argument<5>(Op5));
2151 }
2152 
2153 // Helper intrinsic matching specializations.
2154 template <typename Opnd0>
2155 inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BitReverse(const Opnd0 &Op0) {
2156  return m_Intrinsic<Intrinsic::bitreverse>(Op0);
2157 }
2158 
2159 template <typename Opnd0>
2160 inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BSwap(const Opnd0 &Op0) {
2161  return m_Intrinsic<Intrinsic::bswap>(Op0);
2162 }
2163 
2164 template <typename Opnd0>
2165 inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FAbs(const Opnd0 &Op0) {
2166  return m_Intrinsic<Intrinsic::fabs>(Op0);
2167 }
2168 
2169 template <typename Opnd0>
2170 inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FCanonicalize(const Opnd0 &Op0) {
2171  return m_Intrinsic<Intrinsic::canonicalize>(Op0);
2172 }
2173 
2174 template <typename Opnd0, typename Opnd1>
2175 inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMin(const Opnd0 &Op0,
2176  const Opnd1 &Op1) {
2177  return m_Intrinsic<Intrinsic::minnum>(Op0, Op1);
2178 }
2179 
2180 template <typename Opnd0, typename Opnd1>
2181 inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMax(const Opnd0 &Op0,
2182  const Opnd1 &Op1) {
2183  return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
2184 }
2185 
2186 template <typename Opnd0, typename Opnd1, typename Opnd2>
2188 m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2189  return m_Intrinsic<Intrinsic::fshl>(Op0, Op1, Op2);
2190 }
2191 
2192 template <typename Opnd0, typename Opnd1, typename Opnd2>
2194 m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2195  return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
2196 }
2197 
2198 template <typename Opnd0>
2199 inline typename m_Intrinsic_Ty<Opnd0>::Ty m_Sqrt(const Opnd0 &Op0) {
2200  return m_Intrinsic<Intrinsic::sqrt>(Op0);
2201 }
2202 
2203 //===----------------------------------------------------------------------===//
2204 // Matchers for two-operands operators with the operators in either order
2205 //
2206 
2207 /// Matches a BinaryOperator with LHS and RHS in either order.
2208 template <typename LHS, typename RHS>
2210  return AnyBinaryOp_match<LHS, RHS, true>(L, R);
2211 }
2212 
2213 /// Matches an ICmp with a predicate over LHS and RHS in either order.
2214 /// Swaps the predicate if operands are commuted.
2215 template <typename LHS, typename RHS>
2217 m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
2219  R);
2220 }
2221 
2222 /// Matches a specific opcode with LHS and RHS in either order.
2223 template <typename LHS, typename RHS>
2225 m_c_BinOp(unsigned Opcode, const LHS &L, const RHS &R) {
2226  return SpecificBinaryOp_match<LHS, RHS, true>(Opcode, L, R);
2227 }
2228 
2229 /// Matches a Add with LHS and RHS in either order.
2230 template <typename LHS, typename RHS>
2232  const RHS &R) {
2234 }
2235 
2236 /// Matches a Mul with LHS and RHS in either order.
2237 template <typename LHS, typename RHS>
2239  const RHS &R) {
2241 }
2242 
2243 /// Matches an And with LHS and RHS in either order.
2244 template <typename LHS, typename RHS>
2246  const RHS &R) {
2248 }
2249 
2250 /// Matches an Or with LHS and RHS in either order.
2251 template <typename LHS, typename RHS>
2253  const RHS &R) {
2255 }
2256 
2257 /// Matches an Xor with LHS and RHS in either order.
2258 template <typename LHS, typename RHS>
2260  const RHS &R) {
2262 }
2263 
2264 /// Matches a 'Neg' as 'sub 0, V'.
2265 template <typename ValTy>
2266 inline BinaryOp_match<cst_pred_ty<is_zero_int>, ValTy, Instruction::Sub>
2267 m_Neg(const ValTy &V) {
2268  return m_Sub(m_ZeroInt(), V);
2269 }
2270 
2271 /// Matches a 'Neg' as 'sub nsw 0, V'.
2272 template <typename ValTy>
2274  Instruction::Sub,
2276 m_NSWNeg(const ValTy &V) {
2277  return m_NSWSub(m_ZeroInt(), V);
2278 }
2279 
2280 /// Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
2281 template <typename ValTy>
2282 inline BinaryOp_match<ValTy, cst_pred_ty<is_all_ones>, Instruction::Xor, true>
2283 m_Not(const ValTy &V) {
2284  return m_c_Xor(V, m_AllOnes());
2285 }
2286 
2287 template <typename ValTy> struct NotForbidUndef_match {
2288  ValTy Val;
2289  NotForbidUndef_match(const ValTy &V) : Val(V) {}
2290 
2291  template <typename OpTy> bool match(OpTy *V) {
2292  // We do not use m_c_Xor because that could match an arbitrary APInt that is
2293  // not -1 as C and then fail to match the other operand if it is -1.
2294  // This code should still work even when both operands are constants.
2295  Value *X;
2296  const APInt *C;
2297  if (m_Xor(m_Value(X), m_APIntForbidUndef(C)).match(V) && C->isAllOnes())
2298  return Val.match(X);
2299  if (m_Xor(m_APIntForbidUndef(C), m_Value(X)).match(V) && C->isAllOnes())
2300  return Val.match(X);
2301  return false;
2302  }
2303 };
2304 
2305 /// Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'. For vectors, the
2306 /// constant value must be composed of only -1 scalar elements.
2307 template <typename ValTy>
2309  return NotForbidUndef_match<ValTy>(V);
2310 }
2311 
2312 /// Matches an SMin with LHS and RHS in either order.
2313 template <typename LHS, typename RHS>
2315 m_c_SMin(const LHS &L, const RHS &R) {
2317 }
2318 /// Matches an SMax with LHS and RHS in either order.
2319 template <typename LHS, typename RHS>
2321 m_c_SMax(const LHS &L, const RHS &R) {
2323 }
2324 /// Matches a UMin with LHS and RHS in either order.
2325 template <typename LHS, typename RHS>
2327 m_c_UMin(const LHS &L, const RHS &R) {
2329 }
2330 /// Matches a UMax with LHS and RHS in either order.
2331 template <typename LHS, typename RHS>
2333 m_c_UMax(const LHS &L, const RHS &R) {
2335 }
2336 
2337 template <typename LHS, typename RHS>
2338 inline match_combine_or<
2343 m_c_MaxOrMin(const LHS &L, const RHS &R) {
2344  return m_CombineOr(m_CombineOr(m_c_SMax(L, R), m_c_SMin(L, R)),
2345  m_CombineOr(m_c_UMax(L, R), m_c_UMin(L, R)));
2346 }
2347 
2348 /// Matches FAdd with LHS and RHS in either order.
2349 template <typename LHS, typename RHS>
2351 m_c_FAdd(const LHS &L, const RHS &R) {
2353 }
2354 
2355 /// Matches FMul with LHS and RHS in either order.
2356 template <typename LHS, typename RHS>
2358 m_c_FMul(const LHS &L, const RHS &R) {
2360 }
2361 
2362 template <typename Opnd_t> struct Signum_match {
2363  Opnd_t Val;
2364  Signum_match(const Opnd_t &V) : Val(V) {}
2365 
2366  template <typename OpTy> bool match(OpTy *V) {
2367  unsigned TypeSize = V->getType()->getScalarSizeInBits();
2368  if (TypeSize == 0)
2369  return false;
2370 
2371  unsigned ShiftWidth = TypeSize - 1;
2372  Value *OpL = nullptr, *OpR = nullptr;
2373 
2374  // This is the representation of signum we match:
2375  //
2376  // signum(x) == (x >> 63) | (-x >>u 63)
2377  //
2378  // An i1 value is its own signum, so it's correct to match
2379  //
2380  // signum(x) == (x >> 0) | (-x >>u 0)
2381  //
2382  // for i1 values.
2383 
2384  auto LHS = m_AShr(m_Value(OpL), m_SpecificInt(ShiftWidth));
2385  auto RHS = m_LShr(m_Neg(m_Value(OpR)), m_SpecificInt(ShiftWidth));
2386  auto Signum = m_Or(LHS, RHS);
2387 
2388  return Signum.match(V) && OpL == OpR && Val.match(OpL);
2389  }
2390 };
2391 
2392 /// Matches a signum pattern.
2393 ///
2394 /// signum(x) =
2395 /// x > 0 -> 1
2396 /// x == 0 -> 0
2397 /// x < 0 -> -1
2398 template <typename Val_t> inline Signum_match<Val_t> m_Signum(const Val_t &V) {
2399  return Signum_match<Val_t>(V);
2400 }
2401 
2402 template <int Ind, typename Opnd_t> struct ExtractValue_match {
2403  Opnd_t Val;
2404  ExtractValue_match(const Opnd_t &V) : Val(V) {}
2405 
2406  template <typename OpTy> bool match(OpTy *V) {
2407  if (auto *I = dyn_cast<ExtractValueInst>(V)) {
2408  // If Ind is -1, don't inspect indices
2409  if (Ind != -1 &&
2410  !(I->getNumIndices() == 1 && I->getIndices()[0] == (unsigned)Ind))
2411  return false;
2412  return Val.match(I->getAggregateOperand());
2413  }
2414  return false;
2415  }
2416 };
2417 
2418 /// Match a single index ExtractValue instruction.
2419 /// For example m_ExtractValue<1>(...)
2420 template <int Ind, typename Val_t>
2423 }
2424 
2425 /// Match an ExtractValue instruction with any index.
2426 /// For example m_ExtractValue(...)
2427 template <typename Val_t>
2428 inline ExtractValue_match<-1, Val_t> m_ExtractValue(const Val_t &V) {
2429  return ExtractValue_match<-1, Val_t>(V);
2430 }
2431 
2432 /// Matcher for a single index InsertValue instruction.
2433 template <int Ind, typename T0, typename T1> struct InsertValue_match {
2434  T0 Op0;
2436 
2437  InsertValue_match(const T0 &Op0, const T1 &Op1) : Op0(Op0), Op1(Op1) {}
2438 
2439  template <typename OpTy> bool match(OpTy *V) {
2440  if (auto *I = dyn_cast<InsertValueInst>(V)) {
2441  return Op0.match(I->getOperand(0)) && Op1.match(I->getOperand(1)) &&
2442  I->getNumIndices() == 1 && Ind == I->getIndices()[0];
2443  }
2444  return false;
2445  }
2446 };
2447 
2448 /// Matches a single index InsertValue instruction.
2449 template <int Ind, typename Val_t, typename Elt_t>
2451  const Elt_t &Elt) {
2452  return InsertValue_match<Ind, Val_t, Elt_t>(Val, Elt);
2453 }
2454 
2455 /// Matches patterns for `vscale`. This can either be a call to `llvm.vscale` or
2456 /// the constant expression
2457 /// `ptrtoint(gep <vscale x 1 x i8>, <vscale x 1 x i8>* null, i32 1>`
2458 /// under the right conditions determined by DataLayout.
2460  const DataLayout &DL;
2462 
2463  template <typename ITy> bool match(ITy *V) {
2464  if (m_Intrinsic<Intrinsic::vscale>().match(V))
2465  return true;
2466 
2467  Value *Ptr;
2468  if (m_PtrToInt(m_Value(Ptr)).match(V)) {
2469  if (auto *GEP = dyn_cast<GEPOperator>(Ptr)) {
2470  auto *DerefTy = GEP->getSourceElementType();
2471  if (GEP->getNumIndices() == 1 && isa<ScalableVectorType>(DerefTy) &&
2472  m_Zero().match(GEP->getPointerOperand()) &&
2473  m_SpecificInt(1).match(GEP->idx_begin()->get()) &&
2474  DL.getTypeAllocSizeInBits(DerefTy).getKnownMinSize() == 8)
2475  return true;
2476  }
2477  }
2478 
2479  return false;
2480  }
2481 };
2482 
2484  return VScaleVal_match(DL);
2485 }
2486 
2487 template <typename LHS, typename RHS, unsigned Opcode, bool Commutable = false>
2491 
2492  LogicalOp_match(const LHS &L, const RHS &R) : L(L), R(R) {}
2493 
2494  template <typename T> bool match(T *V) {
2495  auto *I = dyn_cast<Instruction>(V);
2496  if (!I || !I->getType()->isIntOrIntVectorTy(1))
2497  return false;
2498 
2499  if (I->getOpcode() == Opcode) {
2500  auto *Op0 = I->getOperand(0);
2501  auto *Op1 = I->getOperand(1);
2502  return (L.match(Op0) && R.match(Op1)) ||
2503  (Commutable && L.match(Op1) && R.match(Op0));
2504  }
2505 
2506  if (auto *Select = dyn_cast<SelectInst>(I)) {
2507  auto *Cond = Select->getCondition();
2508  auto *TVal = Select->getTrueValue();
2509  auto *FVal = Select->getFalseValue();
2510  if (Opcode == Instruction::And) {
2511  auto *C = dyn_cast<Constant>(FVal);
2512  if (C && C->isNullValue())
2513  return (L.match(Cond) && R.match(TVal)) ||
2514  (Commutable && L.match(TVal) && R.match(Cond));
2515  } else {
2516  assert(Opcode == Instruction::Or);
2517  auto *C = dyn_cast<Constant>(TVal);
2518  if (C && C->isOneValue())
2519  return (L.match(Cond) && R.match(FVal)) ||
2520  (Commutable && L.match(FVal) && R.match(Cond));
2521  }
2522  }
2523 
2524  return false;
2525  }
2526 };
2527 
2528 /// Matches L && R either in the form of L & R or L ? R : false.
2529 /// Note that the latter form is poison-blocking.
2530 template <typename LHS, typename RHS>
2532  const RHS &R) {
2534 }
2535 
2536 /// Matches L && R where L and R are arbitrary values.
2537 inline auto m_LogicalAnd() { return m_LogicalAnd(m_Value(), m_Value()); }
2538 
2539 /// Matches L && R with LHS and RHS in either order.
2540 template <typename LHS, typename RHS>
2542 m_c_LogicalAnd(const LHS &L, const RHS &R) {
2544 }
2545 
2546 /// Matches L || R either in the form of L | R or L ? true : R.
2547 /// Note that the latter form is poison-blocking.
2548 template <typename LHS, typename RHS>
2550  const RHS &R) {
2552 }
2553 
2554 /// Matches L || R where L and R are arbitrary values.
2555 inline auto m_LogicalOr() { return m_LogicalOr(m_Value(), m_Value()); }
2556 
2557 /// Matches L || R with LHS and RHS in either order.
2558 template <typename LHS, typename RHS>
2560 m_c_LogicalOr(const LHS &L, const RHS &R) {
2562 }
2563 
2564 } // end namespace PatternMatch
2565 } // end namespace llvm
2566 
2567 #endif // LLVM_IR_PATTERNMATCH_H
llvm::PatternMatch::apint_match::AllowUndef
bool AllowUndef
Definition: PatternMatch.h:224
llvm::PatternMatch::api_pred_ty
This helper class is used to match scalar and vector constants that satisfy a specified predicate,...
Definition: PatternMatch.h:374
llvm::PatternMatch::specificval_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:762
llvm::PatternMatch::Signum_match
Definition: PatternMatch.h:2362
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:817
llvm::PatternMatch::MaxMin_match
Definition: PatternMatch.h:1742
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:832
llvm::PatternMatch::m_APFloatForbidUndef
apfloat_match m_APFloatForbidUndef(const APFloat *&Res)
Match APFloat while forbidding undefs in splat vector constants.
Definition: PatternMatch.h:300
llvm::PatternMatch::m_Intrinsic
IntrinsicID_match m_Intrinsic()
Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X))
Definition: PatternMatch.h:2091
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:558
llvm::PatternMatch::is_pos_zero_fp
Definition: PatternMatch.h:662
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:2194
llvm::PatternMatch::is_finitenonzero::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:642
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:2106
llvm::PatternMatch::is_nan::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:600
llvm::PatternMatch::m_SIToFP
CastClass_match< OpTy, Instruction::SIToFP > m_SIToFP(const OpTy &Op)
Definition: PatternMatch.h:1661
llvm::PatternMatch::SpecificBinaryOp_match::SpecificBinaryOp_match
SpecificBinaryOp_match(unsigned Opcode, const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:1218
llvm::PatternMatch::is_zero_int::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:514
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:554
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:1820
llvm::PatternMatch::bind_ty
Definition: PatternMatch.h:691
llvm::PatternMatch::BinaryOp_match
Definition: PatternMatch.h:946
llvm::PatternMatch::Signum_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2366
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:671
llvm::PatternMatch::m_TruncOrSelf
match_combine_or< CastClass_match< OpTy, Instruction::Trunc >, OpTy > m_TruncOrSelf(const OpTy &Op)
Definition: PatternMatch.h:1611
llvm::PatternMatch::class_match::match
bool match(ITy *V)
Definition: PatternMatch.h:72
llvm::PatternMatch::m_Mask
Definition: PatternMatch.h:1508
llvm::PatternMatch::BinOpPred_match::L
LHS_t L
Definition: PatternMatch.h:1238
llvm::PatternMatch::cstval_pred_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:329
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:2011
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:809
llvm::PatternMatch::is_any_apint::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:434
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:925
llvm::PatternMatch::Exact_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1338
IntrinsicInst.h
llvm::PatternMatch::ThreeOps_match
Matches instructions with Opcode and three operands.
Definition: PatternMatch.h:1435
llvm::PatternMatch::TwoOps_match::Op2
T1 Op2
Definition: PatternMatch.h:1420
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:4164
llvm::PatternMatch::m_NegatedPower2
cst_pred_ty< is_negated_power2 > m_NegatedPower2()
Match a integer or vector negated power-of-2.
Definition: PatternMatch.h:546
llvm::PatternMatch::CmpClass_match::CmpClass_match
CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:1362
llvm::PatternMatch::NotForbidUndef_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2291
llvm::PatternMatch::ExtractValue_match::Val
Opnd_t Val
Definition: PatternMatch.h:2403
llvm::PatternMatch::match_unless::M
Ty M
Definition: PatternMatch.h:168
llvm::PatternMatch::match_combine_and::match_combine_and
match_combine_and(const LTy &Left, const RTy &Right)
Definition: PatternMatch.h:200
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:604
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:1111
llvm::PatternMatch::is_one::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:507
llvm::PatternMatch::Shuffle_match::Mask
T2 Mask
Definition: PatternMatch.h:1494
llvm::PatternMatch::m_Mask::m_Mask
m_Mask(ArrayRef< int > &MaskRef)
Definition: PatternMatch.h:1510
llvm::PatternMatch::specificval_ty::specificval_ty
specificval_ty(const Value *V)
Definition: PatternMatch.h:760
llvm::PatternMatch::m_SplatOrUndefMask
Definition: PatternMatch.h:1529
llvm::PatternMatch::deferredval_ty
Stores a reference to the Value *, not the Value * itself, thus can be used in commutative matchers.
Definition: PatternMatch.h:770
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:812
llvm::PatternMatch::AnyBinaryOp_match
Definition: PatternMatch.h:898
llvm::PatternMatch::Shuffle_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1499
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:1478
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:1523
llvm::PatternMatch::m_Freeze
OneOps_match< OpTy, Instruction::Freeze > m_Freeze(const OpTy &Op)
Matches FreezeInst.
Definition: PatternMatch.h:1471
llvm::PatternMatch::m_FRem
BinaryOp_match< LHS, RHS, Instruction::FRem > m_FRem(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1081
llvm::PatternMatch::m_Add
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:973
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:457
llvm::MCID::Commutable
@ Commutable
Definition: MCInstrDesc.h:173
llvm::PatternMatch::specific_fpval::Val
double Val
Definition: PatternMatch.h:792
llvm::PatternMatch::m_Load
OneOps_match< OpTy, Instruction::Load > m_Load(const OpTy &Op)
Matches LoadInst.
Definition: PatternMatch.h:1557
llvm::PatternMatch::match_combine_or::R
RTy R
Definition: PatternMatch.h:183
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:212
llvm::PatternMatch::SpecificBinaryOp_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1221
llvm::PatternMatch::ThreeOps_match::ThreeOps_match
ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
Definition: PatternMatch.h:1440
llvm::PatternMatch::br_match::br_match
br_match(BasicBlock *&Succ)
Definition: PatternMatch.h:1692
llvm::PatternMatch::m_SplatOrUndefMask::m_SplatOrUndefMask
m_SplatOrUndefMask(int &SplatIndex)
Definition: PatternMatch.h:1531
llvm::ConstantAggregate
Base class for aggregate constants (with operands).
Definition: Constants.h:386
llvm::PatternMatch::BinaryOp_match::L
LHS_t L
Definition: PatternMatch.h:947
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:289
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:1725
llvm::PatternMatch::m_BitReverse
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse(const Opnd0 &Op0)
Definition: PatternMatch.h:2155
llvm::PatternMatch::CastClass_match
Definition: PatternMatch.h:1573
llvm::PatternMatch::is_right_shift_op
Definition: PatternMatch.h:1258
llvm::PatternMatch::MaxMin_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1751
llvm::PatternMatch::apf_pred_ty::apf_pred_ty
apf_pred_ty(const APFloat *&R)
Definition: PatternMatch.h:403
APInt.h
llvm::PatternMatch::OneOps_match::Op1
T0 Op1
Definition: PatternMatch.h:1404
llvm::PatternMatch::m_FCanonicalize
m_Intrinsic_Ty< Opnd0 >::Ty m_FCanonicalize(const Opnd0 &Op0)
Definition: PatternMatch.h:2170
llvm::PatternMatch::m_NegZeroFP
cstfp_pred_ty< is_neg_zero_fp > m_NegZeroFP()
Match a floating-point negative zero.
Definition: PatternMatch.h:676
llvm::PatternMatch::m_NUWShl
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1207
llvm::CmpInst::ICMP_SGT
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:746
llvm::PatternMatch::SpecificBinaryOp_match
Definition: PatternMatch.h:1214
llvm::PatternMatch::MaxMin_match::L
LHS_t L
Definition: PatternMatch.h:1744
llvm::PatternMatch::specific_intval
Match a specified integer value or vector of all elements of that value.
Definition: PatternMatch.h:831
llvm::PatternMatch::smin_pred_ty::match
static bool match(ICmpInst::Predicate Pred)
Definition: PatternMatch.h:1799
llvm::PatternMatch::icmp_pred_with_threshold::Thr
const APInt * Thr
Definition: PatternMatch.h:586
llvm::PatternMatch::m_FPToUI
CastClass_match< OpTy, Instruction::FPToUI > m_FPToUI(const OpTy &Op)
Definition: PatternMatch.h:1666
llvm::PatternMatch::constantint_match::match
bool match(ITy *V)
Definition: PatternMatch.h:305
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:1937
llvm::Instruction::isShift
bool isShift() const
Definition: Instruction.h:164
llvm::PatternMatch::OneOps_match
Matches instructions with Opcode and three operands.
Definition: PatternMatch.h:1403
llvm::PatternMatch::is_maxsignedvalue
Definition: PatternMatch.h:451
llvm::PatternMatch::is_negative::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:465
llvm::PatternMatch::BinOpPred_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1243
T1
#define T1
Definition: Mips16ISelLowering.cpp:340
llvm::PatternMatch::CastClass_match::CastClass_match
CastClass_match(const Op_t &OpMatch)
Definition: PatternMatch.h:1576
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:1651
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:1424
llvm::PatternMatch::m_SplatOrUndefMask::match
bool match(ArrayRef< int > Mask)
Definition: PatternMatch.h:1532
llvm::PatternMatch::m_AShr
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1117
llvm::tgtok::FalseVal
@ FalseVal
Definition: TGLexer.h:62
llvm::PatternMatch::InsertValue_match
Matcher for a single index InsertValue instruction.
Definition: PatternMatch.h:2433
llvm::PatternMatch::m_SpecificBB
specific_bbval m_SpecificBB(BasicBlock *BB)
Match a specific basic block value.
Definition: PatternMatch.h:881
Operator.h
llvm::PatternMatch::is_negated_power2
Definition: PatternMatch.h:541
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:2492
llvm::PatternMatch::IntrinsicID_match::IntrinsicID_match
IntrinsicID_match(Intrinsic::ID IntrID)
Definition: PatternMatch.h:2039
llvm::PatternMatch::OneOps_match::OneOps_match
OneOps_match(const T0 &Op1)
Definition: PatternMatch.h:1406
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:952
llvm::PatternMatch::bind_const_intval_ty
Definition: PatternMatch.h:814
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:2245
llvm::PatternMatch::m_Mask::match
bool match(ArrayRef< int > Mask)
Definition: PatternMatch.h:1511
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:2283
llvm::PatternMatch::m_BitCast
CastClass_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
Definition: PatternMatch.h:1587
llvm::PatternMatch::ThreeOps_match::Op1
T0 Op1
Definition: PatternMatch.h:1436
llvm::PatternMatch::VScaleVal_match::match
bool match(ITy *V)
Definition: PatternMatch.h:2463
llvm::PatternMatch::m_VScale
VScaleVal_match m_VScale(const DataLayout &DL)
Definition: PatternMatch.h:2483
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:815
llvm::PatternMatch::apfloat_match
Definition: PatternMatch.h:247
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:784
llvm::PatternMatch::m_ConstantFP
class_match< ConstantFP > m_ConstantFP()
Match an arbitrary ConstantFP and ignore it.
Definition: PatternMatch.h:152
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:2137
llvm::PatternMatch::m_FDiv
BinaryOp_match< LHS, RHS, Instruction::FDiv > m_FDiv(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1063
llvm::PatternMatch::ExtractValue_match::ExtractValue_match
ExtractValue_match(const Opnd_t &V)
Definition: PatternMatch.h:2404
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:2343
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:979
llvm::PatternMatch::umax_pred_ty::match
static bool match(ICmpInst::Predicate Pred)
Definition: PatternMatch.h:1806
llvm::PatternMatch::m_FSub
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:991
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:176
llvm::PatternMatch::MaxMin_match::R
RHS_t R
Definition: PatternMatch.h:1745
llvm::PatternMatch::AnyUnaryOp_match
Definition: PatternMatch.h:924
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:2217
llvm::PatternMatch::is_power2_or_zero
Definition: PatternMatch.h:553
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:2363
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:328
llvm::PatternMatch::match_combine_and
Definition: PatternMatch.h:196
llvm::AlignStyle::Left
@ Left
llvm::PatternMatch::is_strictlypositive
Definition: PatternMatch.h:484
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:272
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:2209
llvm::PatternMatch::m_UMax
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1859
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:1906
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
llvm::PatternMatch::is_maxsignedvalue::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:452
llvm::PatternMatch::FNeg_match
Definition: PatternMatch.h:996
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:1617
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:579
llvm::PatternMatch::m_UIToFP
CastClass_match< OpTy, Instruction::UIToFP > m_UIToFP(const OpTy &Op)
Definition: PatternMatch.h:1656
llvm::PatternMatch::is_finite::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:632
llvm::PatternMatch::is_idiv_op::isOpType
bool isOpType(unsigned Opcode)
Definition: PatternMatch.h:1277
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:1456
llvm::PatternMatch::AnyBinaryOp_match::AnyBinaryOp_match
AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:904
llvm::PatternMatch::smax_pred_ty::match
static bool match(ICmpInst::Predicate Pred)
Definition: PatternMatch.h:1792
llvm::PatternMatch::smin_pred_ty
Helper class for identifying signed min predicates.
Definition: PatternMatch.h:1798
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:1642
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:1418
llvm::PatternMatch::NotForbidUndef_match::NotForbidUndef_match
NotForbidUndef_match(const ValTy &V)
Definition: PatternMatch.h:2289
llvm::PatternMatch::ufmax_pred_ty
Helper class for identifying unordered max predicates.
Definition: PatternMatch.h:1833
llvm::PatternMatch::is_lowbit_mask::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:575
llvm::PatternMatch::Shuffle_match::Shuffle_match
Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
Definition: PatternMatch.h:1496
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:2188
llvm::PatternMatch::match_combine_and::R
RTy R
Definition: PatternMatch.h:198
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:869
llvm::PatternMatch::specific_bbval::match
bool match(ITy *V)
Definition: PatternMatch.h:874
llvm::PatternMatch::m_Exact
Exact_match< T > m_Exact(const T &SubPattern)
Definition: PatternMatch.h:1345
llvm::PatternMatch::AnyUnaryOp_match::AnyUnaryOp_match
AnyUnaryOp_match(const OP_t &X)
Definition: PatternMatch.h:927
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:856
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:251
llvm::PatternMatch::Exact_match
Definition: PatternMatch.h:1333
llvm::PatternMatch::CastClass_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1578
llvm::PatternMatch::match_combine_or
Matching combinators.
Definition: PatternMatch.h:181
llvm::PatternMatch::BinaryOp_match::R
RHS_t R
Definition: PatternMatch.h:948
llvm::PatternMatch::m_PosZeroFP
cstfp_pred_ty< is_pos_zero_fp > m_PosZeroFP()
Match a floating-point positive zero.
Definition: PatternMatch.h:667
llvm::PatternMatch::m_NonNaN
cstfp_pred_ty< is_nonnan > m_NonNaN()
Match a non-NaN FP constant.
Definition: PatternMatch.h:611
llvm::PatternMatch::is_lowbit_mask
Definition: PatternMatch.h:574
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:771
llvm::PatternMatch::is_bitwiselogic_op
Definition: PatternMatch.h:1270
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:710
llvm::PatternMatch::AnyBinaryOp_match::L
LHS_t L
Definition: PatternMatch.h:899
llvm::PatternMatch::class_match
Definition: PatternMatch.h:71
llvm::PatternMatch::bind_ty::bind_ty
bind_ty(Class *&V)
Definition: PatternMatch.h:694
llvm::PatternMatch::m_ZExt
CastClass_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
Definition: PatternMatch.h:1623
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:2231
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:542
llvm::PatternMatch::CmpClass_match::Predicate
PredicateTy & Predicate
Definition: PatternMatch.h:1356
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:1876
llvm::PatternMatch::m_FNeg
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
Definition: PatternMatch.h:1027
llvm::PatternMatch::ufmin_pred_ty
Helper class for identifying unordered min predicates.
Definition: PatternMatch.h:1840
llvm::PatternMatch::deferredval_ty::deferredval_ty
deferredval_ty(Class *const &V)
Definition: PatternMatch.h:773
llvm::PatternMatch::m_SDiv
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1057
llvm::PatternMatch::m_ConstantInt
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:147
llvm::PatternMatch::is_idiv_op
Definition: PatternMatch.h:1276
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:1318
llvm::PatternMatch::m_NSWMul
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > m_NSWMul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1166
llvm::PatternMatch::icmp_pred_with_threshold::Pred
ICmpInst::Predicate Pred
Definition: PatternMatch.h:585
llvm::PatternMatch::m_UMin
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1865
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:2252
llvm::PatternMatch::UAddWithOverflow_match::R
RHS_t R
Definition: PatternMatch.h:1949
RHS_t
llvm::PatternMatch::br_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1694
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:1708
llvm::PatternMatch::m_NSWSub
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1158
llvm::PatternMatch::apint_match
Definition: PatternMatch.h:222
llvm::PatternMatch::CmpClass_match::R
RHS_t R
Definition: PatternMatch.h:1358
llvm::OverflowingBinaryOperator::NoSignedWrap
@ NoSignedWrap
Definition: Operator.h:77
llvm::PatternMatch::apint_match::match
bool match(ITy *V)
Definition: PatternMatch.h:229
llvm::PatternMatch::BinOpPred_match::R
RHS_t R
Definition: PatternMatch.h:1239
llvm::OverflowingBinaryOperator::NoUnsignedWrap
@ NoUnsignedWrap
Definition: Operator.h:76
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:1922
llvm::PatternMatch::is_pos_zero_fp::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:663
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:501
llvm::PatternMatch::m_URem
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1069
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:1259
llvm::PatternMatch::apfloat_match::AllowUndef
bool AllowUndef
Definition: PatternMatch.h:249
llvm::PatternMatch::m_APIntAllowUndef
apint_match m_APIntAllowUndef(const APInt *&Res)
Match APInt while allowing undefs in splat vector constants.
Definition: PatternMatch.h:278
llvm::PatternMatch::VScaleVal_match
Matches patterns for vscale.
Definition: PatternMatch.h:2459
LHS_t
llvm::PatternMatch::specificval_ty
Match a specified Value*.
Definition: PatternMatch.h:757
llvm::PatternMatch::is_inf
Definition: PatternMatch.h:615
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:1290
llvm::PatternMatch::is_sign_mask::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:566
llvm::PatternMatch::Argument_match::Val
Opnd_t Val
Definition: PatternMatch.h:2017
llvm::PatternMatch::SpecificBinaryOp_match::Opcode
unsigned Opcode
Definition: PatternMatch.h:1216
llvm::PatternMatch::is_zero
Definition: PatternMatch.h:522
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:2333
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:511
llvm::PatternMatch::is_logical_shift_op
Definition: PatternMatch.h:1264
llvm::PatternMatch::Shuffle_match::Op1
T0 Op1
Definition: PatternMatch.h:1492
llvm::PatternMatch::bind_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:696
llvm::PatternMatch::FNeg_match::FNeg_match
FNeg_match(const Op_t &Op)
Definition: PatternMatch.h:999
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:1486
llvm::PatternMatch::m_NSWAdd
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1150
llvm::PatternMatch::ufmin_pred_ty::match
static bool match(FCmpInst::Predicate Pred)
Definition: PatternMatch.h:1841
llvm::PatternMatch::m_Power2
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
Definition: PatternMatch.h:538
llvm::PatternMatch::m_Xor
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1099
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:1297
llvm::PatternMatch::api_pred_ty::api_pred_ty
api_pred_ty(const APInt *&R)
Definition: PatternMatch.h:377
llvm::PatternMatch::m_FMax
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMax(const Opnd0 &Op0, const Opnd1 &Op1)
Definition: PatternMatch.h:2181
llvm::PatternMatch::OverflowingBinaryOp_match::R
RHS_t R
Definition: PatternMatch.h:1126
llvm::PatternMatch::m_FPTrunc
CastClass_match< OpTy, Instruction::FPTrunc > m_FPTrunc(const OpTy &Op)
Definition: PatternMatch.h:1676
llvm::PatternMatch::m_ZExtOrSelf
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, OpTy > m_ZExtOrSelf(const OpTy &Op)
Definition: PatternMatch.h:1629
llvm::PatternMatch::ExtractValue_match
Definition: PatternMatch.h:2402
llvm::PatternMatch::is_nonpositive
Definition: PatternMatch.h:496
llvm::APFloat
Definition: APFloat.h:701
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:1422
llvm::PatternMatch::m_Zero
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
Definition: PatternMatch.h:531
llvm::PatternMatch::NotForbidUndef_match::Val
ValTy Val
Definition: PatternMatch.h:2288
llvm::PatternMatch::m_NUWAdd
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1183
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::PatternMatch::is_power2
Definition: PatternMatch.h:533
llvm::PatternMatch::match_combine_or::L
LTy L
Definition: PatternMatch.h:182
llvm::PatternMatch::m_UnconditionalBr
br_match m_UnconditionalBr(BasicBlock *&Succ)
Definition: PatternMatch.h:1704
llvm::PatternMatch::LogicalOp_match::match
bool match(T *V)
Definition: PatternMatch.h:2494
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:745
llvm::PatternMatch::apf_pred_ty
This helper class is used to match scalar and vector constants that satisfy a specified predicate,...
Definition: PatternMatch.h:400
llvm::PatternMatch::smax_pred_ty
Helper class for identifying signed max predicates.
Definition: PatternMatch.h:1791
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:2549
llvm::PatternMatch::m_Inf
cstfp_pred_ty< is_inf > m_Inf()
Match a positive or negative infinity FP constant.
Definition: PatternMatch.h:620
llvm::PatternMatch::is_finitenonzero
Definition: PatternMatch.h:641
llvm::PatternMatch::is_non_zero_fp
Definition: PatternMatch.h:680
llvm::PatternMatch::m_SpecificMask::match
bool match(ArrayRef< int > Mask)
Definition: PatternMatch.h:1526
llvm::PatternMatch::bind_const_intval_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:819
llvm::PatternMatch::specific_intval::specific_intval
specific_intval(APInt V)
Definition: PatternMatch.h:834
llvm::PatternMatch::match_combine_and::L
LTy L
Definition: PatternMatch.h:197
llvm::PatternMatch::IntrinsicID_match::ID
unsigned ID
Definition: PatternMatch.h:2037
llvm::PatternMatch::Argument_match::Argument_match
Argument_match(unsigned OpIdx, const Opnd_t &V)
Definition: PatternMatch.h:2019
llvm::PatternMatch::m_Or
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1093
llvm::PatternMatch::m_AllOnes
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
Definition: PatternMatch.h:447
llvm::PatternMatch::m_NonInf
cstfp_pred_ty< is_noninf > m_NonInf()
Match a non-infinity FP constant, i.e.
Definition: PatternMatch.h:627
llvm::PatternMatch::UAddWithOverflow_match::S
Sum_t S
Definition: PatternMatch.h:1950
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:584
llvm::PatternMatch::InsertValue_match::Op0
T0 Op0
Definition: PatternMatch.h:2434
llvm::PatternMatch::m_Store
TwoOps_match< ValueOpTy, PointerOpTy, Instruction::Store > m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp)
Matches StoreInst.
Definition: PatternMatch.h:1564
llvm::PatternMatch::UAddWithOverflow_match
Definition: PatternMatch.h:1947
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::PatternMatch::is_all_ones
Definition: PatternMatch.h:442
llvm::PatternMatch::m_FAbs
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
Definition: PatternMatch.h:2165
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:2098
llvm::PatternMatch::m_And
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1087
llvm::X86II::T8
@ T8
Definition: X86BaseInfo.h:808
llvm::PatternMatch::LogicalOp_match::R
RHS R
Definition: PatternMatch.h:2490
llvm::PatternMatch::specific_bbval::Val
BasicBlock * Val
Definition: PatternMatch.h:870
llvm::PatternMatch::MaxMin_match::PredType
Pred_t PredType
Definition: PatternMatch.h:1743
llvm::PatternMatch::m_SRem
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1075
llvm::PatternMatch::AnyBinaryOp_match::R
RHS_t R
Definition: PatternMatch.h:900
llvm::PatternMatch::is_one
Definition: PatternMatch.h:506
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::PatternMatch::OverflowingBinaryOp_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1131
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:1675
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:985
llvm::PatternMatch::MaxMin_match::MaxMin_match
MaxMin_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:1749
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::PatternMatch::OneOps_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1408
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:616
llvm::PatternMatch::BinaryOp_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:969
llvm::PatternMatch::UAddWithOverflow_match::L
LHS_t L
Definition: PatternMatch.h:1948
llvm::PatternMatch::Shuffle_match::Op2
T1 Op2
Definition: PatternMatch.h:1493
llvm::PatternMatch::umin_pred_ty
Helper class for identifying unsigned min predicates.
Definition: PatternMatch.h:1812
llvm::PatternMatch::Shuffle_match
Matches shuffle.
Definition: PatternMatch.h:1491
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:2308
llvm::PatternMatch::brc_match
Definition: PatternMatch.h:1707
llvm::PatternMatch::m_ZeroMask
Definition: PatternMatch.h:1517
llvm::PatternMatch::specificval_ty::Val
const Value * Val
Definition: PatternMatch.h:758
llvm::PatternMatch::m_WithOverflowInst
bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
Definition: PatternMatch.h:716
llvm::PatternMatch::m_SMin
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1853
llvm::PatternMatch::bind_ty::VR
Class *& VR
Definition: PatternMatch.h:692
llvm::PatternMatch::m_Negative
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
Definition: PatternMatch.h:469
llvm::PatternMatch::specific_fpval::match
bool match(ITy *V)
Definition: PatternMatch.h:796
llvm::PatternMatch::is_finite
Definition: PatternMatch.h:631
llvm::PatternMatch::m_Constant
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
Definition: PatternMatch.h:144
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:401
llvm::PatternMatch::AnyUnaryOp_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:929
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:2127
llvm::PatternMatch::m_SExt
CastClass_match< OpTy, Instruction::SExt > m_SExt(const OpTy &Op)
Matches SExt.
Definition: PatternMatch.h:1617
llvm::PatternMatch::is_nan
Definition: PatternMatch.h:599
llvm::PatternMatch::specific_fpval
Match a specified floating point value or vector of all elements of that value.
Definition: PatternMatch.h:791
llvm::PatternMatch::LogicalOp_match
Definition: PatternMatch.h:2488
llvm::PatternMatch::m_SpecificMask::m_SpecificMask
m_SpecificMask(ArrayRef< int > &MaskRef)
Definition: PatternMatch.h:1525
llvm::PatternMatch::FNeg_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1000
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:848
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:218
llvm::PatternMatch::m_NUWMul
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWMul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1199
llvm::ArrayRef< int >
llvm::PatternMatch::FNeg_match::X
Op_t X
Definition: PatternMatch.h:997
llvm::BinaryOperator
Definition: InstrTypes.h:188
llvm::PatternMatch::is_nonnan::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:607
llvm::PatternMatch::VScaleVal_match::DL
const DataLayout & DL
Definition: PatternMatch.h:2460
Mul
BinaryOperator * Mul
Definition: X86PartialReduction.cpp:70
llvm::PatternMatch::is_noninf
Definition: PatternMatch.h:622
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:592
llvm::PatternMatch::match
bool match(ArrayRef< int > Mask, const Pattern &P)
Definition: PatternMatch.h:53
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:137
llvm::PatternMatch::ThreeOps_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1443
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:1709
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:1437
llvm::PatternMatch::is_sign_mask
Definition: PatternMatch.h:565
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:1545
llvm::PatternMatch::Exact_match::SubPattern
SubPattern_t SubPattern
Definition: PatternMatch.h:1334
llvm::PatternMatch::m_FiniteNonZero
cstfp_pred_ty< is_finitenonzero > m_FiniteNonZero()
Match a finite non-zero FP constant.
Definition: PatternMatch.h:646
llvm::PatternMatch::m_NonZeroFP
cstfp_pred_ty< is_non_zero_fp > m_NonZeroFP()
Match a floating-point non-zero.
Definition: PatternMatch.h:685
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::PatternMatch::is_irem_op
Definition: PatternMatch.h:1282
llvm::PatternMatch::icmp_pred_with_threshold::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:587
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:2031
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:223
llvm::WithOverflowInst
Represents an op.with.overflow intrinsic.
Definition: IntrinsicInst.h:677
llvm::PatternMatch::Argument_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2021
llvm::PatternMatch::is_irem_op::isOpType
bool isOpType(unsigned Opcode)
Definition: PatternMatch.h:1283
llvm::PatternMatch::match_combine_or::match
bool match(ITy *V)
Definition: PatternMatch.h:187
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:1325
llvm::PatternMatch::m_SMax
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1847
llvm::PatternMatch::UAddWithOverflow_match::UAddWithOverflow_match
UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
Definition: PatternMatch.h:1952
llvm::PatternMatch::VScaleVal_match::VScaleVal_match
VScaleVal_match(const DataLayout &DL)
Definition: PatternMatch.h:2461
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:534
llvm::PatternMatch::m_SpecificMask::MaskRef
ArrayRef< int > & MaskRef
Definition: PatternMatch.h:1524
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:1891
llvm::PatternMatch::constantint_match
Definition: PatternMatch.h:304
llvm::PatternMatch::deferredval_ty::match
bool match(ITy *const V)
Definition: PatternMatch.h:775
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:1644
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:2321
llvm::PatternMatch::is_negative
Definition: PatternMatch.h:464
llvm::PatternMatch::m_StrictlyPositive
cst_pred_ty< is_strictlypositive > m_StrictlyPositive()
Match an integer or vector of strictly positive values.
Definition: PatternMatch.h:489
llvm::PatternMatch::m_FMin
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMin(const Opnd0 &Op0, const Opnd1 &Op1)
Definition: PatternMatch.h:2175
llvm::MCID::Select
@ Select
Definition: MCInstrDesc.h:164
llvm::PatternMatch::InsertValue_match::Op1
T1 Op1
Definition: PatternMatch.h:2435
llvm::PatternMatch::LogicalOp_match::L
LHS L
Definition: PatternMatch.h:2489
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:1312
llvm::PatternMatch::m_FPExt
CastClass_match< OpTy, Instruction::FPExt > m_FPExt(const OpTy &Op)
Definition: PatternMatch.h:1681
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:2142
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:2041
Constant.h
llvm::PatternMatch::m_SExtOrSelf
match_combine_or< CastClass_match< OpTy, Instruction::SExt >, OpTy > m_SExtOrSelf(const OpTy &Op)
Definition: PatternMatch.h:1635
llvm::PatternMatch::InsertValue_match::InsertValue_match
InsertValue_match(const T0 &Op0, const T1 &Op1)
Definition: PatternMatch.h:2437
llvm::ConstantExpr
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:972
llvm::PatternMatch::is_bitwiselogic_op::isOpType
bool isOpType(unsigned Opcode)
Definition: PatternMatch.h:1271
llvm::PatternMatch::is_noninf::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:623
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:1051
llvm::PatternMatch::is_all_ones::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:443
llvm::PatternMatch::m_Sqrt
m_Intrinsic_Ty< Opnd0 >::Ty m_Sqrt(const Opnd0 &Op0)
Definition: PatternMatch.h:2199
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:345
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:1237
llvm::PatternMatch::m_FPToSI
CastClass_match< OpTy, Instruction::FPToSI > m_FPToSI(const OpTy &Op)
Definition: PatternMatch.h:1671
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:2315
llvm::PatternMatch::m_ZeroMask::match
bool match(ArrayRef< int > Mask)
Definition: PatternMatch.h:1518
llvm::TypeSize
Definition: TypeSize.h:435
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:794
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:570
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:1365
llvm::PatternMatch::m_NSWShl
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > m_NSWShl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1174
llvm::PatternMatch::m_BSwap
m_Intrinsic_Ty< Opnd0 >::Ty m_BSwap(const Opnd0 &Op0)
Definition: PatternMatch.h:2160
llvm::PatternMatch::ExtractValue_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2406
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:2542
llvm::PatternMatch::umax_pred_ty
Helper class for identifying unsigned max predicates.
Definition: PatternMatch.h:1805
llvm::PatternMatch::m_ExtractValue
ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)
Match a single index ExtractValue instruction.
Definition: PatternMatch.h:2421
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:2238
llvm::PatternMatch::BinOpPred_match::BinOpPred_match
BinOpPred_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:1241
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:518
llvm::PatternMatch::is_any_apint
Definition: PatternMatch.h:433
llvm::PatternMatch::m_PtrToInt
CastClass_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
Definition: PatternMatch.h:1593
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:2398
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:681
llvm::PatternMatch::m_APFloatAllowUndef
apfloat_match m_APFloatAllowUndef(const APFloat *&Res)
Match APFloat while allowing undefs in splat vector constants.
Definition: PatternMatch.h:295
llvm::PatternMatch::InsertValue_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:2439
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:2259
llvm::PatternMatch::brc_match::brc_match
brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
Definition: PatternMatch.h:1712
llvm::PatternMatch::m_Mask::MaskRef
ArrayRef< int > & MaskRef
Definition: PatternMatch.h:1509
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:1305
llvm::PatternMatch::api_pred_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:379
llvm::PatternMatch::ThreeOps_match::Op3
T2 Op3
Definition: PatternMatch.h:1438
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:658
llvm::PatternMatch::m_NUWSub
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWSub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1191
llvm::PatternMatch::Argument_match
Definition: PatternMatch.h:2015
llvm::PatternMatch::br_match::Succ
BasicBlock *& Succ
Definition: PatternMatch.h:1690
llvm::PatternMatch::ofmax_pred_ty
Helper class for identifying ordered max predicates.
Definition: PatternMatch.h:1819
llvm::PatternMatch::OverflowingBinaryOp_match::OverflowingBinaryOp_match
OverflowingBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:1128
llvm::PatternMatch::m_ConstantExpr
class_match< ConstantExpr > m_ConstantExpr()
Match an arbitrary ConstantExpr and ignore it.
Definition: PatternMatch.h:157
llvm::PatternMatch::is_shift_op
Definition: PatternMatch.h:1254
llvm::PatternMatch::m_Intrinsic_Ty
Intrinsic matches are combinations of ID matchers, and argument matchers.
Definition: PatternMatch.h:2057
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:2358
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:2351
llvm::PatternMatch::m_AnyIntegralConstant
cst_pred_ty< is_any_apint > m_AnyIntegralConstant()
Match an integer or vector with any integral constant.
Definition: PatternMatch.h:438
llvm::PatternMatch::apint_match::apint_match
apint_match(const APInt *&Res, bool AllowUndef)
Definition: PatternMatch.h:226
llvm::PatternMatch::m_Specific
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:766
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:1388
llvm::CmpInst::ICMP_UGT
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:742
llvm::PatternMatch::OverflowingBinaryOp_match::L
LHS_t L
Definition: PatternMatch.h:1125
llvm::PatternMatch::brc_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1715
llvm::PatternMatch::m_SplatOrUndefMask::SplatIndex
int & SplatIndex
Definition: PatternMatch.h:1530
llvm::PatternMatch::TwoOps_match::Op1
T0 Op1
Definition: PatternMatch.h:1419
llvm::PatternMatch::Signum_match::Signum_match
Signum_match(const Opnd_t &V)
Definition: PatternMatch.h:2364
llvm::PatternMatch::is_shift_op::isOpType
bool isOpType(unsigned Opcode)
Definition: PatternMatch.h:1255
llvm::PatternMatch::CmpClass_match::L
LHS_t L
Definition: PatternMatch.h:1357
llvm::PatternMatch::specific_intval::match
bool match(ITy *V)
Definition: PatternMatch.h:836
llvm::PatternMatch::is_nonpositive::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:497
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:2276
llvm::PatternMatch::BinaryOp_match::match
bool match(unsigned Opc, OpTy *V)
Definition: PatternMatch.h:954
llvm::PatternMatch::UAddWithOverflow_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:1955
llvm::TypeSize::getKnownMinSize
ScalarTy getKnownMinSize() const
Definition: TypeSize.h:445
llvm::PatternMatch::match_unless::match
bool match(ITy *V)
Definition: PatternMatch.h:172
llvm::PatternMatch::api_pred_ty::Res
const APInt *& Res
Definition: PatternMatch.h:375
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:1394
llvm::PatternMatch::ofmin_pred_ty
Helper class for identifying ordered min predicates.
Definition: PatternMatch.h:1826
llvm::PatternMatch::m_IntToPtr
CastClass_match< OpTy, Instruction::IntToPtr > m_IntToPtr(const OpTy &Op)
Matches IntToPtr.
Definition: PatternMatch.h:1599
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:2267
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:2450
llvm::PatternMatch::is_neg_zero_fp::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:672
llvm::PatternMatch::specific_bbval::specific_bbval
specific_bbval(BasicBlock *Val)
Definition: PatternMatch.h:872
llvm::PatternMatch::is_any_zero_fp
Definition: PatternMatch.h:653
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:167
GEP
Hexagon Common GEP
Definition: HexagonCommonGEP.cpp:171
llvm::PatternMatch::is_strictlypositive::isValue
bool isValue(const APInt &C)
Definition: PatternMatch.h:485
llvm::PatternMatch::match_combine_or::match_combine_or
match_combine_or(const LTy &Left, const RTy &Right)
Definition: PatternMatch.h:185
llvm::PatternMatch::is_nonnegative
Definition: PatternMatch.h:474
llvm::PatternMatch::CmpClass_match
Definition: PatternMatch.h:1355
llvm::PatternMatch::Argument_match::OpI
unsigned OpI
Definition: PatternMatch.h:2016
llvm::PatternMatch::m_APIntForbidUndef
apint_match m_APIntForbidUndef(const APInt *&Res)
Match APInt while forbidding undefs in splat vector constants.
Definition: PatternMatch.h:283
llvm::PatternMatch::m_BasicBlock
class_match< BasicBlock > m_BasicBlock()
Match an arbitrary basic block value and ignore it.
Definition: PatternMatch.h:162
llvm::PatternMatch::umin_pred_ty::match
static bool match(ICmpInst::Predicate Pred)
Definition: PatternMatch.h:1813
llvm::PatternMatch::m_Finite
cstfp_pred_ty< is_finite > m_Finite()
Match a finite FP constant, i.e.
Definition: PatternMatch.h:636
llvm::PatternMatch::NotForbidUndef_match
Definition: PatternMatch.h:2287
llvm::PatternMatch::is_zero_int
Definition: PatternMatch.h:513
llvm::PatternMatch::apfloat_match::Res
const APFloat *& Res
Definition: PatternMatch.h:248
llvm::PatternMatch::match_unless::match_unless
match_unless(const Ty &Matcher)
Definition: PatternMatch.h:170
llvm::PatternMatch::m_Trunc
CastClass_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
Definition: PatternMatch.h:1605
llvm::PatternMatch::match_combine_and::match
bool match(ITy *V)
Definition: PatternMatch.h:202
llvm::PatternMatch::is_nonnan
Definition: PatternMatch.h:606
llvm::PatternMatch::apfloat_match::match
bool match(ITy *V)
Definition: PatternMatch.h:254
llvm::PatternMatch::CastClass_match::Op
Op_t Op
Definition: PatternMatch.h:1574
llvm::PatternMatch::ofmin_pred_ty::match
static bool match(FCmpInst::Predicate Pred)
Definition: PatternMatch.h:1827
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:1465
llvm::PatternMatch::m_FMul
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1045
llvm::tgtok::TrueVal
@ TrueVal
Definition: TGLexer.h:62
llvm::PatternMatch::is_any_zero_fp::isValue
bool isValue(const APFloat &C)
Definition: PatternMatch.h:654
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:2560
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:1265
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:1105
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:1034
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:2132
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:2531
llvm::PatternMatch::Exact_match::Exact_match
Exact_match(const SubPattern_t &SP)
Definition: PatternMatch.h:1336
llvm::PatternMatch::apf_pred_ty::match
bool match(ITy *V)
Definition: PatternMatch.h:405
llvm::PatternMatch::OneUse_match::SubPattern
SubPattern_t SubPattern
Definition: PatternMatch.h:58
llvm::PatternMatch::AnyBinaryOp_match::match
bool match(OpTy *V)
Definition: PatternMatch.h:906
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:2327
llvm::PatternMatch::m_Mul
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:1039
llvm::PatternMatch::ufmax_pred_ty::match
static bool match(FCmpInst::Predicate Pred)
Definition: PatternMatch.h:1834
llvm::PatternMatch::is_zero::match
bool match(ITy *V)
Definition: PatternMatch.h:523
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:927
llvm::PatternMatch::OverflowingBinaryOp_match
Definition: PatternMatch.h:1124
llvm::PatternMatch::IntrinsicID_match
Intrinsic matchers.
Definition: PatternMatch.h:2036
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:38
llvm::PatternMatch::br_match
Definition: PatternMatch.h:1689
llvm::PatternMatch::brc_match::F
FalseBlock_t F
Definition: PatternMatch.h:1710