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
1242template <typename LHS, typename RHS>
1246
1247 DisjointOr_match(const LHS &L, const RHS &R) : L(L), R(R) {}
1248
1249 template <typename OpTy> bool match(OpTy *V) {
1250 if (auto *PDI = dyn_cast<PossiblyDisjointInst>(V)) {
1251 assert(PDI->getOpcode() == Instruction::Or && "Only or can be disjoint");
1252 if (!PDI->isDisjoint())
1253 return false;
1254 return L.match(PDI->getOperand(0)) && R.match(PDI->getOperand(1));
1255 }
1256 return false;
1257 }
1258};
1259
1260template <typename LHS, typename RHS>
1262 return DisjointOr_match<LHS, RHS>(L, R);
1263}
1264
1265//===----------------------------------------------------------------------===//
1266// Class that matches a group of binary opcodes.
1267//
1268template <typename LHS_t, typename RHS_t, typename Predicate>
1269struct BinOpPred_match : Predicate {
1272
1273 BinOpPred_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1274
1275 template <typename OpTy> bool match(OpTy *V) {
1276 if (auto *I = dyn_cast<Instruction>(V))
1277 return this->isOpType(I->getOpcode()) && L.match(I->getOperand(0)) &&
1278 R.match(I->getOperand(1));
1279 return false;
1280 }
1281};
1282
1284 bool isOpType(unsigned Opcode) { return Instruction::isShift(Opcode); }
1285};
1286
1288 bool isOpType(unsigned Opcode) {
1289 return Opcode == Instruction::LShr || Opcode == Instruction::AShr;
1290 }
1291};
1292
1294 bool isOpType(unsigned Opcode) {
1295 return Opcode == Instruction::LShr || Opcode == Instruction::Shl;
1296 }
1297};
1298
1300 bool isOpType(unsigned Opcode) {
1302 }
1303};
1304
1306 bool isOpType(unsigned Opcode) {
1307 return Opcode == Instruction::SDiv || Opcode == Instruction::UDiv;
1308 }
1309};
1310
1312 bool isOpType(unsigned Opcode) {
1313 return Opcode == Instruction::SRem || Opcode == Instruction::URem;
1314 }
1315};
1316
1317/// Matches shift operations.
1318template <typename LHS, typename RHS>
1320 const RHS &R) {
1322}
1323
1324/// Matches logical shift operations.
1325template <typename LHS, typename RHS>
1327 const RHS &R) {
1329}
1330
1331/// Matches logical shift operations.
1332template <typename LHS, typename RHS>
1334m_LogicalShift(const LHS &L, const RHS &R) {
1336}
1337
1338/// Matches bitwise logic operations.
1339template <typename LHS, typename RHS>
1341m_BitwiseLogic(const LHS &L, const RHS &R) {
1343}
1344
1345/// Matches integer division operations.
1346template <typename LHS, typename RHS>
1348 const RHS &R) {
1350}
1351
1352/// Matches integer remainder operations.
1353template <typename LHS, typename RHS>
1355 const RHS &R) {
1357}
1358
1359//===----------------------------------------------------------------------===//
1360// Class that matches exact binary ops.
1361//
1362template <typename SubPattern_t> struct Exact_match {
1363 SubPattern_t SubPattern;
1364
1365 Exact_match(const SubPattern_t &SP) : SubPattern(SP) {}
1366
1367 template <typename OpTy> bool match(OpTy *V) {
1368 if (auto *PEO = dyn_cast<PossiblyExactOperator>(V))
1369 return PEO->isExact() && SubPattern.match(V);
1370 return false;
1371 }
1372};
1373
1374template <typename T> inline Exact_match<T> m_Exact(const T &SubPattern) {
1375 return SubPattern;
1376}
1377
1378//===----------------------------------------------------------------------===//
1379// Matchers for CmpInst classes
1380//
1381
1382template <typename LHS_t, typename RHS_t, typename Class, typename PredicateTy,
1383 bool Commutable = false>
1385 PredicateTy &Predicate;
1388
1389 // The evaluation order is always stable, regardless of Commutability.
1390 // The LHS is always matched first.
1391 CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
1392 : Predicate(Pred), L(LHS), R(RHS) {}
1393
1394 template <typename OpTy> bool match(OpTy *V) {
1395 if (auto *I = dyn_cast<Class>(V)) {
1396 if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
1397 Predicate = I->getPredicate();
1398 return true;
1399 } else if (Commutable && L.match(I->getOperand(1)) &&
1400 R.match(I->getOperand(0))) {
1401 Predicate = I->getSwappedPredicate();
1402 return true;
1403 }
1404 }
1405 return false;
1406 }
1407};
1408
1409template <typename LHS, typename RHS>
1411m_Cmp(CmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1413}
1414
1415template <typename LHS, typename RHS>
1417m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1419}
1420
1421template <typename LHS, typename RHS>
1423m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1425}
1426
1427//===----------------------------------------------------------------------===//
1428// Matchers for instructions with a given opcode and number of operands.
1429//
1430
1431/// Matches instructions with Opcode and three operands.
1432template <typename T0, unsigned Opcode> struct OneOps_match {
1434
1435 OneOps_match(const T0 &Op1) : Op1(Op1) {}
1436
1437 template <typename OpTy> bool match(OpTy *V) {
1438 if (V->getValueID() == Value::InstructionVal + Opcode) {
1439 auto *I = cast<Instruction>(V);
1440 return Op1.match(I->getOperand(0));
1441 }
1442 return false;
1443 }
1444};
1445
1446/// Matches instructions with Opcode and three operands.
1447template <typename T0, typename T1, unsigned Opcode> struct TwoOps_match {
1450
1451 TwoOps_match(const T0 &Op1, const T1 &Op2) : Op1(Op1), Op2(Op2) {}
1452
1453 template <typename OpTy> bool match(OpTy *V) {
1454 if (V->getValueID() == Value::InstructionVal + Opcode) {
1455 auto *I = cast<Instruction>(V);
1456 return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1));
1457 }
1458 return false;
1459 }
1460};
1461
1462/// Matches instructions with Opcode and three operands.
1463template <typename T0, typename T1, typename T2, unsigned Opcode>
1468
1469 ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
1470 : Op1(Op1), Op2(Op2), Op3(Op3) {}
1471
1472 template <typename OpTy> bool match(OpTy *V) {
1473 if (V->getValueID() == Value::InstructionVal + Opcode) {
1474 auto *I = cast<Instruction>(V);
1475 return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1476 Op3.match(I->getOperand(2));
1477 }
1478 return false;
1479 }
1480};
1481
1482/// Matches SelectInst.
1483template <typename Cond, typename LHS, typename RHS>
1485m_Select(const Cond &C, const LHS &L, const RHS &R) {
1487}
1488
1489/// This matches a select of two constants, e.g.:
1490/// m_SelectCst<-1, 0>(m_Value(V))
1491template <int64_t L, int64_t R, typename Cond>
1493 Instruction::Select>
1495 return m_Select(C, m_ConstantInt<L>(), m_ConstantInt<R>());
1496}
1497
1498/// Matches FreezeInst.
1499template <typename OpTy>
1502}
1503
1504/// Matches InsertElementInst.
1505template <typename Val_t, typename Elt_t, typename Idx_t>
1507m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx) {
1509 Val, Elt, Idx);
1510}
1511
1512/// Matches ExtractElementInst.
1513template <typename Val_t, typename Idx_t>
1515m_ExtractElt(const Val_t &Val, const Idx_t &Idx) {
1517}
1518
1519/// Matches shuffle.
1520template <typename T0, typename T1, typename T2> struct Shuffle_match {
1524
1525 Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
1526 : Op1(Op1), Op2(Op2), Mask(Mask) {}
1527
1528 template <typename OpTy> bool match(OpTy *V) {
1529 if (auto *I = dyn_cast<ShuffleVectorInst>(V)) {
1530 return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1531 Mask.match(I->getShuffleMask());
1532 }
1533 return false;
1534 }
1535};
1536
1537struct m_Mask {
1541 MaskRef = Mask;
1542 return true;
1543 }
1544};
1545
1548 return all_of(Mask, [](int Elem) { return Elem == 0 || Elem == -1; });
1549 }
1550};
1551
1555 bool match(ArrayRef<int> Mask) { return MaskRef == Mask; }
1556};
1557
1562 const auto *First = find_if(Mask, [](int Elem) { return Elem != -1; });
1563 if (First == Mask.end())
1564 return false;
1565 SplatIndex = *First;
1566 return all_of(Mask,
1567 [First](int Elem) { return Elem == *First || Elem == -1; });
1568 }
1569};
1570
1571/// Matches ShuffleVectorInst independently of mask value.
1572template <typename V1_t, typename V2_t>
1574m_Shuffle(const V1_t &v1, const V2_t &v2) {
1576}
1577
1578template <typename V1_t, typename V2_t, typename Mask_t>
1580m_Shuffle(const V1_t &v1, const V2_t &v2, const Mask_t &mask) {
1581 return Shuffle_match<V1_t, V2_t, Mask_t>(v1, v2, mask);
1582}
1583
1584/// Matches LoadInst.
1585template <typename OpTy>
1588}
1589
1590/// Matches StoreInst.
1591template <typename ValueOpTy, typename PointerOpTy>
1593m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp) {
1595 PointerOp);
1596}
1597
1598//===----------------------------------------------------------------------===//
1599// Matchers for CastInst classes
1600//
1601
1602template <typename Op_t, unsigned Opcode> struct CastOperator_match {
1603 Op_t Op;
1604
1605 CastOperator_match(const Op_t &OpMatch) : Op(OpMatch) {}
1606
1607 template <typename OpTy> bool match(OpTy *V) {
1608 if (auto *O = dyn_cast<Operator>(V))
1609 return O->getOpcode() == Opcode && Op.match(O->getOperand(0));
1610 return false;
1611 }
1612};
1613
1614template <typename Op_t, unsigned Opcode> struct CastInst_match {
1615 Op_t Op;
1616
1617 CastInst_match(const Op_t &OpMatch) : Op(OpMatch) {}
1618
1619 template <typename OpTy> bool match(OpTy *V) {
1620 if (auto *I = dyn_cast<Instruction>(V))
1621 return I->getOpcode() == Opcode && Op.match(I->getOperand(0));
1622 return false;
1623 }
1624};
1625
1626template <typename Op_t> struct PtrToIntSameSize_match {
1628 Op_t Op;
1629
1630 PtrToIntSameSize_match(const DataLayout &DL, const Op_t &OpMatch)
1631 : DL(DL), Op(OpMatch) {}
1632
1633 template <typename OpTy> bool match(OpTy *V) {
1634 if (auto *O = dyn_cast<Operator>(V))
1635 return O->getOpcode() == Instruction::PtrToInt &&
1636 DL.getTypeSizeInBits(O->getType()) ==
1637 DL.getTypeSizeInBits(O->getOperand(0)->getType()) &&
1638 Op.match(O->getOperand(0));
1639 return false;
1640 }
1641};
1642
1643/// Matches BitCast.
1644template <typename OpTy>
1646m_BitCast(const OpTy &Op) {
1648}
1649
1650/// Matches PtrToInt.
1651template <typename OpTy>
1653m_PtrToInt(const OpTy &Op) {
1655}
1656
1657template <typename OpTy>
1659 const OpTy &Op) {
1661}
1662
1663/// Matches IntToPtr.
1664template <typename OpTy>
1666m_IntToPtr(const OpTy &Op) {
1668}
1669
1670/// Matches Trunc.
1671template <typename OpTy>
1674}
1675
1676template <typename OpTy>
1678m_TruncOrSelf(const OpTy &Op) {
1679 return m_CombineOr(m_Trunc(Op), Op);
1680}
1681
1682/// Matches SExt.
1683template <typename OpTy>
1686}
1687
1688/// Matches ZExt.
1689template <typename OpTy>
1692}
1693
1694template <typename OpTy>
1696m_ZExtOrSelf(const OpTy &Op) {
1697 return m_CombineOr(m_ZExt(Op), Op);
1698}
1699
1700template <typename OpTy>
1702m_SExtOrSelf(const OpTy &Op) {
1703 return m_CombineOr(m_SExt(Op), Op);
1704}
1705
1706template <typename OpTy>
1709m_ZExtOrSExt(const OpTy &Op) {
1710 return m_CombineOr(m_ZExt(Op), m_SExt(Op));
1711}
1712
1713template <typename OpTy>
1714inline match_combine_or<
1717 OpTy>
1719 return m_CombineOr(m_ZExtOrSExt(Op), Op);
1720}
1721
1722template <typename OpTy>
1725}
1726
1727template <typename OpTy>
1730}
1731
1732template <typename OpTy>
1735}
1736
1737template <typename OpTy>
1740}
1741
1742template <typename OpTy>
1744m_FPTrunc(const OpTy &Op) {
1746}
1747
1748template <typename OpTy>
1751}
1752
1753//===----------------------------------------------------------------------===//
1754// Matchers for control flow.
1755//
1756
1757struct br_match {
1759
1761
1762 template <typename OpTy> bool match(OpTy *V) {
1763 if (auto *BI = dyn_cast<BranchInst>(V))
1764 if (BI->isUnconditional()) {
1765 Succ = BI->getSuccessor(0);
1766 return true;
1767 }
1768 return false;
1769 }
1770};
1771
1772inline br_match m_UnconditionalBr(BasicBlock *&Succ) { return br_match(Succ); }
1773
1774template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1776 Cond_t Cond;
1777 TrueBlock_t T;
1778 FalseBlock_t F;
1779
1780 brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
1781 : Cond(C), T(t), F(f) {}
1782
1783 template <typename OpTy> bool match(OpTy *V) {
1784 if (auto *BI = dyn_cast<BranchInst>(V))
1785 if (BI->isConditional() && Cond.match(BI->getCondition()))
1786 return T.match(BI->getSuccessor(0)) && F.match(BI->getSuccessor(1));
1787 return false;
1788 }
1789};
1790
1791template <typename Cond_t>
1793m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F) {
1796}
1797
1798template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1800m_Br(const Cond_t &C, const TrueBlock_t &T, const FalseBlock_t &F) {
1802}
1803
1804//===----------------------------------------------------------------------===//
1805// Matchers for max/min idioms, eg: "select (sgt x, y), x, y" -> smax(x,y).
1806//
1807
1808template <typename CmpInst_t, typename LHS_t, typename RHS_t, typename Pred_t,
1809 bool Commutable = false>
1811 using PredType = Pred_t;
1814
1815 // The evaluation order is always stable, regardless of Commutability.
1816 // The LHS is always matched first.
1817 MaxMin_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1818
1819 template <typename OpTy> bool match(OpTy *V) {
1820 if (auto *II = dyn_cast<IntrinsicInst>(V)) {
1821 Intrinsic::ID IID = II->getIntrinsicID();
1822 if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
1823 (IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
1824 (IID == Intrinsic::umax && Pred_t::match(ICmpInst::ICMP_UGT)) ||
1825 (IID == Intrinsic::umin && Pred_t::match(ICmpInst::ICMP_ULT))) {
1826 Value *LHS = II->getOperand(0), *RHS = II->getOperand(1);
1827 return (L.match(LHS) && R.match(RHS)) ||
1828 (Commutable && L.match(RHS) && R.match(LHS));
1829 }
1830 }
1831 // Look for "(x pred y) ? x : y" or "(x pred y) ? y : x".
1832 auto *SI = dyn_cast<SelectInst>(V);
1833 if (!SI)
1834 return false;
1835 auto *Cmp = dyn_cast<CmpInst_t>(SI->getCondition());
1836 if (!Cmp)
1837 return false;
1838 // At this point we have a select conditioned on a comparison. Check that
1839 // it is the values returned by the select that are being compared.
1840 auto *TrueVal = SI->getTrueValue();
1841 auto *FalseVal = SI->getFalseValue();
1842 auto *LHS = Cmp->getOperand(0);
1843 auto *RHS = Cmp->getOperand(1);
1844 if ((TrueVal != LHS || FalseVal != RHS) &&
1845 (TrueVal != RHS || FalseVal != LHS))
1846 return false;
1847 typename CmpInst_t::Predicate Pred =
1848 LHS == TrueVal ? Cmp->getPredicate() : Cmp->getInversePredicate();
1849 // Does "(x pred y) ? x : y" represent the desired max/min operation?
1850 if (!Pred_t::match(Pred))
1851 return false;
1852 // It does! Bind the operands.
1853 return (L.match(LHS) && R.match(RHS)) ||
1854 (Commutable && L.match(RHS) && R.match(LHS));
1855 }
1856};
1857
1858/// Helper class for identifying signed max predicates.
1860 static bool match(ICmpInst::Predicate Pred) {
1861 return Pred == CmpInst::ICMP_SGT || Pred == CmpInst::ICMP_SGE;
1862 }
1863};
1864
1865/// Helper class for identifying signed min predicates.
1867 static bool match(ICmpInst::Predicate Pred) {
1868 return Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_SLE;
1869 }
1870};
1871
1872/// Helper class for identifying unsigned max predicates.
1874 static bool match(ICmpInst::Predicate Pred) {
1875 return Pred == CmpInst::ICMP_UGT || Pred == CmpInst::ICMP_UGE;
1876 }
1877};
1878
1879/// Helper class for identifying unsigned min predicates.
1881 static bool match(ICmpInst::Predicate Pred) {
1882 return Pred == CmpInst::ICMP_ULT || Pred == CmpInst::ICMP_ULE;
1883 }
1884};
1885
1886/// Helper class for identifying ordered max predicates.
1888 static bool match(FCmpInst::Predicate Pred) {
1889 return Pred == CmpInst::FCMP_OGT || Pred == CmpInst::FCMP_OGE;
1890 }
1891};
1892
1893/// Helper class for identifying ordered min predicates.
1895 static bool match(FCmpInst::Predicate Pred) {
1896 return Pred == CmpInst::FCMP_OLT || Pred == CmpInst::FCMP_OLE;
1897 }
1898};
1899
1900/// Helper class for identifying unordered max predicates.
1902 static bool match(FCmpInst::Predicate Pred) {
1903 return Pred == CmpInst::FCMP_UGT || Pred == CmpInst::FCMP_UGE;
1904 }
1905};
1906
1907/// Helper class for identifying unordered min predicates.
1909 static bool match(FCmpInst::Predicate Pred) {
1910 return Pred == CmpInst::FCMP_ULT || Pred == CmpInst::FCMP_ULE;
1911 }
1912};
1913
1914template <typename LHS, typename RHS>
1916 const RHS &R) {
1918}
1919
1920template <typename LHS, typename RHS>
1922 const RHS &R) {
1924}
1925
1926template <typename LHS, typename RHS>
1928 const RHS &R) {
1930}
1931
1932template <typename LHS, typename RHS>
1934 const RHS &R) {
1936}
1937
1938template <typename LHS, typename RHS>
1939inline match_combine_or<
1944m_MaxOrMin(const LHS &L, const RHS &R) {
1945 return m_CombineOr(m_CombineOr(m_SMax(L, R), m_SMin(L, R)),
1946 m_CombineOr(m_UMax(L, R), m_UMin(L, R)));
1947}
1948
1949/// Match an 'ordered' floating point maximum function.
1950/// Floating point has one special value 'NaN'. Therefore, there is no total
1951/// order. However, if we can ignore the 'NaN' value (for example, because of a
1952/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1953/// semantics. In the presence of 'NaN' we have to preserve the original
1954/// select(fcmp(ogt/ge, L, R), L, R) semantics matched by this predicate.
1955///
1956/// max(L, R) iff L and R are not NaN
1957/// m_OrdFMax(L, R) = R iff L or R are NaN
1958template <typename LHS, typename RHS>
1960 const RHS &R) {
1962}
1963
1964/// Match an 'ordered' floating point minimum function.
1965/// Floating point has one special value 'NaN'. Therefore, there is no total
1966/// order. However, if we can ignore the 'NaN' value (for example, because of a
1967/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1968/// semantics. In the presence of 'NaN' we have to preserve the original
1969/// select(fcmp(olt/le, L, R), L, R) semantics matched by this predicate.
1970///
1971/// min(L, R) iff L and R are not NaN
1972/// m_OrdFMin(L, R) = R iff L or R are NaN
1973template <typename LHS, typename RHS>
1975 const RHS &R) {
1977}
1978
1979/// Match an 'unordered' floating point maximum function.
1980/// Floating point has one special value 'NaN'. Therefore, there is no total
1981/// order. However, if we can ignore the 'NaN' value (for example, because of a
1982/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1983/// semantics. In the presence of 'NaN' we have to preserve the original
1984/// select(fcmp(ugt/ge, L, R), L, R) semantics matched by this predicate.
1985///
1986/// max(L, R) iff L and R are not NaN
1987/// m_UnordFMax(L, R) = L iff L or R are NaN
1988template <typename LHS, typename RHS>
1990m_UnordFMax(const LHS &L, const RHS &R) {
1992}
1993
1994/// Match an 'unordered' floating point minimum function.
1995/// Floating point has one special value 'NaN'. Therefore, there is no total
1996/// order. However, if we can ignore the 'NaN' value (for example, because of a
1997/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1998/// semantics. In the presence of 'NaN' we have to preserve the original
1999/// select(fcmp(ult/le, L, R), L, R) semantics matched by this predicate.
2000///
2001/// min(L, R) iff L and R are not NaN
2002/// m_UnordFMin(L, R) = L iff L or R are NaN
2003template <typename LHS, typename RHS>
2005m_UnordFMin(const LHS &L, const RHS &R) {
2007}
2008
2009//===----------------------------------------------------------------------===//
2010// Matchers for overflow check patterns: e.g. (a + b) u< a, (a ^ -1) <u b
2011// Note that S might be matched to other instructions than AddInst.
2012//
2013
2014template <typename LHS_t, typename RHS_t, typename Sum_t>
2018 Sum_t S;
2019
2020 UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
2021 : L(L), R(R), S(S) {}
2022
2023 template <typename OpTy> bool match(OpTy *V) {
2024 Value *ICmpLHS, *ICmpRHS;
2026 if (!m_ICmp(Pred, m_Value(ICmpLHS), m_Value(ICmpRHS)).match(V))
2027 return false;
2028
2029 Value *AddLHS, *AddRHS;
2030 auto AddExpr = m_Add(m_Value(AddLHS), m_Value(AddRHS));
2031
2032 // (a + b) u< a, (a + b) u< b
2033 if (Pred == ICmpInst::ICMP_ULT)
2034 if (AddExpr.match(ICmpLHS) && (ICmpRHS == AddLHS || ICmpRHS == AddRHS))
2035 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
2036
2037 // a >u (a + b), b >u (a + b)
2038 if (Pred == ICmpInst::ICMP_UGT)
2039 if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
2040 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
2041
2042 Value *Op1;
2043 auto XorExpr = m_OneUse(m_Xor(m_Value(Op1), m_AllOnes()));
2044 // (a ^ -1) <u b
2045 if (Pred == ICmpInst::ICMP_ULT) {
2046 if (XorExpr.match(ICmpLHS))
2047 return L.match(Op1) && R.match(ICmpRHS) && S.match(ICmpLHS);
2048 }
2049 // b > u (a ^ -1)
2050 if (Pred == ICmpInst::ICMP_UGT) {
2051 if (XorExpr.match(ICmpRHS))
2052 return L.match(Op1) && R.match(ICmpLHS) && S.match(ICmpRHS);
2053 }
2054
2055 // Match special-case for increment-by-1.
2056 if (Pred == ICmpInst::ICMP_EQ) {
2057 // (a + 1) == 0
2058 // (1 + a) == 0
2059 if (AddExpr.match(ICmpLHS) && m_ZeroInt().match(ICmpRHS) &&
2060 (m_One().match(AddLHS) || m_One().match(AddRHS)))
2061 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
2062 // 0 == (a + 1)
2063 // 0 == (1 + a)
2064 if (m_ZeroInt().match(ICmpLHS) && AddExpr.match(ICmpRHS) &&
2065 (m_One().match(AddLHS) || m_One().match(AddRHS)))
2066 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
2067 }
2068
2069 return false;
2070 }
2071};
2072
2073/// Match an icmp instruction checking for unsigned overflow on addition.
2074///
2075/// S is matched to the addition whose result is being checked for overflow, and
2076/// L and R are matched to the LHS and RHS of S.
2077template <typename LHS_t, typename RHS_t, typename Sum_t>
2079m_UAddWithOverflow(const LHS_t &L, const RHS_t &R, const Sum_t &S) {
2081}
2082
2083template <typename Opnd_t> struct Argument_match {
2084 unsigned OpI;
2085 Opnd_t Val;
2086
2087 Argument_match(unsigned OpIdx, const Opnd_t &V) : OpI(OpIdx), Val(V) {}
2088
2089 template <typename OpTy> bool match(OpTy *V) {
2090 // FIXME: Should likely be switched to use `CallBase`.
2091 if (const auto *CI = dyn_cast<CallInst>(V))
2092 return Val.match(CI->getArgOperand(OpI));
2093 return false;
2094 }
2095};
2096
2097/// Match an argument.
2098template <unsigned OpI, typename Opnd_t>
2099inline Argument_match<Opnd_t> m_Argument(const Opnd_t &Op) {
2100 return Argument_match<Opnd_t>(OpI, Op);
2101}
2102
2103/// Intrinsic matchers.
2105 unsigned ID;
2106
2108
2109 template <typename OpTy> bool match(OpTy *V) {
2110 if (const auto *CI = dyn_cast<CallInst>(V))
2111 if (const auto *F = CI->getCalledFunction())
2112 return F->getIntrinsicID() == ID;
2113 return false;
2114 }
2115};
2116
2117/// Intrinsic matches are combinations of ID matchers, and argument
2118/// matchers. Higher arity matcher are defined recursively in terms of and-ing
2119/// them with lower arity matchers. Here's some convenient typedefs for up to
2120/// several arguments, and more can be added as needed
2121template <typename T0 = void, typename T1 = void, typename T2 = void,
2122 typename T3 = void, typename T4 = void, typename T5 = void,
2123 typename T6 = void, typename T7 = void, typename T8 = void,
2124 typename T9 = void, typename T10 = void>
2126template <typename T0> struct m_Intrinsic_Ty<T0> {
2128};
2129template <typename T0, typename T1> struct m_Intrinsic_Ty<T0, T1> {
2130 using Ty =
2132};
2133template <typename T0, typename T1, typename T2>
2134struct m_Intrinsic_Ty<T0, T1, T2> {
2137};
2138template <typename T0, typename T1, typename T2, typename T3>
2139struct m_Intrinsic_Ty<T0, T1, T2, T3> {
2142};
2143
2144template <typename T0, typename T1, typename T2, typename T3, typename T4>
2145struct m_Intrinsic_Ty<T0, T1, T2, T3, T4> {
2148};
2149
2150template <typename T0, typename T1, typename T2, typename T3, typename T4,
2151 typename T5>
2152struct m_Intrinsic_Ty<T0, T1, T2, T3, T4, T5> {
2155};
2156
2157/// Match intrinsic calls like this:
2158/// m_Intrinsic<Intrinsic::fabs>(m_Value(X))
2159template <Intrinsic::ID IntrID> inline IntrinsicID_match m_Intrinsic() {
2160 return IntrinsicID_match(IntrID);
2161}
2162
2163/// Matches MaskedLoad Intrinsic.
2164template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2166m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2167 const Opnd3 &Op3) {
2168 return m_Intrinsic<Intrinsic::masked_load>(Op0, Op1, Op2, Op3);
2169}
2170
2171/// Matches MaskedGather Intrinsic.
2172template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2174m_MaskedGather(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2175 const Opnd3 &Op3) {
2176 return m_Intrinsic<Intrinsic::masked_gather>(Op0, Op1, Op2, Op3);
2177}
2178
2179template <Intrinsic::ID IntrID, typename T0>
2180inline typename m_Intrinsic_Ty<T0>::Ty m_Intrinsic(const T0 &Op0) {
2181 return m_CombineAnd(m_Intrinsic<IntrID>(), m_Argument<0>(Op0));
2182}
2183
2184template <Intrinsic::ID IntrID, typename T0, typename T1>
2185inline typename m_Intrinsic_Ty<T0, T1>::Ty m_Intrinsic(const T0 &Op0,
2186 const T1 &Op1) {
2187 return m_CombineAnd(m_Intrinsic<IntrID>(Op0), m_Argument<1>(Op1));
2188}
2189
2190template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2>
2191inline typename m_Intrinsic_Ty<T0, T1, T2>::Ty
2192m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2) {
2193 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1), m_Argument<2>(Op2));
2194}
2195
2196template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2197 typename T3>
2199m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3) {
2200 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2), m_Argument<3>(Op3));
2201}
2202
2203template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2204 typename T3, typename T4>
2206m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2207 const T4 &Op4) {
2208 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3),
2209 m_Argument<4>(Op4));
2210}
2211
2212template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2213 typename T3, typename T4, typename T5>
2215m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2216 const T4 &Op4, const T5 &Op5) {
2217 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3, Op4),
2218 m_Argument<5>(Op5));
2219}
2220
2221// Helper intrinsic matching specializations.
2222template <typename Opnd0>
2223inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BitReverse(const Opnd0 &Op0) {
2224 return m_Intrinsic<Intrinsic::bitreverse>(Op0);
2225}
2226
2227template <typename Opnd0>
2228inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BSwap(const Opnd0 &Op0) {
2229 return m_Intrinsic<Intrinsic::bswap>(Op0);
2230}
2231
2232template <typename Opnd0>
2233inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FAbs(const Opnd0 &Op0) {
2234 return m_Intrinsic<Intrinsic::fabs>(Op0);
2235}
2236
2237template <typename Opnd0>
2238inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FCanonicalize(const Opnd0 &Op0) {
2239 return m_Intrinsic<Intrinsic::canonicalize>(Op0);
2240}
2241
2242template <typename Opnd0, typename Opnd1>
2243inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMin(const Opnd0 &Op0,
2244 const Opnd1 &Op1) {
2245 return m_Intrinsic<Intrinsic::minnum>(Op0, Op1);
2246}
2247
2248template <typename Opnd0, typename Opnd1>
2249inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMax(const Opnd0 &Op0,
2250 const Opnd1 &Op1) {
2251 return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
2252}
2253
2254template <typename Opnd0, typename Opnd1, typename Opnd2>
2256m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2257 return m_Intrinsic<Intrinsic::fshl>(Op0, Op1, Op2);
2258}
2259
2260template <typename Opnd0, typename Opnd1, typename Opnd2>
2262m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2263 return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
2264}
2265
2266template <typename Opnd0>
2267inline typename m_Intrinsic_Ty<Opnd0>::Ty m_Sqrt(const Opnd0 &Op0) {
2268 return m_Intrinsic<Intrinsic::sqrt>(Op0);
2269}
2270
2271template <typename Opnd0, typename Opnd1>
2272inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_CopySign(const Opnd0 &Op0,
2273 const Opnd1 &Op1) {
2274 return m_Intrinsic<Intrinsic::copysign>(Op0, Op1);
2275}
2276
2277template <typename Opnd0>
2278inline typename m_Intrinsic_Ty<Opnd0>::Ty m_VecReverse(const Opnd0 &Op0) {
2279 return m_Intrinsic<Intrinsic::experimental_vector_reverse>(Op0);
2280}
2281
2282//===----------------------------------------------------------------------===//
2283// Matchers for two-operands operators with the operators in either order
2284//
2285
2286/// Matches a BinaryOperator with LHS and RHS in either order.
2287template <typename LHS, typename RHS>
2290}
2291
2292/// Matches an ICmp with a predicate over LHS and RHS in either order.
2293/// Swaps the predicate if operands are commuted.
2294template <typename LHS, typename RHS>
2296m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
2298 R);
2299}
2300
2301/// Matches a specific opcode with LHS and RHS in either order.
2302template <typename LHS, typename RHS>
2304m_c_BinOp(unsigned Opcode, const LHS &L, const RHS &R) {
2306}
2307
2308/// Matches a Add with LHS and RHS in either order.
2309template <typename LHS, typename RHS>
2311 const RHS &R) {
2313}
2314
2315/// Matches a Mul with LHS and RHS in either order.
2316template <typename LHS, typename RHS>
2318 const RHS &R) {
2320}
2321
2322/// Matches an And with LHS and RHS in either order.
2323template <typename LHS, typename RHS>
2325 const RHS &R) {
2327}
2328
2329/// Matches an Or with LHS and RHS in either order.
2330template <typename LHS, typename RHS>
2332 const RHS &R) {
2334}
2335
2336/// Matches an Xor with LHS and RHS in either order.
2337template <typename LHS, typename RHS>
2339 const RHS &R) {
2341}
2342
2343/// Matches a 'Neg' as 'sub 0, V'.
2344template <typename ValTy>
2345inline BinaryOp_match<cst_pred_ty<is_zero_int>, ValTy, Instruction::Sub>
2346m_Neg(const ValTy &V) {
2347 return m_Sub(m_ZeroInt(), V);
2348}
2349
2350/// Matches a 'Neg' as 'sub nsw 0, V'.
2351template <typename ValTy>
2353 Instruction::Sub,
2355m_NSWNeg(const ValTy &V) {
2356 return m_NSWSub(m_ZeroInt(), V);
2357}
2358
2359/// Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
2360/// NOTE: we first match the 'Not' (by matching '-1'),
2361/// and only then match the inner matcher!
2362template <typename ValTy>
2363inline BinaryOp_match<cst_pred_ty<is_all_ones>, ValTy, Instruction::Xor, true>
2364m_Not(const ValTy &V) {
2365 return m_c_Xor(m_AllOnes(), V);
2366}
2367
2368template <typename ValTy> struct NotForbidUndef_match {
2369 ValTy Val;
2370 NotForbidUndef_match(const ValTy &V) : Val(V) {}
2371
2372 template <typename OpTy> bool match(OpTy *V) {
2373 // We do not use m_c_Xor because that could match an arbitrary APInt that is
2374 // not -1 as C and then fail to match the other operand if it is -1.
2375 // This code should still work even when both operands are constants.
2376 Value *X;
2377 const APInt *C;
2378 if (m_Xor(m_Value(X), m_APIntForbidUndef(C)).match(V) && C->isAllOnes())
2379 return Val.match(X);
2380 if (m_Xor(m_APIntForbidUndef(C), m_Value(X)).match(V) && C->isAllOnes())
2381 return Val.match(X);
2382 return false;
2383 }
2384};
2385
2386/// Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'. For vectors, the
2387/// constant value must be composed of only -1 scalar elements.
2388template <typename ValTy>
2391}
2392
2393/// Matches an SMin with LHS and RHS in either order.
2394template <typename LHS, typename RHS>
2396m_c_SMin(const LHS &L, const RHS &R) {
2398}
2399/// Matches an SMax with LHS and RHS in either order.
2400template <typename LHS, typename RHS>
2402m_c_SMax(const LHS &L, const RHS &R) {
2404}
2405/// Matches a UMin with LHS and RHS in either order.
2406template <typename LHS, typename RHS>
2408m_c_UMin(const LHS &L, const RHS &R) {
2410}
2411/// Matches a UMax with LHS and RHS in either order.
2412template <typename LHS, typename RHS>
2414m_c_UMax(const LHS &L, const RHS &R) {
2416}
2417
2418template <typename LHS, typename RHS>
2419inline match_combine_or<
2424m_c_MaxOrMin(const LHS &L, const RHS &R) {
2425 return m_CombineOr(m_CombineOr(m_c_SMax(L, R), m_c_SMin(L, R)),
2426 m_CombineOr(m_c_UMax(L, R), m_c_UMin(L, R)));
2427}
2428
2429template <Intrinsic::ID IntrID, typename T0, typename T1>
2432m_c_Intrinsic(const T0 &Op0, const T1 &Op1) {
2433 return m_CombineOr(m_Intrinsic<IntrID>(Op0, Op1),
2434 m_Intrinsic<IntrID>(Op1, Op0));
2435}
2436
2437/// Matches FAdd with LHS and RHS in either order.
2438template <typename LHS, typename RHS>
2440m_c_FAdd(const LHS &L, const RHS &R) {
2442}
2443
2444/// Matches FMul with LHS and RHS in either order.
2445template <typename LHS, typename RHS>
2447m_c_FMul(const LHS &L, const RHS &R) {
2449}
2450
2451template <typename Opnd_t> struct Signum_match {
2452 Opnd_t Val;
2453 Signum_match(const Opnd_t &V) : Val(V) {}
2454
2455 template <typename OpTy> bool match(OpTy *V) {
2456 unsigned TypeSize = V->getType()->getScalarSizeInBits();
2457 if (TypeSize == 0)
2458 return false;
2459
2460 unsigned ShiftWidth = TypeSize - 1;
2461 Value *OpL = nullptr, *OpR = nullptr;
2462
2463 // This is the representation of signum we match:
2464 //
2465 // signum(x) == (x >> 63) | (-x >>u 63)
2466 //
2467 // An i1 value is its own signum, so it's correct to match
2468 //
2469 // signum(x) == (x >> 0) | (-x >>u 0)
2470 //
2471 // for i1 values.
2472
2473 auto LHS = m_AShr(m_Value(OpL), m_SpecificInt(ShiftWidth));
2474 auto RHS = m_LShr(m_Neg(m_Value(OpR)), m_SpecificInt(ShiftWidth));
2475 auto Signum = m_Or(LHS, RHS);
2476
2477 return Signum.match(V) && OpL == OpR && Val.match(OpL);
2478 }
2479};
2480
2481/// Matches a signum pattern.
2482///
2483/// signum(x) =
2484/// x > 0 -> 1
2485/// x == 0 -> 0
2486/// x < 0 -> -1
2487template <typename Val_t> inline Signum_match<Val_t> m_Signum(const Val_t &V) {
2488 return Signum_match<Val_t>(V);
2489}
2490
2491template <int Ind, typename Opnd_t> struct ExtractValue_match {
2492 Opnd_t Val;
2493 ExtractValue_match(const Opnd_t &V) : Val(V) {}
2494
2495 template <typename OpTy> bool match(OpTy *V) {
2496 if (auto *I = dyn_cast<ExtractValueInst>(V)) {
2497 // If Ind is -1, don't inspect indices
2498 if (Ind != -1 &&
2499 !(I->getNumIndices() == 1 && I->getIndices()[0] == (unsigned)Ind))
2500 return false;
2501 return Val.match(I->getAggregateOperand());
2502 }
2503 return false;
2504 }
2505};
2506
2507/// Match a single index ExtractValue instruction.
2508/// For example m_ExtractValue<1>(...)
2509template <int Ind, typename Val_t>
2512}
2513
2514/// Match an ExtractValue instruction with any index.
2515/// For example m_ExtractValue(...)
2516template <typename Val_t>
2517inline ExtractValue_match<-1, Val_t> m_ExtractValue(const Val_t &V) {
2518 return ExtractValue_match<-1, Val_t>(V);
2519}
2520
2521/// Matcher for a single index InsertValue instruction.
2522template <int Ind, typename T0, typename T1> struct InsertValue_match {
2525
2526 InsertValue_match(const T0 &Op0, const T1 &Op1) : Op0(Op0), Op1(Op1) {}
2527
2528 template <typename OpTy> bool match(OpTy *V) {
2529 if (auto *I = dyn_cast<InsertValueInst>(V)) {
2530 return Op0.match(I->getOperand(0)) && Op1.match(I->getOperand(1)) &&
2531 I->getNumIndices() == 1 && Ind == I->getIndices()[0];
2532 }
2533 return false;
2534 }
2535};
2536
2537/// Matches a single index InsertValue instruction.
2538template <int Ind, typename Val_t, typename Elt_t>
2540 const Elt_t &Elt) {
2541 return InsertValue_match<Ind, Val_t, Elt_t>(Val, Elt);
2542}
2543
2544/// Matches patterns for `vscale`. This can either be a call to `llvm.vscale` or
2545/// the constant expression
2546/// `ptrtoint(gep <vscale x 1 x i8>, <vscale x 1 x i8>* null, i32 1>`
2547/// under the right conditions determined by DataLayout.
2549 template <typename ITy> bool match(ITy *V) {
2550 if (m_Intrinsic<Intrinsic::vscale>().match(V))
2551 return true;
2552
2553 Value *Ptr;
2554 if (m_PtrToInt(m_Value(Ptr)).match(V)) {
2555 if (auto *GEP = dyn_cast<GEPOperator>(Ptr)) {
2556 auto *DerefTy =
2557 dyn_cast<ScalableVectorType>(GEP->getSourceElementType());
2558 if (GEP->getNumIndices() == 1 && DerefTy &&
2559 DerefTy->getElementType()->isIntegerTy(8) &&
2560 m_Zero().match(GEP->getPointerOperand()) &&
2561 m_SpecificInt(1).match(GEP->idx_begin()->get()))
2562 return true;
2563 }
2564 }
2565
2566 return false;
2567 }
2568};
2569
2571 return VScaleVal_match();
2572}
2573
2574template <typename LHS, typename RHS, unsigned Opcode, bool Commutable = false>
2578
2579 LogicalOp_match(const LHS &L, const RHS &R) : L(L), R(R) {}
2580
2581 template <typename T> bool match(T *V) {
2582 auto *I = dyn_cast<Instruction>(V);
2583 if (!I || !I->getType()->isIntOrIntVectorTy(1))
2584 return false;
2585
2586 if (I->getOpcode() == Opcode) {
2587 auto *Op0 = I->getOperand(0);
2588 auto *Op1 = I->getOperand(1);
2589 return (L.match(Op0) && R.match(Op1)) ||
2590 (Commutable && L.match(Op1) && R.match(Op0));
2591 }
2592
2593 if (auto *Select = dyn_cast<SelectInst>(I)) {
2594 auto *Cond = Select->getCondition();
2595 auto *TVal = Select->getTrueValue();
2596 auto *FVal = Select->getFalseValue();
2597
2598 // Don't match a scalar select of bool vectors.
2599 // Transforms expect a single type for operands if this matches.
2600 if (Cond->getType() != Select->getType())
2601 return false;
2602
2603 if (Opcode == Instruction::And) {
2604 auto *C = dyn_cast<Constant>(FVal);
2605 if (C && C->isNullValue())
2606 return (L.match(Cond) && R.match(TVal)) ||
2607 (Commutable && L.match(TVal) && R.match(Cond));
2608 } else {
2609 assert(Opcode == Instruction::Or);
2610 auto *C = dyn_cast<Constant>(TVal);
2611 if (C && C->isOneValue())
2612 return (L.match(Cond) && R.match(FVal)) ||
2613 (Commutable && L.match(FVal) && R.match(Cond));
2614 }
2615 }
2616
2617 return false;
2618 }
2619};
2620
2621/// Matches L && R either in the form of L & R or L ? R : false.
2622/// Note that the latter form is poison-blocking.
2623template <typename LHS, typename RHS>
2625 const RHS &R) {
2627}
2628
2629/// Matches L && R where L and R are arbitrary values.
2630inline auto m_LogicalAnd() { return m_LogicalAnd(m_Value(), m_Value()); }
2631
2632/// Matches L && R with LHS and RHS in either order.
2633template <typename LHS, typename RHS>
2635m_c_LogicalAnd(const LHS &L, const RHS &R) {
2637}
2638
2639/// Matches L || R either in the form of L | R or L ? true : R.
2640/// Note that the latter form is poison-blocking.
2641template <typename LHS, typename RHS>
2643 const RHS &R) {
2645}
2646
2647/// Matches L || R where L and R are arbitrary values.
2648inline auto m_LogicalOr() { return m_LogicalOr(m_Value(), m_Value()); }
2649
2650/// Matches L || R with LHS and RHS in either order.
2651template <typename LHS, typename RHS>
2653m_c_LogicalOr(const LHS &L, const RHS &R) {
2655}
2656
2657/// Matches either L && R or L || R,
2658/// either one being in the either binary or logical form.
2659/// Note that the latter form is poison-blocking.
2660template <typename LHS, typename RHS, bool Commutable = false>
2661inline auto m_LogicalOp(const LHS &L, const RHS &R) {
2662 return m_CombineOr(
2665}
2666
2667/// Matches either L && R or L || R where L and R are arbitrary values.
2668inline auto m_LogicalOp() { return m_LogicalOp(m_Value(), m_Value()); }
2669
2670/// Matches either L && R or L || R with LHS and RHS in either order.
2671template <typename LHS, typename RHS>
2672inline auto m_c_LogicalOp(const LHS &L, const RHS &R) {
2673 return m_LogicalOp<LHS, RHS, /*Commutable=*/true>(L, R);
2674}
2675
2676} // end namespace PatternMatch
2677} // end namespace llvm
2678
2679#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:385
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:1003
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:261
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
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:293
bool isShift() const
Definition: Instruction.h:246
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
DisjointOr_match< LHS, RHS > m_DisjointOr(const LHS &L, const RHS &R)
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)
DisjointOr_match(const LHS &L, const RHS &R)
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