LLVM 18.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"
40#include "llvm/IR/Intrinsics.h"
41#include "llvm/IR/Operator.h"
42#include "llvm/IR/Value.h"
44#include <cstdint>
45
46namespace llvm {
47namespace PatternMatch {
48
49template <typename Val, typename Pattern> bool match(Val *V, const Pattern &P) {
50 return const_cast<Pattern &>(P).match(V);
51}
52
53template <typename Pattern> bool match(ArrayRef<int> Mask, const Pattern &P) {
54 return const_cast<Pattern &>(P).match(Mask);
55}
56
57template <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
67template <typename T> inline OneUse_match<T> m_OneUse(const T &SubPattern) {
68 return SubPattern;
69}
70
71template <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
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.
136inline auto m_Undef() { return undef_match(); }
137
138/// Match an arbitrary poison constant.
141}
142
143/// Match an arbitrary Constant and ignore it.
145
146/// Match an arbitrary ConstantInt and ignore it.
149}
150
151/// Match an arbitrary ConstantFP and ignore it.
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.
170}
171
172/// Inverting matcher
173template <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.
182template <typename Ty> inline match_unless<Ty> m_Unless(const Ty &M) {
183 return match_unless<Ty>(M);
184}
185
186/// Matching combinators
187template <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
202template <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
217template <typename LTy, typename RTy>
218inline 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
223template <typename LTy, typename RTy>
224inline match_combine_and<LTy, RTy> m_CombineAnd(const LTy &L, const RTy &R) {
225 return match_combine_and<LTy, RTy>(L, R);
226}
227
229 const APInt *&Res;
231
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
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.
278inline 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.
285 return apint_match(Res, /* AllowUndef */ true);
286}
287
288/// Match APInt while forbidding undefs in splat vector constants.
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.
295inline 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
310template <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.
326template <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.
333template <typename Predicate, typename ConstantVal>
334struct 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
371template <typename Predicate>
373
374/// specialization of cstval_pred_ty for ConstantFP
375template <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.
380template <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.
406template <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
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.
446}
447
449 bool isValue(const APInt &C) { return C.isShiftedMask(); }
450};
451
454}
455
457 bool isValue(const APInt &C) { return C.isAllOnes(); }
458};
459/// Match an integer or vector with all bits set.
460/// For vectors, this includes constants with undefined elements.
463}
464
466 bool isValue(const APInt &C) { return C.isMaxSignedValue(); }
467};
468/// Match an integer or vector with values having all bits except for the high
469/// bit set (0x7f...).
470/// For vectors, this includes constants with undefined elements.
473}
475 return V;
476}
477
479 bool isValue(const APInt &C) { return C.isNegative(); }
480};
481/// Match an integer or vector of negative values.
482/// For vectors, this includes constants with undefined elements.
485}
486inline api_pred_ty<is_negative> m_Negative(const APInt *&V) { return V; }
487
489 bool isValue(const APInt &C) { return C.isNonNegative(); }
490};
491/// Match an integer or vector of non-negative values.
492/// For vectors, this includes constants with undefined elements.
495}
496inline api_pred_ty<is_nonnegative> m_NonNegative(const APInt *&V) { return V; }
497
499 bool isValue(const APInt &C) { return C.isStrictlyPositive(); }
500};
501/// Match an integer or vector of strictly positive values.
502/// For vectors, this includes constants with undefined elements.
505}
507 return V;
508}
509
511 bool isValue(const APInt &C) { return C.isNonPositive(); }
512};
513/// Match an integer or vector of non-positive values.
514/// For vectors, this includes constants with undefined elements.
517}
518inline api_pred_ty<is_nonpositive> m_NonPositive(const APInt *&V) { return V; }
519
520struct is_one {
521 bool isValue(const APInt &C) { return C.isOne(); }
522};
523/// Match an integer 1 or a vector with all elements equal to 1.
524/// For vectors, this includes constants with undefined elements.
526
528 bool isValue(const APInt &C) { return C.isZero(); }
529};
530/// Match an integer 0 or a vector with all elements equal to 0.
531/// For vectors, this includes constants with undefined elements.
534}
535
536struct is_zero {
537 template <typename ITy> bool match(ITy *V) {
538 auto *C = dyn_cast<Constant>(V);
539 // FIXME: this should be able to do something for scalable vectors
540 return C && (C->isNullValue() || cst_pred_ty<is_zero_int>().match(C));
541 }
542};
543/// Match any null constant or a vector with all elements equal to 0.
544/// For vectors, this includes constants with undefined elements.
545inline is_zero m_Zero() { return is_zero(); }
546
547struct is_power2 {
548 bool isValue(const APInt &C) { return C.isPowerOf2(); }
549};
550/// Match an integer or vector power-of-2.
551/// For vectors, this includes constants with undefined elements.
553inline api_pred_ty<is_power2> m_Power2(const APInt *&V) { return V; }
554
556 bool isValue(const APInt &C) { return C.isNegatedPowerOf2(); }
557};
558/// Match a integer or vector negated power-of-2.
559/// For vectors, this includes constants with undefined elements.
562}
564 return V;
565}
566
568 bool isValue(const APInt &C) { return !C || C.isPowerOf2(); }
569};
570/// Match an integer or vector of 0 or power-of-2 values.
571/// For vectors, this includes constants with undefined elements.
574}
576 return V;
577}
578
580 bool isValue(const APInt &C) { return C.isSignMask(); }
581};
582/// Match an integer or vector with only the sign bit(s) set.
583/// For vectors, this includes constants with undefined elements.
586}
587
589 bool isValue(const APInt &C) { return C.isMask(); }
590};
591/// Match an integer or vector with only the low bit(s) set.
592/// For vectors, this includes constants with undefined elements.
595}
596inline api_pred_ty<is_lowbit_mask> m_LowBitMask(const APInt *&V) { return V; }
597
600 const APInt *Thr;
601 bool isValue(const APInt &C) { return ICmpInst::compare(C, *Thr, Pred); }
602};
603/// Match an integer or vector with every element comparing 'pred' (eg/ne/...)
604/// to Threshold. For vectors, this includes constants with undefined elements.
606m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold) {
608 P.Pred = Predicate;
609 P.Thr = &Threshold;
610 return P;
611}
612
613struct is_nan {
614 bool isValue(const APFloat &C) { return C.isNaN(); }
615};
616/// Match an arbitrary NaN constant. This includes quiet and signalling nans.
617/// For vectors, this includes constants with undefined elements.
619
620struct is_nonnan {
621 bool isValue(const APFloat &C) { return !C.isNaN(); }
622};
623/// Match a non-NaN FP constant.
624/// For vectors, this includes constants with undefined elements.
627}
628
629struct is_inf {
630 bool isValue(const APFloat &C) { return C.isInfinity(); }
631};
632/// Match a positive or negative infinity FP constant.
633/// For vectors, this includes constants with undefined elements.
635
636struct is_noninf {
637 bool isValue(const APFloat &C) { return !C.isInfinity(); }
638};
639/// Match a non-infinity FP constant, i.e. finite or NaN.
640/// For vectors, this includes constants with undefined elements.
643}
644
645struct is_finite {
646 bool isValue(const APFloat &C) { return C.isFinite(); }
647};
648/// Match a finite FP constant, i.e. not infinity or NaN.
649/// For vectors, this includes constants with undefined elements.
652}
653inline apf_pred_ty<is_finite> m_Finite(const APFloat *&V) { return V; }
654
656 bool isValue(const APFloat &C) { return C.isFiniteNonZero(); }
657};
658/// Match a finite non-zero FP constant.
659/// For vectors, this includes constants with undefined elements.
662}
664 return V;
665}
666
668 bool isValue(const APFloat &C) { return C.isZero(); }
669};
670/// Match a floating-point negative zero or positive zero.
671/// For vectors, this includes constants with undefined elements.
674}
675
677 bool isValue(const APFloat &C) { return C.isPosZero(); }
678};
679/// Match a floating-point positive zero.
680/// For vectors, this includes constants with undefined elements.
683}
684
686 bool isValue(const APFloat &C) { return C.isNegZero(); }
687};
688/// Match a floating-point negative zero.
689/// For vectors, this includes constants with undefined elements.
692}
693
695 bool isValue(const APFloat &C) { return C.isNonZero(); }
696};
697/// Match a floating-point non-zero.
698/// For vectors, this includes constants with undefined elements.
701}
702
703///////////////////////////////////////////////////////////////////////////////
704
705template <typename Class> struct bind_ty {
706 Class *&VR;
707
708 bind_ty(Class *&V) : VR(V) {}
709
710 template <typename ITy> bool match(ITy *V) {
711 if (auto *CV = dyn_cast<Class>(V)) {
712 VR = CV;
713 return true;
714 }
715 return false;
716 }
717};
718
719/// Match a value, capturing it if we match.
720inline bind_ty<Value> m_Value(Value *&V) { return V; }
721inline bind_ty<const Value> m_Value(const Value *&V) { return V; }
722
723/// Match an instruction, capturing it if we match.
725/// Match a unary operator, capturing it if we match.
727/// Match a binary operator, capturing it if we match.
729/// Match a with overflow intrinsic, capturing it if we match.
731 return I;
732}
735 return I;
736}
737
738/// Match a Constant, capturing the value if we match.
740
741/// Match a ConstantInt, capturing the value if we match.
743
744/// Match a ConstantFP, capturing the value if we match.
746
747/// Match a ConstantExpr, capturing the value if we match.
749
750/// Match a basic block value, capturing it if we match.
753 return V;
754}
755
756/// Match an arbitrary immediate Constant and ignore it.
761}
762
763/// Match an immediate Constant, capturing the value if we match.
768}
769
770/// Match a specified Value*.
772 const Value *Val;
773
774 specificval_ty(const Value *V) : Val(V) {}
775
776 template <typename ITy> bool match(ITy *V) { return V == Val; }
777};
778
779/// Match if we have a specific specified value.
780inline specificval_ty m_Specific(const Value *V) { return V; }
781
782/// Stores a reference to the Value *, not the Value * itself,
783/// thus can be used in commutative matchers.
784template <typename Class> struct deferredval_ty {
785 Class *const &Val;
786
787 deferredval_ty(Class *const &V) : Val(V) {}
788
789 template <typename ITy> bool match(ITy *const V) { return V == Val; }
790};
791
792/// Like m_Specific(), but works if the specific value to match is determined
793/// as part of the same match() expression. For example:
794/// m_Add(m_Value(X), m_Specific(X)) is incorrect, because m_Specific() will
795/// bind X before the pattern match starts.
796/// m_Add(m_Value(X), m_Deferred(X)) is correct, and will check against
797/// whichever value m_Value(X) populated.
798inline deferredval_ty<Value> m_Deferred(Value *const &V) { return V; }
800 return V;
801}
802
803/// Match a specified floating point value or vector of all elements of
804/// that value.
806 double Val;
807
808 specific_fpval(double V) : Val(V) {}
809
810 template <typename ITy> bool match(ITy *V) {
811 if (const auto *CFP = dyn_cast<ConstantFP>(V))
812 return CFP->isExactlyValue(Val);
813 if (V->getType()->isVectorTy())
814 if (const auto *C = dyn_cast<Constant>(V))
815 if (auto *CFP = dyn_cast_or_null<ConstantFP>(C->getSplatValue()))
816 return CFP->isExactlyValue(Val);
817 return false;
818 }
819};
820
821/// Match a specific floating point value or vector with all elements
822/// equal to the value.
823inline specific_fpval m_SpecificFP(double V) { return specific_fpval(V); }
824
825/// Match a float 1.0 or vector with all elements equal to 1.0.
826inline specific_fpval m_FPOne() { return m_SpecificFP(1.0); }
827
830
832
833 template <typename ITy> bool match(ITy *V) {
834 if (const auto *CV = dyn_cast<ConstantInt>(V))
835 if (CV->getValue().ule(UINT64_MAX)) {
836 VR = CV->getZExtValue();
837 return true;
838 }
839 return false;
840 }
841};
842
843/// Match a specified integer value or vector of all elements of that
844/// value.
845template <bool AllowUndefs> struct specific_intval {
847
849
850 template <typename ITy> bool match(ITy *V) {
851 const auto *CI = dyn_cast<ConstantInt>(V);
852 if (!CI && V->getType()->isVectorTy())
853 if (const auto *C = dyn_cast<Constant>(V))
854 CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowUndefs));
855
856 return CI && APInt::isSameValue(CI->getValue(), Val);
857 }
858};
859
860/// Match a specific integer value or vector with all elements equal to
861/// the value.
863 return specific_intval<false>(std::move(V));
864}
865
867 return m_SpecificInt(APInt(64, V));
868}
869
871 return specific_intval<true>(std::move(V));
872}
873
875 return m_SpecificIntAllowUndef(APInt(64, V));
876}
877
878/// Match a ConstantInt and bind to its value. This does not match
879/// ConstantInts wider than 64-bits.
881
882/// Match a specified basic block value.
885
887
888 template <typename ITy> bool match(ITy *V) {
889 const auto *BB = dyn_cast<BasicBlock>(V);
890 return BB && BB == Val;
891 }
892};
893
894/// Match a specific basic block value.
896 return specific_bbval(BB);
897}
898
899/// A commutative-friendly version of m_Specific().
901 return BB;
902}
904m_Deferred(const BasicBlock *const &BB) {
905 return BB;
906}
907
908//===----------------------------------------------------------------------===//
909// Matcher for any binary operator.
910//
911template <typename LHS_t, typename RHS_t, bool Commutable = false>
915
916 // The evaluation order is always stable, regardless of Commutability.
917 // The LHS is always matched first.
918 AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
919
920 template <typename OpTy> bool match(OpTy *V) {
921 if (auto *I = dyn_cast<BinaryOperator>(V))
922 return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
923 (Commutable && L.match(I->getOperand(1)) &&
924 R.match(I->getOperand(0)));
925 return false;
926 }
927};
928
929template <typename LHS, typename RHS>
930inline AnyBinaryOp_match<LHS, RHS> m_BinOp(const LHS &L, const RHS &R) {
931 return AnyBinaryOp_match<LHS, RHS>(L, R);
932}
933
934//===----------------------------------------------------------------------===//
935// Matcher for any unary operator.
936// TODO fuse unary, binary matcher into n-ary matcher
937//
938template <typename OP_t> struct AnyUnaryOp_match {
939 OP_t X;
940
941 AnyUnaryOp_match(const OP_t &X) : X(X) {}
942
943 template <typename OpTy> bool match(OpTy *V) {
944 if (auto *I = dyn_cast<UnaryOperator>(V))
945 return X.match(I->getOperand(0));
946 return false;
947 }
948};
949
950template <typename OP_t> inline AnyUnaryOp_match<OP_t> m_UnOp(const OP_t &X) {
952}
953
954//===----------------------------------------------------------------------===//
955// Matchers for specific binary operators.
956//
957
958template <typename LHS_t, typename RHS_t, unsigned Opcode,
959 bool Commutable = false>
963
964 // The evaluation order is always stable, regardless of Commutability.
965 // The LHS is always matched first.
966 BinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
967
968 template <typename OpTy> inline bool match(unsigned Opc, OpTy *V) {
969 if (V->getValueID() == Value::InstructionVal + Opc) {
970 auto *I = cast<BinaryOperator>(V);
971 return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
972 (Commutable && L.match(I->getOperand(1)) &&
973 R.match(I->getOperand(0)));
974 }
975 return false;
976 }
977
978 template <typename OpTy> bool match(OpTy *V) { return match(Opcode, V); }
979};
980
981template <typename LHS, typename RHS>
983 const RHS &R) {
985}
986
987template <typename LHS, typename RHS>
989 const RHS &R) {
991}
992
993template <typename LHS, typename RHS>
995 const RHS &R) {
997}
998
999template <typename LHS, typename RHS>
1001 const RHS &R) {
1003}
1004
1005template <typename Op_t> struct FNeg_match {
1006 Op_t X;
1007
1008 FNeg_match(const Op_t &Op) : X(Op) {}
1009 template <typename OpTy> bool match(OpTy *V) {
1010 auto *FPMO = dyn_cast<FPMathOperator>(V);
1011 if (!FPMO)
1012 return false;
1013
1014 if (FPMO->getOpcode() == Instruction::FNeg)
1015 return X.match(FPMO->getOperand(0));
1016
1017 if (FPMO->getOpcode() == Instruction::FSub) {
1018 if (FPMO->hasNoSignedZeros()) {
1019 // With 'nsz', any zero goes.
1020 if (!cstfp_pred_ty<is_any_zero_fp>().match(FPMO->getOperand(0)))
1021 return false;
1022 } else {
1023 // Without 'nsz', we need fsub -0.0, X exactly.
1024 if (!cstfp_pred_ty<is_neg_zero_fp>().match(FPMO->getOperand(0)))
1025 return false;
1026 }
1027
1028 return X.match(FPMO->getOperand(1));
1029 }
1030
1031 return false;
1032 }
1033};
1034
1035/// Match 'fneg X' as 'fsub -0.0, X'.
1036template <typename OpTy> inline FNeg_match<OpTy> m_FNeg(const OpTy &X) {
1037 return FNeg_match<OpTy>(X);
1038}
1039
1040/// Match 'fneg X' as 'fsub +-0.0, X'.
1041template <typename RHS>
1042inline BinaryOp_match<cstfp_pred_ty<is_any_zero_fp>, RHS, Instruction::FSub>
1043m_FNegNSZ(const RHS &X) {
1044 return m_FSub(m_AnyZeroFP(), X);
1045}
1046
1047template <typename LHS, typename RHS>
1049 const RHS &R) {
1051}
1052
1053template <typename LHS, typename RHS>
1055 const RHS &R) {
1057}
1058
1059template <typename LHS, typename RHS>
1061 const RHS &R) {
1063}
1064
1065template <typename LHS, typename RHS>
1067 const RHS &R) {
1069}
1070
1071template <typename LHS, typename RHS>
1073 const RHS &R) {
1075}
1076
1077template <typename LHS, typename RHS>
1079 const RHS &R) {
1081}
1082
1083template <typename LHS, typename RHS>
1085 const RHS &R) {
1087}
1088
1089template <typename LHS, typename RHS>
1091 const RHS &R) {
1093}
1094
1095template <typename LHS, typename RHS>
1097 const RHS &R) {
1099}
1100
1101template <typename LHS, typename RHS>
1103 const RHS &R) {
1105}
1106
1107template <typename LHS, typename RHS>
1109 const RHS &R) {
1111}
1112
1113template <typename LHS, typename RHS>
1115 const RHS &R) {
1117}
1118
1119template <typename LHS, typename RHS>
1121 const RHS &R) {
1123}
1124
1125template <typename LHS, typename RHS>
1127 const RHS &R) {
1129}
1130
1131template <typename LHS_t, typename RHS_t, unsigned Opcode,
1132 unsigned WrapFlags = 0>
1136
1138 : L(LHS), R(RHS) {}
1139
1140 template <typename OpTy> bool match(OpTy *V) {
1141 if (auto *Op = dyn_cast<OverflowingBinaryOperator>(V)) {
1142 if (Op->getOpcode() != Opcode)
1143 return false;
1145 !Op->hasNoUnsignedWrap())
1146 return false;
1147 if ((WrapFlags & OverflowingBinaryOperator::NoSignedWrap) &&
1148 !Op->hasNoSignedWrap())
1149 return false;
1150 return L.match(Op->getOperand(0)) && R.match(Op->getOperand(1));
1151 }
1152 return false;
1153 }
1154};
1155
1156template <typename LHS, typename RHS>
1157inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1159m_NSWAdd(const LHS &L, const RHS &R) {
1160 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1162 R);
1163}
1164template <typename LHS, typename RHS>
1165inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1167m_NSWSub(const LHS &L, const RHS &R) {
1168 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1170 R);
1171}
1172template <typename LHS, typename RHS>
1173inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1175m_NSWMul(const LHS &L, const RHS &R) {
1176 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1178 R);
1179}
1180template <typename LHS, typename RHS>
1181inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1183m_NSWShl(const LHS &L, const RHS &R) {
1184 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1186 R);
1187}
1188
1189template <typename LHS, typename RHS>
1190inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1192m_NUWAdd(const LHS &L, const RHS &R) {
1193 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1195 L, R);
1196}
1197template <typename LHS, typename RHS>
1198inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1200m_NUWSub(const LHS &L, const RHS &R) {
1201 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1203 L, R);
1204}
1205template <typename LHS, typename RHS>
1206inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1208m_NUWMul(const LHS &L, const RHS &R) {
1209 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1211 L, R);
1212}
1213template <typename LHS, typename RHS>
1214inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1216m_NUWShl(const LHS &L, const RHS &R) {
1217 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1219 L, R);
1220}
1221
1222template <typename LHS_t, typename RHS_t, bool Commutable = false>
1224 : public BinaryOp_match<LHS_t, RHS_t, 0, Commutable> {
1225 unsigned Opcode;
1226
1228 : BinaryOp_match<LHS_t, RHS_t, 0, Commutable>(LHS, RHS), Opcode(Opcode) {}
1229
1230 template <typename OpTy> bool match(OpTy *V) {
1232 }
1233};
1234
1235/// Matches a specific opcode.
1236template <typename LHS, typename RHS>
1238 const RHS &R) {
1240}
1241
1242//===----------------------------------------------------------------------===//
1243// Class that matches a group of binary opcodes.
1244//
1245template <typename LHS_t, typename RHS_t, typename Predicate>
1246struct BinOpPred_match : Predicate {
1249
1250 BinOpPred_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1251
1252 template <typename OpTy> bool match(OpTy *V) {
1253 if (auto *I = dyn_cast<Instruction>(V))
1254 return this->isOpType(I->getOpcode()) && L.match(I->getOperand(0)) &&
1255 R.match(I->getOperand(1));
1256 return false;
1257 }
1258};
1259
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) {
1279 }
1280};
1281
1283 bool isOpType(unsigned Opcode) {
1284 return Opcode == Instruction::SDiv || Opcode == Instruction::UDiv;
1285 }
1286};
1287
1289 bool isOpType(unsigned Opcode) {
1290 return Opcode == Instruction::SRem || Opcode == Instruction::URem;
1291 }
1292};
1293
1294/// Matches shift operations.
1295template <typename LHS, typename RHS>
1297 const RHS &R) {
1299}
1300
1301/// Matches logical shift operations.
1302template <typename LHS, typename RHS>
1304 const RHS &R) {
1306}
1307
1308/// Matches logical shift operations.
1309template <typename LHS, typename RHS>
1311m_LogicalShift(const LHS &L, const RHS &R) {
1313}
1314
1315/// Matches bitwise logic operations.
1316template <typename LHS, typename RHS>
1318m_BitwiseLogic(const LHS &L, const RHS &R) {
1320}
1321
1322/// Matches integer division operations.
1323template <typename LHS, typename RHS>
1325 const RHS &R) {
1327}
1328
1329/// Matches integer remainder operations.
1330template <typename LHS, typename RHS>
1332 const RHS &R) {
1334}
1335
1336//===----------------------------------------------------------------------===//
1337// Class that matches exact binary ops.
1338//
1339template <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
1351template <typename T> inline Exact_match<T> m_Exact(const T &SubPattern) {
1352 return SubPattern;
1353}
1354
1355//===----------------------------------------------------------------------===//
1356// Matchers for CmpInst classes
1357//
1358
1359template <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
1386template <typename LHS, typename RHS>
1388m_Cmp(CmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1390}
1391
1392template <typename LHS, typename RHS>
1394m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1396}
1397
1398template <typename LHS, typename RHS>
1400m_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.
1409template <typename T0, unsigned Opcode> struct OneOps_match {
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.
1424template <typename T0, typename T1, unsigned Opcode> struct TwoOps_match {
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.
1440template <typename T0, typename T1, typename T2, unsigned Opcode>
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.
1460template <typename Cond, typename LHS, typename RHS>
1462m_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))
1468template <int64_t L, int64_t R, typename Cond>
1470 Instruction::Select>
1472 return m_Select(C, m_ConstantInt<L>(), m_ConstantInt<R>());
1473}
1474
1475/// Matches FreezeInst.
1476template <typename OpTy>
1479}
1480
1481/// Matches InsertElementInst.
1482template <typename Val_t, typename Elt_t, typename Idx_t>
1484m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx) {
1486 Val, Elt, Idx);
1487}
1488
1489/// Matches ExtractElementInst.
1490template <typename Val_t, typename Idx_t>
1492m_ExtractElt(const Val_t &Val, const Idx_t &Idx) {
1494}
1495
1496/// Matches shuffle.
1497template <typename T0, typename T1, typename T2> struct Shuffle_match {
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
1514struct m_Mask {
1518 MaskRef = Mask;
1519 return true;
1520 }
1521};
1522
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 const 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.
1549template <typename V1_t, typename V2_t>
1551m_Shuffle(const V1_t &v1, const V2_t &v2) {
1553}
1554
1555template <typename V1_t, typename V2_t, typename Mask_t>
1557m_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.
1562template <typename OpTy>
1565}
1566
1567/// Matches StoreInst.
1568template <typename ValueOpTy, typename PointerOpTy>
1570m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp) {
1572 PointerOp);
1573}
1574
1575//===----------------------------------------------------------------------===//
1576// Matchers for CastInst classes
1577//
1578
1579template <typename Op_t, unsigned Opcode> struct CastOperator_match {
1580 Op_t Op;
1581
1582 CastOperator_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
1591template <typename Op_t, unsigned Opcode> struct CastInst_match {
1592 Op_t Op;
1593
1594 CastInst_match(const Op_t &OpMatch) : Op(OpMatch) {}
1595
1596 template <typename OpTy> bool match(OpTy *V) {
1597 if (auto *I = dyn_cast<Instruction>(V))
1598 return I->getOpcode() == Opcode && Op.match(I->getOperand(0));
1599 return false;
1600 }
1601};
1602
1603template <typename Op_t> struct PtrToIntSameSize_match {
1605 Op_t Op;
1606
1607 PtrToIntSameSize_match(const DataLayout &DL, const Op_t &OpMatch)
1608 : DL(DL), Op(OpMatch) {}
1609
1610 template <typename OpTy> bool match(OpTy *V) {
1611 if (auto *O = dyn_cast<Operator>(V))
1612 return O->getOpcode() == Instruction::PtrToInt &&
1613 DL.getTypeSizeInBits(O->getType()) ==
1614 DL.getTypeSizeInBits(O->getOperand(0)->getType()) &&
1615 Op.match(O->getOperand(0));
1616 return false;
1617 }
1618};
1619
1620/// Matches BitCast.
1621template <typename OpTy>
1623m_BitCast(const OpTy &Op) {
1625}
1626
1627/// Matches PtrToInt.
1628template <typename OpTy>
1630m_PtrToInt(const OpTy &Op) {
1632}
1633
1634template <typename OpTy>
1636 const OpTy &Op) {
1638}
1639
1640/// Matches IntToPtr.
1641template <typename OpTy>
1643m_IntToPtr(const OpTy &Op) {
1645}
1646
1647/// Matches Trunc.
1648template <typename OpTy>
1651}
1652
1653template <typename OpTy>
1655m_TruncOrSelf(const OpTy &Op) {
1656 return m_CombineOr(m_Trunc(Op), Op);
1657}
1658
1659/// Matches SExt.
1660template <typename OpTy>
1663}
1664
1665/// Matches ZExt.
1666template <typename OpTy>
1669}
1670
1671template <typename OpTy>
1673m_ZExtOrSelf(const OpTy &Op) {
1674 return m_CombineOr(m_ZExt(Op), Op);
1675}
1676
1677template <typename OpTy>
1679m_SExtOrSelf(const OpTy &Op) {
1680 return m_CombineOr(m_SExt(Op), Op);
1681}
1682
1683template <typename OpTy>
1686m_ZExtOrSExt(const OpTy &Op) {
1687 return m_CombineOr(m_ZExt(Op), m_SExt(Op));
1688}
1689
1690template <typename OpTy>
1691inline match_combine_or<
1694 OpTy>
1696 return m_CombineOr(m_ZExtOrSExt(Op), Op);
1697}
1698
1699template <typename OpTy>
1702}
1703
1704template <typename OpTy>
1707}
1708
1709template <typename OpTy>
1712}
1713
1714template <typename OpTy>
1717}
1718
1719template <typename OpTy>
1721m_FPTrunc(const OpTy &Op) {
1723}
1724
1725template <typename OpTy>
1728}
1729
1730//===----------------------------------------------------------------------===//
1731// Matchers for control flow.
1732//
1733
1734struct br_match {
1736
1738
1739 template <typename OpTy> bool match(OpTy *V) {
1740 if (auto *BI = dyn_cast<BranchInst>(V))
1741 if (BI->isUnconditional()) {
1742 Succ = BI->getSuccessor(0);
1743 return true;
1744 }
1745 return false;
1746 }
1747};
1748
1749inline br_match m_UnconditionalBr(BasicBlock *&Succ) { return br_match(Succ); }
1750
1751template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1753 Cond_t Cond;
1754 TrueBlock_t T;
1755 FalseBlock_t F;
1756
1757 brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
1758 : Cond(C), T(t), F(f) {}
1759
1760 template <typename OpTy> bool match(OpTy *V) {
1761 if (auto *BI = dyn_cast<BranchInst>(V))
1762 if (BI->isConditional() && Cond.match(BI->getCondition()))
1763 return T.match(BI->getSuccessor(0)) && F.match(BI->getSuccessor(1));
1764 return false;
1765 }
1766};
1767
1768template <typename Cond_t>
1770m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F) {
1773}
1774
1775template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1777m_Br(const Cond_t &C, const TrueBlock_t &T, const FalseBlock_t &F) {
1779}
1780
1781//===----------------------------------------------------------------------===//
1782// Matchers for max/min idioms, eg: "select (sgt x, y), x, y" -> smax(x,y).
1783//
1784
1785template <typename CmpInst_t, typename LHS_t, typename RHS_t, typename Pred_t,
1786 bool Commutable = false>
1788 using PredType = Pred_t;
1791
1792 // The evaluation order is always stable, regardless of Commutability.
1793 // The LHS is always matched first.
1794 MaxMin_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1795
1796 template <typename OpTy> bool match(OpTy *V) {
1797 if (auto *II = dyn_cast<IntrinsicInst>(V)) {
1798 Intrinsic::ID IID = II->getIntrinsicID();
1799 if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
1800 (IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
1801 (IID == Intrinsic::umax && Pred_t::match(ICmpInst::ICMP_UGT)) ||
1802 (IID == Intrinsic::umin && Pred_t::match(ICmpInst::ICMP_ULT))) {
1803 Value *LHS = II->getOperand(0), *RHS = II->getOperand(1);
1804 return (L.match(LHS) && R.match(RHS)) ||
1805 (Commutable && L.match(RHS) && R.match(LHS));
1806 }
1807 }
1808 // Look for "(x pred y) ? x : y" or "(x pred y) ? y : x".
1809 auto *SI = dyn_cast<SelectInst>(V);
1810 if (!SI)
1811 return false;
1812 auto *Cmp = dyn_cast<CmpInst_t>(SI->getCondition());
1813 if (!Cmp)
1814 return false;
1815 // At this point we have a select conditioned on a comparison. Check that
1816 // it is the values returned by the select that are being compared.
1817 auto *TrueVal = SI->getTrueValue();
1818 auto *FalseVal = SI->getFalseValue();
1819 auto *LHS = Cmp->getOperand(0);
1820 auto *RHS = Cmp->getOperand(1);
1821 if ((TrueVal != LHS || FalseVal != RHS) &&
1822 (TrueVal != RHS || FalseVal != LHS))
1823 return false;
1824 typename CmpInst_t::Predicate Pred =
1825 LHS == TrueVal ? Cmp->getPredicate() : Cmp->getInversePredicate();
1826 // Does "(x pred y) ? x : y" represent the desired max/min operation?
1827 if (!Pred_t::match(Pred))
1828 return false;
1829 // It does! Bind the operands.
1830 return (L.match(LHS) && R.match(RHS)) ||
1831 (Commutable && L.match(RHS) && R.match(LHS));
1832 }
1833};
1834
1835/// Helper class for identifying signed max predicates.
1837 static bool match(ICmpInst::Predicate Pred) {
1838 return Pred == CmpInst::ICMP_SGT || Pred == CmpInst::ICMP_SGE;
1839 }
1840};
1841
1842/// Helper class for identifying signed min predicates.
1844 static bool match(ICmpInst::Predicate Pred) {
1845 return Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_SLE;
1846 }
1847};
1848
1849/// Helper class for identifying unsigned max predicates.
1851 static bool match(ICmpInst::Predicate Pred) {
1852 return Pred == CmpInst::ICMP_UGT || Pred == CmpInst::ICMP_UGE;
1853 }
1854};
1855
1856/// Helper class for identifying unsigned min predicates.
1858 static bool match(ICmpInst::Predicate Pred) {
1859 return Pred == CmpInst::ICMP_ULT || Pred == CmpInst::ICMP_ULE;
1860 }
1861};
1862
1863/// Helper class for identifying ordered max predicates.
1865 static bool match(FCmpInst::Predicate Pred) {
1866 return Pred == CmpInst::FCMP_OGT || Pred == CmpInst::FCMP_OGE;
1867 }
1868};
1869
1870/// Helper class for identifying ordered min predicates.
1872 static bool match(FCmpInst::Predicate Pred) {
1873 return Pred == CmpInst::FCMP_OLT || Pred == CmpInst::FCMP_OLE;
1874 }
1875};
1876
1877/// Helper class for identifying unordered max predicates.
1879 static bool match(FCmpInst::Predicate Pred) {
1880 return Pred == CmpInst::FCMP_UGT || Pred == CmpInst::FCMP_UGE;
1881 }
1882};
1883
1884/// Helper class for identifying unordered min predicates.
1886 static bool match(FCmpInst::Predicate Pred) {
1887 return Pred == CmpInst::FCMP_ULT || Pred == CmpInst::FCMP_ULE;
1888 }
1889};
1890
1891template <typename LHS, typename RHS>
1893 const RHS &R) {
1895}
1896
1897template <typename LHS, typename RHS>
1899 const RHS &R) {
1901}
1902
1903template <typename LHS, typename RHS>
1905 const RHS &R) {
1907}
1908
1909template <typename LHS, typename RHS>
1911 const RHS &R) {
1913}
1914
1915template <typename LHS, typename RHS>
1916inline match_combine_or<
1921m_MaxOrMin(const LHS &L, const RHS &R) {
1922 return m_CombineOr(m_CombineOr(m_SMax(L, R), m_SMin(L, R)),
1923 m_CombineOr(m_UMax(L, R), m_UMin(L, R)));
1924}
1925
1926/// Match an 'ordered' floating point maximum function.
1927/// Floating point has one special value 'NaN'. Therefore, there is no total
1928/// order. However, if we can ignore the 'NaN' value (for example, because of a
1929/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1930/// semantics. In the presence of 'NaN' we have to preserve the original
1931/// select(fcmp(ogt/ge, L, R), L, R) semantics matched by this predicate.
1932///
1933/// max(L, R) iff L and R are not NaN
1934/// m_OrdFMax(L, R) = R iff L or R are NaN
1935template <typename LHS, typename RHS>
1937 const RHS &R) {
1939}
1940
1941/// Match an 'ordered' floating point minimum function.
1942/// Floating point has one special value 'NaN'. Therefore, there is no total
1943/// order. However, if we can ignore the 'NaN' value (for example, because of a
1944/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1945/// semantics. In the presence of 'NaN' we have to preserve the original
1946/// select(fcmp(olt/le, L, R), L, R) semantics matched by this predicate.
1947///
1948/// min(L, R) iff L and R are not NaN
1949/// m_OrdFMin(L, R) = R iff L or R are NaN
1950template <typename LHS, typename RHS>
1952 const RHS &R) {
1954}
1955
1956/// Match an 'unordered' floating point maximum function.
1957/// Floating point has one special value 'NaN'. Therefore, there is no total
1958/// order. However, if we can ignore the 'NaN' value (for example, because of a
1959/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1960/// semantics. In the presence of 'NaN' we have to preserve the original
1961/// select(fcmp(ugt/ge, L, R), L, R) semantics matched by this predicate.
1962///
1963/// max(L, R) iff L and R are not NaN
1964/// m_UnordFMax(L, R) = L iff L or R are NaN
1965template <typename LHS, typename RHS>
1967m_UnordFMax(const LHS &L, const RHS &R) {
1969}
1970
1971/// Match an 'unordered' floating point minimum function.
1972/// Floating point has one special value 'NaN'. Therefore, there is no total
1973/// order. However, if we can ignore the 'NaN' value (for example, because of a
1974/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1975/// semantics. In the presence of 'NaN' we have to preserve the original
1976/// select(fcmp(ult/le, L, R), L, R) semantics matched by this predicate.
1977///
1978/// min(L, R) iff L and R are not NaN
1979/// m_UnordFMin(L, R) = L iff L or R are NaN
1980template <typename LHS, typename RHS>
1982m_UnordFMin(const LHS &L, const RHS &R) {
1984}
1985
1986//===----------------------------------------------------------------------===//
1987// Matchers for overflow check patterns: e.g. (a + b) u< a, (a ^ -1) <u b
1988// Note that S might be matched to other instructions than AddInst.
1989//
1990
1991template <typename LHS_t, typename RHS_t, typename Sum_t>
1995 Sum_t S;
1996
1997 UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
1998 : L(L), R(R), S(S) {}
1999
2000 template <typename OpTy> bool match(OpTy *V) {
2001 Value *ICmpLHS, *ICmpRHS;
2003 if (!m_ICmp(Pred, m_Value(ICmpLHS), m_Value(ICmpRHS)).match(V))
2004 return false;
2005
2006 Value *AddLHS, *AddRHS;
2007 auto AddExpr = m_Add(m_Value(AddLHS), m_Value(AddRHS));
2008
2009 // (a + b) u< a, (a + b) u< b
2010 if (Pred == ICmpInst::ICMP_ULT)
2011 if (AddExpr.match(ICmpLHS) && (ICmpRHS == AddLHS || ICmpRHS == AddRHS))
2012 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
2013
2014 // a >u (a + b), b >u (a + b)
2015 if (Pred == ICmpInst::ICMP_UGT)
2016 if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
2017 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
2018
2019 Value *Op1;
2020 auto XorExpr = m_OneUse(m_Xor(m_Value(Op1), m_AllOnes()));
2021 // (a ^ -1) <u b
2022 if (Pred == ICmpInst::ICMP_ULT) {
2023 if (XorExpr.match(ICmpLHS))
2024 return L.match(Op1) && R.match(ICmpRHS) && S.match(ICmpLHS);
2025 }
2026 // b > u (a ^ -1)
2027 if (Pred == ICmpInst::ICMP_UGT) {
2028 if (XorExpr.match(ICmpRHS))
2029 return L.match(Op1) && R.match(ICmpLHS) && S.match(ICmpRHS);
2030 }
2031
2032 // Match special-case for increment-by-1.
2033 if (Pred == ICmpInst::ICMP_EQ) {
2034 // (a + 1) == 0
2035 // (1 + a) == 0
2036 if (AddExpr.match(ICmpLHS) && m_ZeroInt().match(ICmpRHS) &&
2037 (m_One().match(AddLHS) || m_One().match(AddRHS)))
2038 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
2039 // 0 == (a + 1)
2040 // 0 == (1 + a)
2041 if (m_ZeroInt().match(ICmpLHS) && AddExpr.match(ICmpRHS) &&
2042 (m_One().match(AddLHS) || m_One().match(AddRHS)))
2043 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
2044 }
2045
2046 return false;
2047 }
2048};
2049
2050/// Match an icmp instruction checking for unsigned overflow on addition.
2051///
2052/// S is matched to the addition whose result is being checked for overflow, and
2053/// L and R are matched to the LHS and RHS of S.
2054template <typename LHS_t, typename RHS_t, typename Sum_t>
2056m_UAddWithOverflow(const LHS_t &L, const RHS_t &R, const Sum_t &S) {
2058}
2059
2060template <typename Opnd_t> struct Argument_match {
2061 unsigned OpI;
2062 Opnd_t Val;
2063
2064 Argument_match(unsigned OpIdx, const Opnd_t &V) : OpI(OpIdx), Val(V) {}
2065
2066 template <typename OpTy> bool match(OpTy *V) {
2067 // FIXME: Should likely be switched to use `CallBase`.
2068 if (const auto *CI = dyn_cast<CallInst>(V))
2069 return Val.match(CI->getArgOperand(OpI));
2070 return false;
2071 }
2072};
2073
2074/// Match an argument.
2075template <unsigned OpI, typename Opnd_t>
2076inline Argument_match<Opnd_t> m_Argument(const Opnd_t &Op) {
2077 return Argument_match<Opnd_t>(OpI, Op);
2078}
2079
2080/// Intrinsic matchers.
2082 unsigned ID;
2083
2085
2086 template <typename OpTy> bool match(OpTy *V) {
2087 if (const auto *CI = dyn_cast<CallInst>(V))
2088 if (const auto *F = CI->getCalledFunction())
2089 return F->getIntrinsicID() == ID;
2090 return false;
2091 }
2092};
2093
2094/// Intrinsic matches are combinations of ID matchers, and argument
2095/// matchers. Higher arity matcher are defined recursively in terms of and-ing
2096/// them with lower arity matchers. Here's some convenient typedefs for up to
2097/// several arguments, and more can be added as needed
2098template <typename T0 = void, typename T1 = void, typename T2 = void,
2099 typename T3 = void, typename T4 = void, typename T5 = void,
2100 typename T6 = void, typename T7 = void, typename T8 = void,
2101 typename T9 = void, typename T10 = void>
2103template <typename T0> struct m_Intrinsic_Ty<T0> {
2105};
2106template <typename T0, typename T1> struct m_Intrinsic_Ty<T0, T1> {
2107 using Ty =
2109};
2110template <typename T0, typename T1, typename T2>
2111struct m_Intrinsic_Ty<T0, T1, T2> {
2114};
2115template <typename T0, typename T1, typename T2, typename T3>
2116struct m_Intrinsic_Ty<T0, T1, T2, T3> {
2119};
2120
2121template <typename T0, typename T1, typename T2, typename T3, typename T4>
2122struct m_Intrinsic_Ty<T0, T1, T2, T3, T4> {
2125};
2126
2127template <typename T0, typename T1, typename T2, typename T3, typename T4,
2128 typename T5>
2129struct m_Intrinsic_Ty<T0, T1, T2, T3, T4, T5> {
2132};
2133
2134/// Match intrinsic calls like this:
2135/// m_Intrinsic<Intrinsic::fabs>(m_Value(X))
2136template <Intrinsic::ID IntrID> inline IntrinsicID_match m_Intrinsic() {
2137 return IntrinsicID_match(IntrID);
2138}
2139
2140/// Matches MaskedLoad Intrinsic.
2141template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2143m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2144 const Opnd3 &Op3) {
2145 return m_Intrinsic<Intrinsic::masked_load>(Op0, Op1, Op2, Op3);
2146}
2147
2148/// Matches MaskedGather Intrinsic.
2149template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2151m_MaskedGather(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2152 const Opnd3 &Op3) {
2153 return m_Intrinsic<Intrinsic::masked_gather>(Op0, Op1, Op2, Op3);
2154}
2155
2156template <Intrinsic::ID IntrID, typename T0>
2157inline typename m_Intrinsic_Ty<T0>::Ty m_Intrinsic(const T0 &Op0) {
2158 return m_CombineAnd(m_Intrinsic<IntrID>(), m_Argument<0>(Op0));
2159}
2160
2161template <Intrinsic::ID IntrID, typename T0, typename T1>
2162inline typename m_Intrinsic_Ty<T0, T1>::Ty m_Intrinsic(const T0 &Op0,
2163 const T1 &Op1) {
2164 return m_CombineAnd(m_Intrinsic<IntrID>(Op0), m_Argument<1>(Op1));
2165}
2166
2167template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2>
2168inline typename m_Intrinsic_Ty<T0, T1, T2>::Ty
2169m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2) {
2170 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1), m_Argument<2>(Op2));
2171}
2172
2173template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2174 typename T3>
2176m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3) {
2177 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2), m_Argument<3>(Op3));
2178}
2179
2180template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2181 typename T3, typename T4>
2183m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2184 const T4 &Op4) {
2185 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3),
2186 m_Argument<4>(Op4));
2187}
2188
2189template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2190 typename T3, typename T4, typename T5>
2192m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2193 const T4 &Op4, const T5 &Op5) {
2194 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3, Op4),
2195 m_Argument<5>(Op5));
2196}
2197
2198// Helper intrinsic matching specializations.
2199template <typename Opnd0>
2200inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BitReverse(const Opnd0 &Op0) {
2201 return m_Intrinsic<Intrinsic::bitreverse>(Op0);
2202}
2203
2204template <typename Opnd0>
2205inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BSwap(const Opnd0 &Op0) {
2206 return m_Intrinsic<Intrinsic::bswap>(Op0);
2207}
2208
2209template <typename Opnd0>
2210inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FAbs(const Opnd0 &Op0) {
2211 return m_Intrinsic<Intrinsic::fabs>(Op0);
2212}
2213
2214template <typename Opnd0>
2215inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FCanonicalize(const Opnd0 &Op0) {
2216 return m_Intrinsic<Intrinsic::canonicalize>(Op0);
2217}
2218
2219template <typename Opnd0, typename Opnd1>
2220inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMin(const Opnd0 &Op0,
2221 const Opnd1 &Op1) {
2222 return m_Intrinsic<Intrinsic::minnum>(Op0, Op1);
2223}
2224
2225template <typename Opnd0, typename Opnd1>
2226inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMax(const Opnd0 &Op0,
2227 const Opnd1 &Op1) {
2228 return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
2229}
2230
2231template <typename Opnd0, typename Opnd1, typename Opnd2>
2233m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2234 return m_Intrinsic<Intrinsic::fshl>(Op0, Op1, Op2);
2235}
2236
2237template <typename Opnd0, typename Opnd1, typename Opnd2>
2239m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2240 return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
2241}
2242
2243template <typename Opnd0>
2244inline typename m_Intrinsic_Ty<Opnd0>::Ty m_Sqrt(const Opnd0 &Op0) {
2245 return m_Intrinsic<Intrinsic::sqrt>(Op0);
2246}
2247
2248template <typename Opnd0, typename Opnd1>
2249inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_CopySign(const Opnd0 &Op0,
2250 const Opnd1 &Op1) {
2251 return m_Intrinsic<Intrinsic::copysign>(Op0, Op1);
2252}
2253
2254template <typename Opnd0>
2255inline typename m_Intrinsic_Ty<Opnd0>::Ty m_VecReverse(const Opnd0 &Op0) {
2256 return m_Intrinsic<Intrinsic::experimental_vector_reverse>(Op0);
2257}
2258
2259//===----------------------------------------------------------------------===//
2260// Matchers for two-operands operators with the operators in either order
2261//
2262
2263/// Matches a BinaryOperator with LHS and RHS in either order.
2264template <typename LHS, typename RHS>
2267}
2268
2269/// Matches an ICmp with a predicate over LHS and RHS in either order.
2270/// Swaps the predicate if operands are commuted.
2271template <typename LHS, typename RHS>
2273m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
2275 R);
2276}
2277
2278/// Matches a specific opcode with LHS and RHS in either order.
2279template <typename LHS, typename RHS>
2281m_c_BinOp(unsigned Opcode, const LHS &L, const RHS &R) {
2283}
2284
2285/// Matches a Add with LHS and RHS in either order.
2286template <typename LHS, typename RHS>
2288 const RHS &R) {
2290}
2291
2292/// Matches a Mul with LHS and RHS in either order.
2293template <typename LHS, typename RHS>
2295 const RHS &R) {
2297}
2298
2299/// Matches an And with LHS and RHS in either order.
2300template <typename LHS, typename RHS>
2302 const RHS &R) {
2304}
2305
2306/// Matches an Or with LHS and RHS in either order.
2307template <typename LHS, typename RHS>
2309 const RHS &R) {
2311}
2312
2313/// Matches an Xor with LHS and RHS in either order.
2314template <typename LHS, typename RHS>
2316 const RHS &R) {
2318}
2319
2320/// Matches a 'Neg' as 'sub 0, V'.
2321template <typename ValTy>
2322inline BinaryOp_match<cst_pred_ty<is_zero_int>, ValTy, Instruction::Sub>
2323m_Neg(const ValTy &V) {
2324 return m_Sub(m_ZeroInt(), V);
2325}
2326
2327/// Matches a 'Neg' as 'sub nsw 0, V'.
2328template <typename ValTy>
2330 Instruction::Sub,
2332m_NSWNeg(const ValTy &V) {
2333 return m_NSWSub(m_ZeroInt(), V);
2334}
2335
2336/// Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
2337/// NOTE: we first match the 'Not' (by matching '-1'),
2338/// and only then match the inner matcher!
2339template <typename ValTy>
2340inline BinaryOp_match<cst_pred_ty<is_all_ones>, ValTy, Instruction::Xor, true>
2341m_Not(const ValTy &V) {
2342 return m_c_Xor(m_AllOnes(), V);
2343}
2344
2345template <typename ValTy> struct NotForbidUndef_match {
2346 ValTy Val;
2347 NotForbidUndef_match(const ValTy &V) : Val(V) {}
2348
2349 template <typename OpTy> bool match(OpTy *V) {
2350 // We do not use m_c_Xor because that could match an arbitrary APInt that is
2351 // not -1 as C and then fail to match the other operand if it is -1.
2352 // This code should still work even when both operands are constants.
2353 Value *X;
2354 const APInt *C;
2355 if (m_Xor(m_Value(X), m_APIntForbidUndef(C)).match(V) && C->isAllOnes())
2356 return Val.match(X);
2357 if (m_Xor(m_APIntForbidUndef(C), m_Value(X)).match(V) && C->isAllOnes())
2358 return Val.match(X);
2359 return false;
2360 }
2361};
2362
2363/// Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'. For vectors, the
2364/// constant value must be composed of only -1 scalar elements.
2365template <typename ValTy>
2368}
2369
2370/// Matches an SMin with LHS and RHS in either order.
2371template <typename LHS, typename RHS>
2373m_c_SMin(const LHS &L, const RHS &R) {
2375}
2376/// Matches an SMax with LHS and RHS in either order.
2377template <typename LHS, typename RHS>
2379m_c_SMax(const LHS &L, const RHS &R) {
2381}
2382/// Matches a UMin with LHS and RHS in either order.
2383template <typename LHS, typename RHS>
2385m_c_UMin(const LHS &L, const RHS &R) {
2387}
2388/// Matches a UMax with LHS and RHS in either order.
2389template <typename LHS, typename RHS>
2391m_c_UMax(const LHS &L, const RHS &R) {
2393}
2394
2395template <typename LHS, typename RHS>
2396inline match_combine_or<
2401m_c_MaxOrMin(const LHS &L, const RHS &R) {
2402 return m_CombineOr(m_CombineOr(m_c_SMax(L, R), m_c_SMin(L, R)),
2403 m_CombineOr(m_c_UMax(L, R), m_c_UMin(L, R)));
2404}
2405
2406template <Intrinsic::ID IntrID, typename T0, typename T1>
2409m_c_Intrinsic(const T0 &Op0, const T1 &Op1) {
2410 return m_CombineOr(m_Intrinsic<IntrID>(Op0, Op1),
2411 m_Intrinsic<IntrID>(Op1, Op0));
2412}
2413
2414/// Matches FAdd with LHS and RHS in either order.
2415template <typename LHS, typename RHS>
2417m_c_FAdd(const LHS &L, const RHS &R) {
2419}
2420
2421/// Matches FMul with LHS and RHS in either order.
2422template <typename LHS, typename RHS>
2424m_c_FMul(const LHS &L, const RHS &R) {
2426}
2427
2428template <typename Opnd_t> struct Signum_match {
2429 Opnd_t Val;
2430 Signum_match(const Opnd_t &V) : Val(V) {}
2431
2432 template <typename OpTy> bool match(OpTy *V) {
2433 unsigned TypeSize = V->getType()->getScalarSizeInBits();
2434 if (TypeSize == 0)
2435 return false;
2436
2437 unsigned ShiftWidth = TypeSize - 1;
2438 Value *OpL = nullptr, *OpR = nullptr;
2439
2440 // This is the representation of signum we match:
2441 //
2442 // signum(x) == (x >> 63) | (-x >>u 63)
2443 //
2444 // An i1 value is its own signum, so it's correct to match
2445 //
2446 // signum(x) == (x >> 0) | (-x >>u 0)
2447 //
2448 // for i1 values.
2449
2450 auto LHS = m_AShr(m_Value(OpL), m_SpecificInt(ShiftWidth));
2451 auto RHS = m_LShr(m_Neg(m_Value(OpR)), m_SpecificInt(ShiftWidth));
2452 auto Signum = m_Or(LHS, RHS);
2453
2454 return Signum.match(V) && OpL == OpR && Val.match(OpL);
2455 }
2456};
2457
2458/// Matches a signum pattern.
2459///
2460/// signum(x) =
2461/// x > 0 -> 1
2462/// x == 0 -> 0
2463/// x < 0 -> -1
2464template <typename Val_t> inline Signum_match<Val_t> m_Signum(const Val_t &V) {
2465 return Signum_match<Val_t>(V);
2466}
2467
2468template <int Ind, typename Opnd_t> struct ExtractValue_match {
2469 Opnd_t Val;
2470 ExtractValue_match(const Opnd_t &V) : Val(V) {}
2471
2472 template <typename OpTy> bool match(OpTy *V) {
2473 if (auto *I = dyn_cast<ExtractValueInst>(V)) {
2474 // If Ind is -1, don't inspect indices
2475 if (Ind != -1 &&
2476 !(I->getNumIndices() == 1 && I->getIndices()[0] == (unsigned)Ind))
2477 return false;
2478 return Val.match(I->getAggregateOperand());
2479 }
2480 return false;
2481 }
2482};
2483
2484/// Match a single index ExtractValue instruction.
2485/// For example m_ExtractValue<1>(...)
2486template <int Ind, typename Val_t>
2489}
2490
2491/// Match an ExtractValue instruction with any index.
2492/// For example m_ExtractValue(...)
2493template <typename Val_t>
2494inline ExtractValue_match<-1, Val_t> m_ExtractValue(const Val_t &V) {
2495 return ExtractValue_match<-1, Val_t>(V);
2496}
2497
2498/// Matcher for a single index InsertValue instruction.
2499template <int Ind, typename T0, typename T1> struct InsertValue_match {
2502
2503 InsertValue_match(const T0 &Op0, const T1 &Op1) : Op0(Op0), Op1(Op1) {}
2504
2505 template <typename OpTy> bool match(OpTy *V) {
2506 if (auto *I = dyn_cast<InsertValueInst>(V)) {
2507 return Op0.match(I->getOperand(0)) && Op1.match(I->getOperand(1)) &&
2508 I->getNumIndices() == 1 && Ind == I->getIndices()[0];
2509 }
2510 return false;
2511 }
2512};
2513
2514/// Matches a single index InsertValue instruction.
2515template <int Ind, typename Val_t, typename Elt_t>
2517 const Elt_t &Elt) {
2518 return InsertValue_match<Ind, Val_t, Elt_t>(Val, Elt);
2519}
2520
2521/// Matches patterns for `vscale`. This can either be a call to `llvm.vscale` or
2522/// the constant expression
2523/// `ptrtoint(gep <vscale x 1 x i8>, <vscale x 1 x i8>* null, i32 1>`
2524/// under the right conditions determined by DataLayout.
2526 template <typename ITy> bool match(ITy *V) {
2527 if (m_Intrinsic<Intrinsic::vscale>().match(V))
2528 return true;
2529
2530 Value *Ptr;
2531 if (m_PtrToInt(m_Value(Ptr)).match(V)) {
2532 if (auto *GEP = dyn_cast<GEPOperator>(Ptr)) {
2533 auto *DerefTy =
2534 dyn_cast<ScalableVectorType>(GEP->getSourceElementType());
2535 if (GEP->getNumIndices() == 1 && DerefTy &&
2536 DerefTy->getElementType()->isIntegerTy(8) &&
2537 m_Zero().match(GEP->getPointerOperand()) &&
2538 m_SpecificInt(1).match(GEP->idx_begin()->get()))
2539 return true;
2540 }
2541 }
2542
2543 return false;
2544 }
2545};
2546
2548 return VScaleVal_match();
2549}
2550
2551template <typename LHS, typename RHS, unsigned Opcode, bool Commutable = false>
2555
2556 LogicalOp_match(const LHS &L, const RHS &R) : L(L), R(R) {}
2557
2558 template <typename T> bool match(T *V) {
2559 auto *I = dyn_cast<Instruction>(V);
2560 if (!I || !I->getType()->isIntOrIntVectorTy(1))
2561 return false;
2562
2563 if (I->getOpcode() == Opcode) {
2564 auto *Op0 = I->getOperand(0);
2565 auto *Op1 = I->getOperand(1);
2566 return (L.match(Op0) && R.match(Op1)) ||
2567 (Commutable && L.match(Op1) && R.match(Op0));
2568 }
2569
2570 if (auto *Select = dyn_cast<SelectInst>(I)) {
2571 auto *Cond = Select->getCondition();
2572 auto *TVal = Select->getTrueValue();
2573 auto *FVal = Select->getFalseValue();
2574
2575 // Don't match a scalar select of bool vectors.
2576 // Transforms expect a single type for operands if this matches.
2577 if (Cond->getType() != Select->getType())
2578 return false;
2579
2580 if (Opcode == Instruction::And) {
2581 auto *C = dyn_cast<Constant>(FVal);
2582 if (C && C->isNullValue())
2583 return (L.match(Cond) && R.match(TVal)) ||
2584 (Commutable && L.match(TVal) && R.match(Cond));
2585 } else {
2586 assert(Opcode == Instruction::Or);
2587 auto *C = dyn_cast<Constant>(TVal);
2588 if (C && C->isOneValue())
2589 return (L.match(Cond) && R.match(FVal)) ||
2590 (Commutable && L.match(FVal) && R.match(Cond));
2591 }
2592 }
2593
2594 return false;
2595 }
2596};
2597
2598/// Matches L && R either in the form of L & R or L ? R : false.
2599/// Note that the latter form is poison-blocking.
2600template <typename LHS, typename RHS>
2602 const RHS &R) {
2604}
2605
2606/// Matches L && R where L and R are arbitrary values.
2607inline auto m_LogicalAnd() { return m_LogicalAnd(m_Value(), m_Value()); }
2608
2609/// Matches L && R with LHS and RHS in either order.
2610template <typename LHS, typename RHS>
2612m_c_LogicalAnd(const LHS &L, const RHS &R) {
2614}
2615
2616/// Matches L || R either in the form of L | R or L ? true : R.
2617/// Note that the latter form is poison-blocking.
2618template <typename LHS, typename RHS>
2620 const RHS &R) {
2622}
2623
2624/// Matches L || R where L and R are arbitrary values.
2625inline auto m_LogicalOr() { return m_LogicalOr(m_Value(), m_Value()); }
2626
2627/// Matches L || R with LHS and RHS in either order.
2628template <typename LHS, typename RHS>
2630m_c_LogicalOr(const LHS &L, const RHS &R) {
2632}
2633
2634/// Matches either L && R or L || R,
2635/// either one being in the either binary or logical form.
2636/// Note that the latter form is poison-blocking.
2637template <typename LHS, typename RHS, bool Commutable = false>
2638inline auto m_LogicalOp(const LHS &L, const RHS &R) {
2639 return m_CombineOr(
2642}
2643
2644/// Matches either L && R or L || R where L and R are arbitrary values.
2645inline auto m_LogicalOp() { return m_LogicalOp(m_Value(), m_Value()); }
2646
2647/// Matches either L && R or L || R with LHS and RHS in either order.
2648template <typename LHS, typename RHS>
2649inline auto m_c_LogicalOp(const LHS &L, const RHS &R) {
2650 return m_LogicalOp<LHS, RHS, /*Commutable=*/true>(L, R);
2651}
2652
2653} // end namespace PatternMatch
2654} // end namespace llvm
2655
2656#endif // LLVM_IR_PATTERNMATCH_H
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
amdgpu AMDGPU Register Bank Select
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
#define check(cond)
Hexagon Common GEP
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define T1
#define P(N)
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * RHS
Value * LHS
static constexpr uint32_t Opcode
Definition: aarch32.h:200
Class for arbitrary precision integers.
Definition: APInt.h:76
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:531
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:748
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:777
@ ICMP_SLE
signed less or equal
Definition: InstrTypes.h:778
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:754
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:763
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:752
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:753
@ ICMP_UGE
unsigned greater or equal
Definition: InstrTypes.h:772
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:771
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:775
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:762
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:773
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:760
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:755
@ ICMP_EQ
equal
Definition: InstrTypes.h:769
@ ICMP_SGE
signed greater or equal
Definition: InstrTypes.h:776
@ ICMP_ULE
unsigned less or equal
Definition: InstrTypes.h:774
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:761
Base class for aggregate constants (with operands).
Definition: Constants.h:384
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:1002
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:260
This is the shared class of boolean and integer constants.
Definition: Constants.h:78
This is an important base class in LLVM.
Definition: Constant.h:41
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
Definition: DataLayout.h:672
static bool compare(const APInt &LHS, const APInt &RHS, ICmpInst::Predicate Pred)
Return result of LHS Pred RHS comparison.
bool isBitwiseLogicOp() const
Return true if this is and/or/xor.
Definition: Instruction.h:288
bool isShift() const
Definition: Instruction.h:241
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:366
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:451
bool empty() const
Definition: SmallVector.h:94
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:941
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
LLVM Value Representation.
Definition: Value.h:74
Represents an op.with.overflow intrinsic.
#define UINT64_MAX
Definition: DataTypes.h:77
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
TwoOps_match< ValueOpTy, PointerOpTy, Instruction::Store > m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp)
Matches StoreInst.
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set.
Definition: PatternMatch.h:461
class_match< PoisonValue > m_Poison()
Match an arbitrary poison constant.
Definition: PatternMatch.h:139
cst_pred_ty< is_lowbit_mask > m_LowBitMask()
Match an integer or vector with only the low bit(s) set.
Definition: PatternMatch.h:593
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
specific_intval< false > m_SpecificInt(APInt V)
Match a specific integer value or vector with all elements equal to the value.
Definition: PatternMatch.h:862
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
Definition: PatternMatch.h:483
MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > m_UnordFMin(const LHS &L, const RHS &R)
Match an 'unordered' floating point minimum function.
PtrToIntSameSize_match< OpTy > m_PtrToIntSameSize(const DataLayout &DL, const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:982
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
Definition: PatternMatch.h:84
apfloat_match m_APFloatAllowUndef(const APFloat *&Res)
Match APFloat while allowing undefs in splat vector constants.
Definition: PatternMatch.h:301
m_Intrinsic_Ty< Opnd0 >::Ty m_FCanonicalize(const Opnd0 &Op0)
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.
cst_pred_ty< is_sign_mask > m_SignMask()
Match an integer or vector with only the sign bit(s) set.
Definition: PatternMatch.h:584
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
cstfp_pred_ty< is_inf > m_Inf()
Match a positive or negative infinity FP constant.
Definition: PatternMatch.h:634
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse(const Opnd0 &Op0)
apint_match m_APIntAllowUndef(const APInt *&Res)
Match APInt while allowing undefs in splat vector constants.
Definition: PatternMatch.h:284
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(const LHS &L, const RHS &R)
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
Definition: PatternMatch.h:552
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'.
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
auto m_LogicalOp()
Matches either L && R or L || R where L and R are arbitrary values.
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
Definition: PatternMatch.h:144
OneOps_match< OpTy, Instruction::Freeze > m_Freeze(const OpTy &Op)
Matches FreezeInst.
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.
cst_pred_ty< is_power2_or_zero > m_Power2OrZero()
Match an integer or vector of 0 or power-of-2 values.
Definition: PatternMatch.h:572
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
br_match m_UnconditionalBr(BasicBlock *&Succ)
CastInst_match< OpTy, Instruction::FPTrunc > m_FPTrunc(const OpTy &Op)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul(const LHS &L, const RHS &R)
CastInst_match< OpTy, Instruction::FPToSI > m_FPToSI(const OpTy &Op)
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
BinOpPred_match< LHS, RHS, is_idiv_op > m_IDiv(const LHS &L, const RHS &R)
Matches integer division operations.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMax(const Opnd0 &Op0, const Opnd1 &Op1)
cst_pred_ty< is_shifted_mask > m_ShiftedMask()
Definition: PatternMatch.h:452
bind_ty< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
Definition: PatternMatch.h:724
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
Definition: PatternMatch.h:672
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:780
constantexpr_match m_ConstantExpr()
Match a constant expression or a constant that contains a constant expression.
Definition: PatternMatch.h:165
BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)
Matches logical shift operations.
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'.
TwoOps_match< Val_t, Idx_t, Instruction::ExtractElement > m_ExtractElt(const Val_t &Val, const Idx_t &Idx)
Matches ExtractElementInst.
cstfp_pred_ty< is_finite > m_Finite()
Match a finite FP constant, i.e.
Definition: PatternMatch.h:650
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
Definition: PatternMatch.h:493
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:147
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:525
IntrinsicID_match m_Intrinsic()
Match intrinsic calls like this: m_Intrinsic<Intrinsic::fabs>(m_Value(X))
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
cstfp_pred_ty< is_neg_zero_fp > m_NegZeroFP()
Match a floating-point negative zero.
Definition: PatternMatch.h:690
CastInst_match< OpTy, Instruction::UIToFP > m_UIToFP(const OpTy &Op)
InsertValue_match< Ind, Val_t, Elt_t > m_InsertValue(const Val_t &Val, const Elt_t &Elt)
Matches a single index InsertValue instruction.
specific_fpval m_SpecificFP(double V)
Match a specific floating point value or vector with all elements equal to the value.
Definition: PatternMatch.h:823
ExtractValue_match< Ind, Val_t > m_ExtractValue(const Val_t &V)
Match a single index ExtractValue instruction.
BinOpPred_match< LHS, RHS, is_logical_shift_op > m_LogicalShift(const LHS &L, const RHS &R)
Matches logical shift operations.
match_combine_and< LTy, RTy > m_CombineAnd(const LTy &L, const RTy &R)
Combine two pattern matchers matching L && R.
Definition: PatternMatch.h:224
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)
CastInst_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
cst_pred_ty< is_any_apint > m_AnyIntegralConstant()
Match an integer or vector with any integral constant.
Definition: PatternMatch.h:444
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R)
match_combine_or< match_combine_or< CastInst_match< OpTy, Instruction::ZExt >, CastInst_match< OpTy, Instruction::SExt > >, OpTy > m_ZExtOrSExtOrSelf(const OpTy &Op)
CastOperator_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
m_Intrinsic_Ty< Opnd0 >::Ty m_Sqrt(const Opnd0 &Op0)
bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
Definition: PatternMatch.h:730
CastInst_match< OpTy, Instruction::FPExt > m_FPExt(const OpTy &Op)
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.
BinaryOp_match< LHS, RHS, Instruction::FAdd > m_FAdd(const LHS &L, const RHS &R)
Definition: PatternMatch.h:988
match_combine_or< typename m_Intrinsic_Ty< T0, T1 >::Ty, typename m_Intrinsic_Ty< T1, T0 >::Ty > m_c_Intrinsic(const T0 &Op0, const T1 &Op1)
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
deferredval_ty< Value > m_Deferred(Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match()...
Definition: PatternMatch.h:798
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
Definition: PatternMatch.h:532
CastInst_match< OpTy, Instruction::SExt > m_SExt(const OpTy &Op)
Matches SExt.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
OneUse_match< T > m_OneUse(const T &SubPattern)
Definition: PatternMatch.h:67
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.
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
Definition: PatternMatch.h:759
specific_bbval m_SpecificBB(BasicBlock *BB)
Match a specific basic block value.
Definition: PatternMatch.h:895
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.
apint_match m_APIntForbidUndef(const APInt *&Res)
Match APInt while forbidding undefs in splat vector constants.
Definition: PatternMatch.h:289
cst_pred_ty< is_strictlypositive > m_StrictlyPositive()
Match an integer or vector of strictly positive values.
Definition: PatternMatch.h:503
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > m_NSWShl(const LHS &L, const RHS &R)
class_match< ConstantFP > m_ConstantFP()
Match an arbitrary ConstantFP and ignore it.
Definition: PatternMatch.h:152
cstfp_pred_ty< is_nonnan > m_NonNaN()
Match a non-NaN FP constant.
Definition: PatternMatch.h:625
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.
OneOps_match< OpTy, Instruction::Load > m_Load(const OpTy &Op)
Matches LoadInst.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
CastInst_match< OpTy, Instruction::SIToFP > m_SIToFP(const OpTy &Op)
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
class_match< CmpInst > m_Cmp()
Matches any compare instruction and ignore it.
Definition: PatternMatch.h:89
match_combine_or< CastInst_match< OpTy, Instruction::ZExt >, CastInst_match< OpTy, Instruction::SExt > > m_ZExtOrSExt(const OpTy &Op)
brc_match< Cond_t, bind_ty< BasicBlock >, bind_ty< BasicBlock > > m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F)
cst_pred_ty< is_negated_power2 > m_NegatedPower2()
Match a integer or vector negated power-of-2.
Definition: PatternMatch.h:560
auto m_c_LogicalOp(const LHS &L, const RHS &R)
Matches either L && R or L || R with LHS and RHS in either order.
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.
specific_fpval m_FPOne()
Match a float 1.0 or vector with all elements equal to 1.0.
Definition: PatternMatch.h:826
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.
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.
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.
CastOperator_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
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)
MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > m_UnordFMax(const LHS &L, const RHS &R)
Match an 'unordered' floating point maximum function.
match_combine_or< CastOperator_match< OpTy, Instruction::Trunc >, OpTy > m_TruncOrSelf(const OpTy &Op)
cstfp_pred_ty< is_finitenonzero > m_FiniteNonZero()
Match a finite non-zero FP constant.
Definition: PatternMatch.h:660
class_match< UnaryOperator > m_UnOp()
Match an arbitrary unary operation and ignore it.
Definition: PatternMatch.h:79
VScaleVal_match m_VScale()
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
specific_intval< true > m_SpecificIntAllowUndef(APInt V)
Definition: PatternMatch.h:870
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWSub(const LHS &L, const RHS &R)
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)
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
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:471
MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty > m_OrdFMax(const LHS &L, const RHS &R)
Match an 'ordered' floating point maximum function.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:76
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
Signum_match< Val_t > m_Signum(const Val_t &V)
Matches a signum pattern.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
Argument_match< Opnd_t > m_Argument(const Opnd_t &Op)
Match an argument.
Exact_match< T > m_Exact(const T &SubPattern)
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
BinOpPred_match< LHS, RHS, is_shift_op > m_Shift(const LHS &L, const RHS &R)
Matches shift operations.
cstfp_pred_ty< is_pos_zero_fp > m_PosZeroFP()
Match a floating-point positive zero.
Definition: PatternMatch.h:681
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.
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.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
cstfp_pred_ty< is_non_zero_fp > m_NonZeroFP()
Match a floating-point non-zero.
Definition: PatternMatch.h:699
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.
BinaryOp_match< LHS, RHS, Instruction::FDiv > m_FDiv(const LHS &L, const RHS &R)
NotForbidUndef_match< ValTy > m_NotForbidUndef(const ValTy &V)
Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'.
m_Intrinsic_Ty< Opnd0 >::Ty m_VecReverse(const Opnd0 &Op0)
BinOpPred_match< LHS, RHS, is_irem_op > m_IRem(const LHS &L, const RHS &R)
Matches integer remainder operations.
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
apfloat_match m_APFloatForbidUndef(const APFloat *&Res)
Match APFloat while forbidding undefs in splat vector constants.
Definition: PatternMatch.h:306
auto m_LogicalAnd()
Matches L && R where L and R are arbitrary values.
MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty > m_OrdFMin(const LHS &L, const RHS &R)
Match an 'ordered' floating point minimum function.
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)
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
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.: m_SelectCst<-1, 0>(m_Value(V))
BinaryOp_match< LHS, RHS, Instruction::FRem > m_FRem(const LHS &L, const RHS &R)
class_match< BasicBlock > m_BasicBlock()
Match an arbitrary basic block value and ignore it.
Definition: PatternMatch.h:168
CastInst_match< OpTy, Instruction::FPToUI > m_FPToUI(const OpTy &Op)
match_combine_or< CastInst_match< OpTy, Instruction::SExt >, OpTy > m_SExtOrSelf(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
auto m_Undef()
Match an arbitrary undef constant.
Definition: PatternMatch.h:136
cst_pred_ty< is_nonpositive > m_NonPositive()
Match an integer or vector of non-positive values.
Definition: PatternMatch.h:515
cstfp_pred_ty< is_nan > m_NaN()
Match an arbitrary NaN constant.
Definition: PatternMatch.h:618
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMin(const Opnd0 &Op0, const Opnd1 &Op1)
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
m_Intrinsic_Ty< Opnd0 >::Ty m_BSwap(const Opnd0 &Op0)
match_combine_or< CastInst_match< OpTy, Instruction::ZExt >, OpTy > m_ZExtOrSelf(const OpTy &Op)
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
Definition: PatternMatch.h:545
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.
CastOperator_match< OpTy, Instruction::IntToPtr > m_IntToPtr(const OpTy &Op)
Matches IntToPtr.
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
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.
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.
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
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.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_CopySign(const Opnd0 &Op0, const Opnd1 &Op1)
CastOperator_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > m_NSWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:994
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)
cstfp_pred_ty< is_noninf > m_NonInf()
Match a non-infinity FP constant, i.e.
Definition: PatternMatch.h:641
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.
match_unless< Ty > m_Unless(const Ty &M)
Match if the inner matcher does NOT match.
Definition: PatternMatch.h:182
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
Definition: PatternMatch.h:218
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:606
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
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:1726
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
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:1853
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:1753
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:918
Argument_match(unsigned OpIdx, const Opnd_t &V)
BinOpPred_match(const LHS_t &LHS, const RHS_t &RHS)
BinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:966
bool match(unsigned Opc, OpTy *V)
Definition: PatternMatch.h:968
CastInst_match(const Op_t &OpMatch)
CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
Exact_match(const SubPattern_t &SP)
Matcher for a single index InsertValue instruction.
InsertValue_match(const T0 &Op0, const T1 &Op1)
IntrinsicID_match(Intrinsic::ID IntrID)
LogicalOp_match(const LHS &L, const RHS &R)
MaxMin_match(const LHS_t &LHS, const RHS_t &RHS)
Matches instructions with Opcode and three operands.
OneUse_match(const SubPattern_t &SP)
Definition: PatternMatch.h:60
OverflowingBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
PtrToIntSameSize_match(const DataLayout &DL, const Op_t &OpMatch)
Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
SpecificBinaryOp_match(unsigned Opcode, const LHS_t &LHS, const RHS_t &RHS)
Matches instructions with Opcode and three operands.
ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
Matches instructions with Opcode and three operands.
TwoOps_match(const T0 &Op1, const T1 &Op2)
UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
Matches patterns for vscale.
This helper class is used to match scalar and vector constants that satisfy a specified predicate,...
Definition: PatternMatch.h:406
apf_pred_ty(const APFloat *&R)
Definition: PatternMatch.h:409
apfloat_match(const APFloat *&Res, bool AllowUndef)
Definition: PatternMatch.h:257
This helper class is used to match scalar and vector constants that satisfy a specified predicate,...
Definition: PatternMatch.h:380
apint_match(const APInt *&Res, bool AllowUndef)
Definition: PatternMatch.h:232
br_match(BasicBlock *&Succ)
brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
This helper class is used to match constant scalars, vector splats, and fixed width vectors that sati...
Definition: PatternMatch.h:334
Stores a reference to the Value *, not the Value * itself, thus can be used in commutative matchers.
Definition: PatternMatch.h:784
bool isValue(const APInt &C)
Definition: PatternMatch.h:457
bool isValue(const APInt &C)
Definition: PatternMatch.h:440
bool isValue(const APFloat &C)
Definition: PatternMatch.h:668
bool isValue(const APFloat &C)
Definition: PatternMatch.h:646
bool isValue(const APFloat &C)
Definition: PatternMatch.h:656
bool isOpType(unsigned Opcode)
bool isValue(const APFloat &C)
Definition: PatternMatch.h:630
bool isOpType(unsigned Opcode)
bool isValue(const APFloat &C)
Definition: PatternMatch.h:614
bool isValue(const APFloat &C)
Definition: PatternMatch.h:686
bool isValue(const APInt &C)
Definition: PatternMatch.h:479
bool isValue(const APFloat &C)
Definition: PatternMatch.h:695
bool isValue(const APFloat &C)
Definition: PatternMatch.h:637
bool isValue(const APFloat &C)
Definition: PatternMatch.h:621
bool isValue(const APInt &C)
Definition: PatternMatch.h:521
bool isValue(const APFloat &C)
Definition: PatternMatch.h:677
bool isValue(const APInt &C)
Definition: PatternMatch.h:548
bool isOpType(unsigned Opcode)
bool isValue(const APInt &C)
Definition: PatternMatch.h:580
bool isValue(const APInt &C)
Definition: PatternMatch.h:528
Intrinsic matches are combinations of ID matchers, and argument matchers.
bool match(ArrayRef< int > Mask)
ArrayRef< int > & MaskRef
m_Mask(ArrayRef< int > &MaskRef)
bool match(ArrayRef< int > Mask)
m_SpecificMask(ArrayRef< int > &MaskRef)
bool match(ArrayRef< int > Mask)
bool match(ArrayRef< int > Mask)
match_combine_and(const LTy &Left, const RTy &Right)
Definition: PatternMatch.h:206
match_combine_or(const LTy &Left, const RTy &Right)
Definition: PatternMatch.h:191
match_unless(const Ty &Matcher)
Definition: PatternMatch.h:176
Helper class for identifying ordered max predicates.
static bool match(FCmpInst::Predicate Pred)
Helper class for identifying ordered min predicates.
static bool match(FCmpInst::Predicate Pred)
Helper class for identifying signed max predicates.
static bool match(ICmpInst::Predicate Pred)
Helper class for identifying signed min predicates.
static bool match(ICmpInst::Predicate Pred)
Match a specified basic block value.
Definition: PatternMatch.h:883
Match a specified floating point value or vector of all elements of that value.
Definition: PatternMatch.h:805
Match a specified integer value or vector of all elements of that value.
Definition: PatternMatch.h:845
Match a specified Value*.
Definition: PatternMatch.h:771
Helper class for identifying unordered max predicates.
static bool match(FCmpInst::Predicate Pred)
Helper class for identifying unordered min predicates.
static bool match(FCmpInst::Predicate Pred)
Helper class for identifying unsigned max predicates.
static bool match(ICmpInst::Predicate Pred)
Helper class for identifying unsigned min predicates.
static bool match(ICmpInst::Predicate Pred)
static bool check(const Value *V)
Definition: PatternMatch.h:92