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