LLVM 17.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.isAllOnes(); }
450};
451/// Match an integer or vector with all bits set.
452/// For vectors, this includes constants with undefined elements.
455}
456
458 bool isValue(const APInt &C) { return C.isMaxSignedValue(); }
459};
460/// Match an integer or vector with values having all bits except for the high
461/// bit set (0x7f...).
462/// For vectors, this includes constants with undefined elements.
465}
467 return V;
468}
469
471 bool isValue(const APInt &C) { return C.isNegative(); }
472};
473/// Match an integer or vector of negative values.
474/// For vectors, this includes constants with undefined elements.
477}
478inline api_pred_ty<is_negative> m_Negative(const APInt *&V) { return V; }
479
481 bool isValue(const APInt &C) { return C.isNonNegative(); }
482};
483/// Match an integer or vector of non-negative values.
484/// For vectors, this includes constants with undefined elements.
487}
488inline api_pred_ty<is_nonnegative> m_NonNegative(const APInt *&V) { return V; }
489
491 bool isValue(const APInt &C) { return C.isStrictlyPositive(); }
492};
493/// Match an integer or vector of strictly positive values.
494/// For vectors, this includes constants with undefined elements.
497}
499 return V;
500}
501
503 bool isValue(const APInt &C) { return C.isNonPositive(); }
504};
505/// Match an integer or vector of non-positive values.
506/// For vectors, this includes constants with undefined elements.
509}
510inline api_pred_ty<is_nonpositive> m_NonPositive(const APInt *&V) { return V; }
511
512struct is_one {
513 bool isValue(const APInt &C) { return C.isOne(); }
514};
515/// Match an integer 1 or a vector with all elements equal to 1.
516/// For vectors, this includes constants with undefined elements.
518
520 bool isValue(const APInt &C) { return C.isZero(); }
521};
522/// Match an integer 0 or a vector with all elements equal to 0.
523/// For vectors, this includes constants with undefined elements.
526}
527
528struct is_zero {
529 template <typename ITy> bool match(ITy *V) {
530 auto *C = dyn_cast<Constant>(V);
531 // FIXME: this should be able to do something for scalable vectors
532 return C && (C->isNullValue() || cst_pred_ty<is_zero_int>().match(C));
533 }
534};
535/// Match any null constant or a vector with all elements equal to 0.
536/// For vectors, this includes constants with undefined elements.
537inline is_zero m_Zero() { return is_zero(); }
538
539struct is_power2 {
540 bool isValue(const APInt &C) { return C.isPowerOf2(); }
541};
542/// Match an integer or vector power-of-2.
543/// For vectors, this includes constants with undefined elements.
545inline api_pred_ty<is_power2> m_Power2(const APInt *&V) { return V; }
546
548 bool isValue(const APInt &C) { return C.isNegatedPowerOf2(); }
549};
550/// Match a integer or vector negated power-of-2.
551/// For vectors, this includes constants with undefined elements.
554}
556 return V;
557}
558
560 bool isValue(const APInt &C) { return !C || C.isPowerOf2(); }
561};
562/// Match an integer or vector of 0 or power-of-2 values.
563/// For vectors, this includes constants with undefined elements.
566}
568 return V;
569}
570
572 bool isValue(const APInt &C) { return C.isSignMask(); }
573};
574/// Match an integer or vector with only the sign bit(s) set.
575/// For vectors, this includes constants with undefined elements.
578}
579
581 bool isValue(const APInt &C) { return C.isMask(); }
582};
583/// Match an integer or vector with only the low bit(s) set.
584/// For vectors, this includes constants with undefined elements.
587}
588inline api_pred_ty<is_lowbit_mask> m_LowBitMask(const APInt *&V) { return V; }
589
592 const APInt *Thr;
593 bool isValue(const APInt &C) { return ICmpInst::compare(C, *Thr, Pred); }
594};
595/// Match an integer or vector with every element comparing 'pred' (eg/ne/...)
596/// to Threshold. For vectors, this includes constants with undefined elements.
598m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold) {
600 P.Pred = Predicate;
601 P.Thr = &Threshold;
602 return P;
603}
604
605struct is_nan {
606 bool isValue(const APFloat &C) { return C.isNaN(); }
607};
608/// Match an arbitrary NaN constant. This includes quiet and signalling nans.
609/// For vectors, this includes constants with undefined elements.
611
612struct is_nonnan {
613 bool isValue(const APFloat &C) { return !C.isNaN(); }
614};
615/// Match a non-NaN FP constant.
616/// For vectors, this includes constants with undefined elements.
619}
620
621struct is_inf {
622 bool isValue(const APFloat &C) { return C.isInfinity(); }
623};
624/// Match a positive or negative infinity FP constant.
625/// For vectors, this includes constants with undefined elements.
627
628struct is_noninf {
629 bool isValue(const APFloat &C) { return !C.isInfinity(); }
630};
631/// Match a non-infinity FP constant, i.e. finite or NaN.
632/// For vectors, this includes constants with undefined elements.
635}
636
637struct is_finite {
638 bool isValue(const APFloat &C) { return C.isFinite(); }
639};
640/// Match a finite FP constant, i.e. not infinity or NaN.
641/// For vectors, this includes constants with undefined elements.
644}
645inline apf_pred_ty<is_finite> m_Finite(const APFloat *&V) { return V; }
646
648 bool isValue(const APFloat &C) { return C.isFiniteNonZero(); }
649};
650/// Match a finite non-zero FP constant.
651/// For vectors, this includes constants with undefined elements.
654}
656 return V;
657}
658
660 bool isValue(const APFloat &C) { return C.isZero(); }
661};
662/// Match a floating-point negative zero or positive zero.
663/// For vectors, this includes constants with undefined elements.
666}
667
669 bool isValue(const APFloat &C) { return C.isPosZero(); }
670};
671/// Match a floating-point positive zero.
672/// For vectors, this includes constants with undefined elements.
675}
676
678 bool isValue(const APFloat &C) { return C.isNegZero(); }
679};
680/// Match a floating-point negative zero.
681/// For vectors, this includes constants with undefined elements.
684}
685
687 bool isValue(const APFloat &C) { return C.isNonZero(); }
688};
689/// Match a floating-point non-zero.
690/// For vectors, this includes constants with undefined elements.
693}
694
695///////////////////////////////////////////////////////////////////////////////
696
697template <typename Class> struct bind_ty {
698 Class *&VR;
699
700 bind_ty(Class *&V) : VR(V) {}
701
702 template <typename ITy> bool match(ITy *V) {
703 if (auto *CV = dyn_cast<Class>(V)) {
704 VR = CV;
705 return true;
706 }
707 return false;
708 }
709};
710
711/// Match a value, capturing it if we match.
712inline bind_ty<Value> m_Value(Value *&V) { return V; }
713inline bind_ty<const Value> m_Value(const Value *&V) { return V; }
714
715/// Match an instruction, capturing it if we match.
717/// Match a unary operator, capturing it if we match.
719/// Match a binary operator, capturing it if we match.
721/// Match a with overflow intrinsic, capturing it if we match.
723 return I;
724}
727 return I;
728}
729
730/// Match a Constant, capturing the value if we match.
732
733/// Match a ConstantInt, capturing the value if we match.
735
736/// Match a ConstantFP, capturing the value if we match.
738
739/// Match a ConstantExpr, capturing the value if we match.
741
742/// Match a basic block value, capturing it if we match.
745 return V;
746}
747
748/// Match an arbitrary immediate Constant and ignore it.
753}
754
755/// Match an immediate Constant, capturing the value if we match.
760}
761
762/// Match a specified Value*.
764 const Value *Val;
765
766 specificval_ty(const Value *V) : Val(V) {}
767
768 template <typename ITy> bool match(ITy *V) { return V == Val; }
769};
770
771/// Match if we have a specific specified value.
772inline specificval_ty m_Specific(const Value *V) { return V; }
773
774/// Stores a reference to the Value *, not the Value * itself,
775/// thus can be used in commutative matchers.
776template <typename Class> struct deferredval_ty {
777 Class *const &Val;
778
779 deferredval_ty(Class *const &V) : Val(V) {}
780
781 template <typename ITy> bool match(ITy *const V) { return V == Val; }
782};
783
784/// Like m_Specific(), but works if the specific value to match is determined
785/// as part of the same match() expression. For example:
786/// m_Add(m_Value(X), m_Specific(X)) is incorrect, because m_Specific() will
787/// bind X before the pattern match starts.
788/// m_Add(m_Value(X), m_Deferred(X)) is correct, and will check against
789/// whichever value m_Value(X) populated.
790inline deferredval_ty<Value> m_Deferred(Value *const &V) { return V; }
792 return V;
793}
794
795/// Match a specified floating point value or vector of all elements of
796/// that value.
798 double Val;
799
800 specific_fpval(double V) : Val(V) {}
801
802 template <typename ITy> bool match(ITy *V) {
803 if (const auto *CFP = dyn_cast<ConstantFP>(V))
804 return CFP->isExactlyValue(Val);
805 if (V->getType()->isVectorTy())
806 if (const auto *C = dyn_cast<Constant>(V))
807 if (auto *CFP = dyn_cast_or_null<ConstantFP>(C->getSplatValue()))
808 return CFP->isExactlyValue(Val);
809 return false;
810 }
811};
812
813/// Match a specific floating point value or vector with all elements
814/// equal to the value.
815inline specific_fpval m_SpecificFP(double V) { return specific_fpval(V); }
816
817/// Match a float 1.0 or vector with all elements equal to 1.0.
818inline specific_fpval m_FPOne() { return m_SpecificFP(1.0); }
819
822
824
825 template <typename ITy> bool match(ITy *V) {
826 if (const auto *CV = dyn_cast<ConstantInt>(V))
827 if (CV->getValue().ule(UINT64_MAX)) {
828 VR = CV->getZExtValue();
829 return true;
830 }
831 return false;
832 }
833};
834
835/// Match a specified integer value or vector of all elements of that
836/// value.
837template <bool AllowUndefs> struct specific_intval {
839
841
842 template <typename ITy> bool match(ITy *V) {
843 const auto *CI = dyn_cast<ConstantInt>(V);
844 if (!CI && V->getType()->isVectorTy())
845 if (const auto *C = dyn_cast<Constant>(V))
846 CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowUndefs));
847
848 return CI && APInt::isSameValue(CI->getValue(), Val);
849 }
850};
851
852/// Match a specific integer value or vector with all elements equal to
853/// the value.
855 return specific_intval<false>(std::move(V));
856}
857
859 return m_SpecificInt(APInt(64, V));
860}
861
863 return specific_intval<true>(std::move(V));
864}
865
867 return m_SpecificIntAllowUndef(APInt(64, V));
868}
869
870/// Match a ConstantInt and bind to its value. This does not match
871/// ConstantInts wider than 64-bits.
873
874/// Match a specified basic block value.
877
879
880 template <typename ITy> bool match(ITy *V) {
881 const auto *BB = dyn_cast<BasicBlock>(V);
882 return BB && BB == Val;
883 }
884};
885
886/// Match a specific basic block value.
888 return specific_bbval(BB);
889}
890
891/// A commutative-friendly version of m_Specific().
893 return BB;
894}
896m_Deferred(const BasicBlock *const &BB) {
897 return BB;
898}
899
900//===----------------------------------------------------------------------===//
901// Matcher for any binary operator.
902//
903template <typename LHS_t, typename RHS_t, bool Commutable = false>
907
908 // The evaluation order is always stable, regardless of Commutability.
909 // The LHS is always matched first.
910 AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
911
912 template <typename OpTy> bool match(OpTy *V) {
913 if (auto *I = dyn_cast<BinaryOperator>(V))
914 return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
915 (Commutable && L.match(I->getOperand(1)) &&
916 R.match(I->getOperand(0)));
917 return false;
918 }
919};
920
921template <typename LHS, typename RHS>
922inline AnyBinaryOp_match<LHS, RHS> m_BinOp(const LHS &L, const RHS &R) {
923 return AnyBinaryOp_match<LHS, RHS>(L, R);
924}
925
926//===----------------------------------------------------------------------===//
927// Matcher for any unary operator.
928// TODO fuse unary, binary matcher into n-ary matcher
929//
930template <typename OP_t> struct AnyUnaryOp_match {
931 OP_t X;
932
933 AnyUnaryOp_match(const OP_t &X) : X(X) {}
934
935 template <typename OpTy> bool match(OpTy *V) {
936 if (auto *I = dyn_cast<UnaryOperator>(V))
937 return X.match(I->getOperand(0));
938 return false;
939 }
940};
941
942template <typename OP_t> inline AnyUnaryOp_match<OP_t> m_UnOp(const OP_t &X) {
944}
945
946//===----------------------------------------------------------------------===//
947// Matchers for specific binary operators.
948//
949
950template <typename LHS_t, typename RHS_t, unsigned Opcode,
951 bool Commutable = false>
955
956 // The evaluation order is always stable, regardless of Commutability.
957 // The LHS is always matched first.
958 BinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
959
960 template <typename OpTy> inline bool match(unsigned Opc, OpTy *V) {
961 if (V->getValueID() == Value::InstructionVal + Opc) {
962 auto *I = cast<BinaryOperator>(V);
963 return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
964 (Commutable && L.match(I->getOperand(1)) &&
965 R.match(I->getOperand(0)));
966 }
967 if (auto *CE = dyn_cast<ConstantExpr>(V))
968 return CE->getOpcode() == Opc &&
969 ((L.match(CE->getOperand(0)) && R.match(CE->getOperand(1))) ||
970 (Commutable && L.match(CE->getOperand(1)) &&
971 R.match(CE->getOperand(0))));
972 return false;
973 }
974
975 template <typename OpTy> bool match(OpTy *V) { return match(Opcode, V); }
976};
977
978template <typename LHS, typename RHS>
980 const RHS &R) {
982}
983
984template <typename LHS, typename RHS>
986 const RHS &R) {
988}
989
990template <typename LHS, typename RHS>
992 const RHS &R) {
994}
995
996template <typename LHS, typename RHS>
998 const RHS &R) {
1000}
1001
1002template <typename Op_t> struct FNeg_match {
1003 Op_t X;
1004
1005 FNeg_match(const Op_t &Op) : X(Op) {}
1006 template <typename OpTy> bool match(OpTy *V) {
1007 auto *FPMO = dyn_cast<FPMathOperator>(V);
1008 if (!FPMO)
1009 return false;
1010
1011 if (FPMO->getOpcode() == Instruction::FNeg)
1012 return X.match(FPMO->getOperand(0));
1013
1014 if (FPMO->getOpcode() == Instruction::FSub) {
1015 if (FPMO->hasNoSignedZeros()) {
1016 // With 'nsz', any zero goes.
1017 if (!cstfp_pred_ty<is_any_zero_fp>().match(FPMO->getOperand(0)))
1018 return false;
1019 } else {
1020 // Without 'nsz', we need fsub -0.0, X exactly.
1021 if (!cstfp_pred_ty<is_neg_zero_fp>().match(FPMO->getOperand(0)))
1022 return false;
1023 }
1024
1025 return X.match(FPMO->getOperand(1));
1026 }
1027
1028 return false;
1029 }
1030};
1031
1032/// Match 'fneg X' as 'fsub -0.0, X'.
1033template <typename OpTy> inline FNeg_match<OpTy> m_FNeg(const OpTy &X) {
1034 return FNeg_match<OpTy>(X);
1035}
1036
1037/// Match 'fneg X' as 'fsub +-0.0, X'.
1038template <typename RHS>
1039inline BinaryOp_match<cstfp_pred_ty<is_any_zero_fp>, RHS, Instruction::FSub>
1040m_FNegNSZ(const RHS &X) {
1041 return m_FSub(m_AnyZeroFP(), X);
1042}
1043
1044template <typename LHS, typename RHS>
1046 const RHS &R) {
1048}
1049
1050template <typename LHS, typename RHS>
1052 const RHS &R) {
1054}
1055
1056template <typename LHS, typename RHS>
1058 const RHS &R) {
1060}
1061
1062template <typename LHS, typename RHS>
1064 const RHS &R) {
1066}
1067
1068template <typename LHS, typename RHS>
1070 const RHS &R) {
1072}
1073
1074template <typename LHS, typename RHS>
1076 const RHS &R) {
1078}
1079
1080template <typename LHS, typename RHS>
1082 const RHS &R) {
1084}
1085
1086template <typename LHS, typename RHS>
1088 const RHS &R) {
1090}
1091
1092template <typename LHS, typename RHS>
1094 const RHS &R) {
1096}
1097
1098template <typename LHS, typename RHS>
1100 const RHS &R) {
1102}
1103
1104template <typename LHS, typename RHS>
1106 const RHS &R) {
1108}
1109
1110template <typename LHS, typename RHS>
1112 const RHS &R) {
1114}
1115
1116template <typename LHS, typename RHS>
1118 const RHS &R) {
1120}
1121
1122template <typename LHS, typename RHS>
1124 const RHS &R) {
1126}
1127
1128template <typename LHS_t, typename RHS_t, unsigned Opcode,
1129 unsigned WrapFlags = 0>
1133
1135 : L(LHS), R(RHS) {}
1136
1137 template <typename OpTy> bool match(OpTy *V) {
1138 if (auto *Op = dyn_cast<OverflowingBinaryOperator>(V)) {
1139 if (Op->getOpcode() != Opcode)
1140 return false;
1142 !Op->hasNoUnsignedWrap())
1143 return false;
1144 if ((WrapFlags & OverflowingBinaryOperator::NoSignedWrap) &&
1145 !Op->hasNoSignedWrap())
1146 return false;
1147 return L.match(Op->getOperand(0)) && R.match(Op->getOperand(1));
1148 }
1149 return false;
1150 }
1151};
1152
1153template <typename LHS, typename RHS>
1154inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1156m_NSWAdd(const LHS &L, const RHS &R) {
1157 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1159 R);
1160}
1161template <typename LHS, typename RHS>
1162inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1164m_NSWSub(const LHS &L, const RHS &R) {
1165 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1167 R);
1168}
1169template <typename LHS, typename RHS>
1170inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1172m_NSWMul(const LHS &L, const RHS &R) {
1173 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1175 R);
1176}
1177template <typename LHS, typename RHS>
1178inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1180m_NSWShl(const LHS &L, const RHS &R) {
1181 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1183 R);
1184}
1185
1186template <typename LHS, typename RHS>
1187inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1189m_NUWAdd(const LHS &L, const RHS &R) {
1190 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1192 L, R);
1193}
1194template <typename LHS, typename RHS>
1195inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1197m_NUWSub(const LHS &L, const RHS &R) {
1198 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1200 L, R);
1201}
1202template <typename LHS, typename RHS>
1203inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1205m_NUWMul(const LHS &L, const RHS &R) {
1206 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1208 L, R);
1209}
1210template <typename LHS, typename RHS>
1211inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1213m_NUWShl(const LHS &L, const RHS &R) {
1214 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1216 L, R);
1217}
1218
1219template <typename LHS_t, typename RHS_t, bool Commutable = false>
1221 : public BinaryOp_match<LHS_t, RHS_t, 0, Commutable> {
1222 unsigned Opcode;
1223
1225 : BinaryOp_match<LHS_t, RHS_t, 0, Commutable>(LHS, RHS), Opcode(Opcode) {}
1226
1227 template <typename OpTy> bool match(OpTy *V) {
1229 }
1230};
1231
1232/// Matches a specific opcode.
1233template <typename LHS, typename RHS>
1234inline SpecificBinaryOp_match<LHS, RHS> m_BinOp(unsigned Opcode, const LHS &L,
1235 const RHS &R) {
1236 return SpecificBinaryOp_match<LHS, RHS>(Opcode, L, R);
1237}
1238
1239//===----------------------------------------------------------------------===//
1240// Class that matches a group of binary opcodes.
1241//
1242template <typename LHS_t, typename RHS_t, typename Predicate>
1243struct BinOpPred_match : Predicate {
1246
1247 BinOpPred_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1248
1249 template <typename OpTy> bool match(OpTy *V) {
1250 if (auto *I = dyn_cast<Instruction>(V))
1251 return this->isOpType(I->getOpcode()) && L.match(I->getOperand(0)) &&
1252 R.match(I->getOperand(1));
1253 if (auto *CE = dyn_cast<ConstantExpr>(V))
1254 return this->isOpType(CE->getOpcode()) && L.match(CE->getOperand(0)) &&
1255 R.match(CE->getOperand(1));
1256 return false;
1257 }
1258};
1259
1261 bool isOpType(unsigned Opcode) { return Instruction::isShift(Opcode); }
1262};
1263
1265 bool isOpType(unsigned Opcode) {
1266 return Opcode == Instruction::LShr || Opcode == Instruction::AShr;
1267 }
1268};
1269
1271 bool isOpType(unsigned Opcode) {
1272 return Opcode == Instruction::LShr || Opcode == Instruction::Shl;
1273 }
1274};
1275
1277 bool isOpType(unsigned Opcode) {
1278 return Instruction::isBitwiseLogicOp(Opcode);
1279 }
1280};
1281
1283 bool isOpType(unsigned Opcode) {
1284 return Opcode == Instruction::SDiv || Opcode == Instruction::UDiv;
1285 }
1286};
1287
1289 bool isOpType(unsigned Opcode) {
1290 return Opcode == Instruction::SRem || Opcode == Instruction::URem;
1291 }
1292};
1293
1294/// Matches shift operations.
1295template <typename LHS, typename RHS>
1297 const RHS &R) {
1299}
1300
1301/// Matches logical shift operations.
1302template <typename LHS, typename RHS>
1304 const RHS &R) {
1306}
1307
1308/// Matches logical shift operations.
1309template <typename LHS, typename RHS>
1311m_LogicalShift(const LHS &L, const RHS &R) {
1313}
1314
1315/// Matches bitwise logic operations.
1316template <typename LHS, typename RHS>
1318m_BitwiseLogic(const LHS &L, const RHS &R) {
1320}
1321
1322/// Matches integer division operations.
1323template <typename LHS, typename RHS>
1325 const RHS &R) {
1327}
1328
1329/// Matches integer remainder operations.
1330template <typename LHS, typename RHS>
1332 const RHS &R) {
1334}
1335
1336//===----------------------------------------------------------------------===//
1337// Class that matches exact binary ops.
1338//
1339template <typename SubPattern_t> struct Exact_match {
1340 SubPattern_t SubPattern;
1341
1342 Exact_match(const SubPattern_t &SP) : SubPattern(SP) {}
1343
1344 template <typename OpTy> bool match(OpTy *V) {
1345 if (auto *PEO = dyn_cast<PossiblyExactOperator>(V))
1346 return PEO->isExact() && SubPattern.match(V);
1347 return false;
1348 }
1349};
1350
1351template <typename T> inline Exact_match<T> m_Exact(const T &SubPattern) {
1352 return SubPattern;
1353}
1354
1355//===----------------------------------------------------------------------===//
1356// Matchers for CmpInst classes
1357//
1358
1359template <typename LHS_t, typename RHS_t, typename Class, typename PredicateTy,
1360 bool Commutable = false>
1362 PredicateTy &Predicate;
1365
1366 // The evaluation order is always stable, regardless of Commutability.
1367 // The LHS is always matched first.
1368 CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
1369 : Predicate(Pred), L(LHS), R(RHS) {}
1370
1371 template <typename OpTy> bool match(OpTy *V) {
1372 if (auto *I = dyn_cast<Class>(V)) {
1373 if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
1374 Predicate = I->getPredicate();
1375 return true;
1376 } else if (Commutable && L.match(I->getOperand(1)) &&
1377 R.match(I->getOperand(0))) {
1378 Predicate = I->getSwappedPredicate();
1379 return true;
1380 }
1381 }
1382 return false;
1383 }
1384};
1385
1386template <typename LHS, typename RHS>
1388m_Cmp(CmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1390}
1391
1392template <typename LHS, typename RHS>
1394m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1396}
1397
1398template <typename LHS, typename RHS>
1400m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1402}
1403
1404//===----------------------------------------------------------------------===//
1405// Matchers for instructions with a given opcode and number of operands.
1406//
1407
1408/// Matches instructions with Opcode and three operands.
1409template <typename T0, unsigned Opcode> struct OneOps_match {
1411
1412 OneOps_match(const T0 &Op1) : Op1(Op1) {}
1413
1414 template <typename OpTy> bool match(OpTy *V) {
1415 if (V->getValueID() == Value::InstructionVal + Opcode) {
1416 auto *I = cast<Instruction>(V);
1417 return Op1.match(I->getOperand(0));
1418 }
1419 return false;
1420 }
1421};
1422
1423/// Matches instructions with Opcode and three operands.
1424template <typename T0, typename T1, unsigned Opcode> struct TwoOps_match {
1427
1428 TwoOps_match(const T0 &Op1, const T1 &Op2) : Op1(Op1), Op2(Op2) {}
1429
1430 template <typename OpTy> bool match(OpTy *V) {
1431 if (V->getValueID() == Value::InstructionVal + Opcode) {
1432 auto *I = cast<Instruction>(V);
1433 return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1));
1434 }
1435 return false;
1436 }
1437};
1438
1439/// Matches instructions with Opcode and three operands.
1440template <typename T0, typename T1, typename T2, unsigned Opcode>
1445
1446 ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
1447 : Op1(Op1), Op2(Op2), Op3(Op3) {}
1448
1449 template <typename OpTy> bool match(OpTy *V) {
1450 if (V->getValueID() == Value::InstructionVal + Opcode) {
1451 auto *I = cast<Instruction>(V);
1452 return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1453 Op3.match(I->getOperand(2));
1454 }
1455 return false;
1456 }
1457};
1458
1459/// Matches SelectInst.
1460template <typename Cond, typename LHS, typename RHS>
1462m_Select(const Cond &C, const LHS &L, const RHS &R) {
1464}
1465
1466/// This matches a select of two constants, e.g.:
1467/// m_SelectCst<-1, 0>(m_Value(V))
1468template <int64_t L, int64_t R, typename Cond>
1470 Instruction::Select>
1472 return m_Select(C, m_ConstantInt<L>(), m_ConstantInt<R>());
1473}
1474
1475/// Matches FreezeInst.
1476template <typename OpTy>
1479}
1480
1481/// Matches InsertElementInst.
1482template <typename Val_t, typename Elt_t, typename Idx_t>
1484m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx) {
1486 Val, Elt, Idx);
1487}
1488
1489/// Matches ExtractElementInst.
1490template <typename Val_t, typename Idx_t>
1492m_ExtractElt(const Val_t &Val, const Idx_t &Idx) {
1494}
1495
1496/// Matches shuffle.
1497template <typename T0, typename T1, typename T2> struct Shuffle_match {
1501
1502 Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
1503 : Op1(Op1), Op2(Op2), Mask(Mask) {}
1504
1505 template <typename OpTy> bool match(OpTy *V) {
1506 if (auto *I = dyn_cast<ShuffleVectorInst>(V)) {
1507 return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1508 Mask.match(I->getShuffleMask());
1509 }
1510 return false;
1511 }
1512};
1513
1514struct m_Mask {
1518 MaskRef = Mask;
1519 return true;
1520 }
1521};
1522
1525 return all_of(Mask, [](int Elem) { return Elem == 0 || Elem == -1; });
1526 }
1527};
1528
1532 bool match(ArrayRef<int> Mask) { return MaskRef == Mask; }
1533};
1534
1539 const auto *First = find_if(Mask, [](int Elem) { return Elem != -1; });
1540 if (First == Mask.end())
1541 return false;
1542 SplatIndex = *First;
1543 return all_of(Mask,
1544 [First](int Elem) { return Elem == *First || Elem == -1; });
1545 }
1546};
1547
1548/// Matches ShuffleVectorInst independently of mask value.
1549template <typename V1_t, typename V2_t>
1551m_Shuffle(const V1_t &v1, const V2_t &v2) {
1553}
1554
1555template <typename V1_t, typename V2_t, typename Mask_t>
1557m_Shuffle(const V1_t &v1, const V2_t &v2, const Mask_t &mask) {
1558 return Shuffle_match<V1_t, V2_t, Mask_t>(v1, v2, mask);
1559}
1560
1561/// Matches LoadInst.
1562template <typename OpTy>
1565}
1566
1567/// Matches StoreInst.
1568template <typename ValueOpTy, typename PointerOpTy>
1570m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp) {
1572 PointerOp);
1573}
1574
1575//===----------------------------------------------------------------------===//
1576// Matchers for CastInst classes
1577//
1578
1579template <typename Op_t, unsigned Opcode> struct CastClass_match {
1580 Op_t Op;
1581
1582 CastClass_match(const Op_t &OpMatch) : Op(OpMatch) {}
1583
1584 template <typename OpTy> bool match(OpTy *V) {
1585 if (auto *O = dyn_cast<Operator>(V))
1586 return O->getOpcode() == Opcode && Op.match(O->getOperand(0));
1587 return false;
1588 }
1589};
1590
1591/// Matches BitCast.
1592template <typename OpTy>
1595}
1596
1597/// Matches PtrToInt.
1598template <typename OpTy>
1601}
1602
1603/// Matches IntToPtr.
1604template <typename OpTy>
1607}
1608
1609/// Matches Trunc.
1610template <typename OpTy>
1613}
1614
1615template <typename OpTy>
1617m_TruncOrSelf(const OpTy &Op) {
1618 return m_CombineOr(m_Trunc(Op), Op);
1619}
1620
1621/// Matches SExt.
1622template <typename OpTy>
1625}
1626
1627/// Matches ZExt.
1628template <typename OpTy>
1631}
1632
1633template <typename OpTy>
1635m_ZExtOrSelf(const OpTy &Op) {
1636 return m_CombineOr(m_ZExt(Op), Op);
1637}
1638
1639template <typename OpTy>
1641m_SExtOrSelf(const OpTy &Op) {
1642 return m_CombineOr(m_SExt(Op), Op);
1643}
1644
1645template <typename OpTy>
1648m_ZExtOrSExt(const OpTy &Op) {
1649 return m_CombineOr(m_ZExt(Op), m_SExt(Op));
1650}
1651
1652template <typename OpTy>
1653inline match_combine_or<
1656 OpTy>
1657m_ZExtOrSExtOrSelf(const OpTy &Op) {
1658 return m_CombineOr(m_ZExtOrSExt(Op), Op);
1659}
1660
1661template <typename OpTy>
1664}
1665
1666template <typename OpTy>
1669}
1670
1671template <typename OpTy>
1674}
1675
1676template <typename OpTy>
1679}
1680
1681template <typename OpTy>
1684}
1685
1686template <typename OpTy>
1689}
1690
1691//===----------------------------------------------------------------------===//
1692// Matchers for control flow.
1693//
1694
1695struct br_match {
1697
1699
1700 template <typename OpTy> bool match(OpTy *V) {
1701 if (auto *BI = dyn_cast<BranchInst>(V))
1702 if (BI->isUnconditional()) {
1703 Succ = BI->getSuccessor(0);
1704 return true;
1705 }
1706 return false;
1707 }
1708};
1709
1710inline br_match m_UnconditionalBr(BasicBlock *&Succ) { return br_match(Succ); }
1711
1712template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1714 Cond_t Cond;
1715 TrueBlock_t T;
1716 FalseBlock_t F;
1717
1718 brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
1719 : Cond(C), T(t), F(f) {}
1720
1721 template <typename OpTy> bool match(OpTy *V) {
1722 if (auto *BI = dyn_cast<BranchInst>(V))
1723 if (BI->isConditional() && Cond.match(BI->getCondition()))
1724 return T.match(BI->getSuccessor(0)) && F.match(BI->getSuccessor(1));
1725 return false;
1726 }
1727};
1728
1729template <typename Cond_t>
1731m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F) {
1734}
1735
1736template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
1738m_Br(const Cond_t &C, const TrueBlock_t &T, const FalseBlock_t &F) {
1740}
1741
1742//===----------------------------------------------------------------------===//
1743// Matchers for max/min idioms, eg: "select (sgt x, y), x, y" -> smax(x,y).
1744//
1745
1746template <typename CmpInst_t, typename LHS_t, typename RHS_t, typename Pred_t,
1747 bool Commutable = false>
1749 using PredType = Pred_t;
1752
1753 // The evaluation order is always stable, regardless of Commutability.
1754 // The LHS is always matched first.
1755 MaxMin_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1756
1757 template <typename OpTy> bool match(OpTy *V) {
1758 if (auto *II = dyn_cast<IntrinsicInst>(V)) {
1759 Intrinsic::ID IID = II->getIntrinsicID();
1760 if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
1761 (IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
1762 (IID == Intrinsic::umax && Pred_t::match(ICmpInst::ICMP_UGT)) ||
1763 (IID == Intrinsic::umin && Pred_t::match(ICmpInst::ICMP_ULT))) {
1764 Value *LHS = II->getOperand(0), *RHS = II->getOperand(1);
1765 return (L.match(LHS) && R.match(RHS)) ||
1766 (Commutable && L.match(RHS) && R.match(LHS));
1767 }
1768 }
1769 // Look for "(x pred y) ? x : y" or "(x pred y) ? y : x".
1770 auto *SI = dyn_cast<SelectInst>(V);
1771 if (!SI)
1772 return false;
1773 auto *Cmp = dyn_cast<CmpInst_t>(SI->getCondition());
1774 if (!Cmp)
1775 return false;
1776 // At this point we have a select conditioned on a comparison. Check that
1777 // it is the values returned by the select that are being compared.
1778 auto *TrueVal = SI->getTrueValue();
1779 auto *FalseVal = SI->getFalseValue();
1780 auto *LHS = Cmp->getOperand(0);
1781 auto *RHS = Cmp->getOperand(1);
1782 if ((TrueVal != LHS || FalseVal != RHS) &&
1783 (TrueVal != RHS || FalseVal != LHS))
1784 return false;
1785 typename CmpInst_t::Predicate Pred =
1786 LHS == TrueVal ? Cmp->getPredicate() : Cmp->getInversePredicate();
1787 // Does "(x pred y) ? x : y" represent the desired max/min operation?
1788 if (!Pred_t::match(Pred))
1789 return false;
1790 // It does! Bind the operands.
1791 return (L.match(LHS) && R.match(RHS)) ||
1792 (Commutable && L.match(RHS) && R.match(LHS));
1793 }
1794};
1795
1796/// Helper class for identifying signed max predicates.
1798 static bool match(ICmpInst::Predicate Pred) {
1799 return Pred == CmpInst::ICMP_SGT || Pred == CmpInst::ICMP_SGE;
1800 }
1801};
1802
1803/// Helper class for identifying signed min predicates.
1805 static bool match(ICmpInst::Predicate Pred) {
1806 return Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_SLE;
1807 }
1808};
1809
1810/// Helper class for identifying unsigned max predicates.
1812 static bool match(ICmpInst::Predicate Pred) {
1813 return Pred == CmpInst::ICMP_UGT || Pred == CmpInst::ICMP_UGE;
1814 }
1815};
1816
1817/// Helper class for identifying unsigned min predicates.
1819 static bool match(ICmpInst::Predicate Pred) {
1820 return Pred == CmpInst::ICMP_ULT || Pred == CmpInst::ICMP_ULE;
1821 }
1822};
1823
1824/// Helper class for identifying ordered max predicates.
1826 static bool match(FCmpInst::Predicate Pred) {
1827 return Pred == CmpInst::FCMP_OGT || Pred == CmpInst::FCMP_OGE;
1828 }
1829};
1830
1831/// Helper class for identifying ordered min predicates.
1833 static bool match(FCmpInst::Predicate Pred) {
1834 return Pred == CmpInst::FCMP_OLT || Pred == CmpInst::FCMP_OLE;
1835 }
1836};
1837
1838/// Helper class for identifying unordered max predicates.
1840 static bool match(FCmpInst::Predicate Pred) {
1841 return Pred == CmpInst::FCMP_UGT || Pred == CmpInst::FCMP_UGE;
1842 }
1843};
1844
1845/// Helper class for identifying unordered min predicates.
1847 static bool match(FCmpInst::Predicate Pred) {
1848 return Pred == CmpInst::FCMP_ULT || Pred == CmpInst::FCMP_ULE;
1849 }
1850};
1851
1852template <typename LHS, typename RHS>
1854 const RHS &R) {
1856}
1857
1858template <typename LHS, typename RHS>
1860 const RHS &R) {
1862}
1863
1864template <typename LHS, typename RHS>
1866 const RHS &R) {
1868}
1869
1870template <typename LHS, typename RHS>
1872 const RHS &R) {
1874}
1875
1876template <typename LHS, typename RHS>
1877inline match_combine_or<
1882m_MaxOrMin(const LHS &L, const RHS &R) {
1883 return m_CombineOr(m_CombineOr(m_SMax(L, R), m_SMin(L, R)),
1884 m_CombineOr(m_UMax(L, R), m_UMin(L, R)));
1885}
1886
1887/// Match an 'ordered' floating point maximum function.
1888/// Floating point has one special value 'NaN'. Therefore, there is no total
1889/// order. However, if we can ignore the 'NaN' value (for example, because of a
1890/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1891/// semantics. In the presence of 'NaN' we have to preserve the original
1892/// select(fcmp(ogt/ge, L, R), L, R) semantics matched by this predicate.
1893///
1894/// max(L, R) iff L and R are not NaN
1895/// m_OrdFMax(L, R) = R iff L or R are NaN
1896template <typename LHS, typename RHS>
1898 const RHS &R) {
1900}
1901
1902/// Match an 'ordered' floating point minimum function.
1903/// Floating point has one special value 'NaN'. Therefore, there is no total
1904/// order. However, if we can ignore the 'NaN' value (for example, because of a
1905/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1906/// semantics. In the presence of 'NaN' we have to preserve the original
1907/// select(fcmp(olt/le, L, R), L, R) semantics matched by this predicate.
1908///
1909/// min(L, R) iff L and R are not NaN
1910/// m_OrdFMin(L, R) = R iff L or R are NaN
1911template <typename LHS, typename RHS>
1913 const RHS &R) {
1915}
1916
1917/// Match an 'unordered' floating point maximum function.
1918/// Floating point has one special value 'NaN'. Therefore, there is no total
1919/// order. However, if we can ignore the 'NaN' value (for example, because of a
1920/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
1921/// semantics. In the presence of 'NaN' we have to preserve the original
1922/// select(fcmp(ugt/ge, L, R), L, R) semantics matched by this predicate.
1923///
1924/// max(L, R) iff L and R are not NaN
1925/// m_UnordFMax(L, R) = L iff L or R are NaN
1926template <typename LHS, typename RHS>
1928m_UnordFMax(const LHS &L, const RHS &R) {
1930}
1931
1932/// Match an 'unordered' floating point minimum function.
1933/// Floating point has one special value 'NaN'. Therefore, there is no total
1934/// order. However, if we can ignore the 'NaN' value (for example, because of a
1935/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
1936/// semantics. In the presence of 'NaN' we have to preserve the original
1937/// select(fcmp(ult/le, L, R), L, R) semantics matched by this predicate.
1938///
1939/// min(L, R) iff L and R are not NaN
1940/// m_UnordFMin(L, R) = L iff L or R are NaN
1941template <typename LHS, typename RHS>
1943m_UnordFMin(const LHS &L, const RHS &R) {
1945}
1946
1947//===----------------------------------------------------------------------===//
1948// Matchers for overflow check patterns: e.g. (a + b) u< a, (a ^ -1) <u b
1949// Note that S might be matched to other instructions than AddInst.
1950//
1951
1952template <typename LHS_t, typename RHS_t, typename Sum_t>
1956 Sum_t S;
1957
1958 UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
1959 : L(L), R(R), S(S) {}
1960
1961 template <typename OpTy> bool match(OpTy *V) {
1962 Value *ICmpLHS, *ICmpRHS;
1964 if (!m_ICmp(Pred, m_Value(ICmpLHS), m_Value(ICmpRHS)).match(V))
1965 return false;
1966
1967 Value *AddLHS, *AddRHS;
1968 auto AddExpr = m_Add(m_Value(AddLHS), m_Value(AddRHS));
1969
1970 // (a + b) u< a, (a + b) u< b
1971 if (Pred == ICmpInst::ICMP_ULT)
1972 if (AddExpr.match(ICmpLHS) && (ICmpRHS == AddLHS || ICmpRHS == AddRHS))
1973 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
1974
1975 // a >u (a + b), b >u (a + b)
1976 if (Pred == ICmpInst::ICMP_UGT)
1977 if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
1978 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
1979
1980 Value *Op1;
1981 auto XorExpr = m_OneUse(m_Xor(m_Value(Op1), m_AllOnes()));
1982 // (a ^ -1) <u b
1983 if (Pred == ICmpInst::ICMP_ULT) {
1984 if (XorExpr.match(ICmpLHS))
1985 return L.match(Op1) && R.match(ICmpRHS) && S.match(ICmpLHS);
1986 }
1987 // b > u (a ^ -1)
1988 if (Pred == ICmpInst::ICMP_UGT) {
1989 if (XorExpr.match(ICmpRHS))
1990 return L.match(Op1) && R.match(ICmpLHS) && S.match(ICmpRHS);
1991 }
1992
1993 // Match special-case for increment-by-1.
1994 if (Pred == ICmpInst::ICMP_EQ) {
1995 // (a + 1) == 0
1996 // (1 + a) == 0
1997 if (AddExpr.match(ICmpLHS) && m_ZeroInt().match(ICmpRHS) &&
1998 (m_One().match(AddLHS) || m_One().match(AddRHS)))
1999 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
2000 // 0 == (a + 1)
2001 // 0 == (1 + a)
2002 if (m_ZeroInt().match(ICmpLHS) && AddExpr.match(ICmpRHS) &&
2003 (m_One().match(AddLHS) || m_One().match(AddRHS)))
2004 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
2005 }
2006
2007 return false;
2008 }
2009};
2010
2011/// Match an icmp instruction checking for unsigned overflow on addition.
2012///
2013/// S is matched to the addition whose result is being checked for overflow, and
2014/// L and R are matched to the LHS and RHS of S.
2015template <typename LHS_t, typename RHS_t, typename Sum_t>
2017m_UAddWithOverflow(const LHS_t &L, const RHS_t &R, const Sum_t &S) {
2019}
2020
2021template <typename Opnd_t> struct Argument_match {
2022 unsigned OpI;
2023 Opnd_t Val;
2024
2025 Argument_match(unsigned OpIdx, const Opnd_t &V) : OpI(OpIdx), Val(V) {}
2026
2027 template <typename OpTy> bool match(OpTy *V) {
2028 // FIXME: Should likely be switched to use `CallBase`.
2029 if (const auto *CI = dyn_cast<CallInst>(V))
2030 return Val.match(CI->getArgOperand(OpI));
2031 return false;
2032 }
2033};
2034
2035/// Match an argument.
2036template <unsigned OpI, typename Opnd_t>
2037inline Argument_match<Opnd_t> m_Argument(const Opnd_t &Op) {
2038 return Argument_match<Opnd_t>(OpI, Op);
2039}
2040
2041/// Intrinsic matchers.
2043 unsigned ID;
2044
2046
2047 template <typename OpTy> bool match(OpTy *V) {
2048 if (const auto *CI = dyn_cast<CallInst>(V))
2049 if (const auto *F = CI->getCalledFunction())
2050 return F->getIntrinsicID() == ID;
2051 return false;
2052 }
2053};
2054
2055/// Intrinsic matches are combinations of ID matchers, and argument
2056/// matchers. Higher arity matcher are defined recursively in terms of and-ing
2057/// them with lower arity matchers. Here's some convenient typedefs for up to
2058/// several arguments, and more can be added as needed
2059template <typename T0 = void, typename T1 = void, typename T2 = void,
2060 typename T3 = void, typename T4 = void, typename T5 = void,
2061 typename T6 = void, typename T7 = void, typename T8 = void,
2062 typename T9 = void, typename T10 = void>
2064template <typename T0> struct m_Intrinsic_Ty<T0> {
2066};
2067template <typename T0, typename T1> struct m_Intrinsic_Ty<T0, T1> {
2068 using Ty =
2070};
2071template <typename T0, typename T1, typename T2>
2072struct m_Intrinsic_Ty<T0, T1, T2> {
2075};
2076template <typename T0, typename T1, typename T2, typename T3>
2077struct m_Intrinsic_Ty<T0, T1, T2, T3> {
2080};
2081
2082template <typename T0, typename T1, typename T2, typename T3, typename T4>
2083struct m_Intrinsic_Ty<T0, T1, T2, T3, T4> {
2086};
2087
2088template <typename T0, typename T1, typename T2, typename T3, typename T4,
2089 typename T5>
2090struct m_Intrinsic_Ty<T0, T1, T2, T3, T4, T5> {
2093};
2094
2095/// Match intrinsic calls like this:
2096/// m_Intrinsic<Intrinsic::fabs>(m_Value(X))
2097template <Intrinsic::ID IntrID> inline IntrinsicID_match m_Intrinsic() {
2098 return IntrinsicID_match(IntrID);
2099}
2100
2101/// Matches MaskedLoad Intrinsic.
2102template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2104m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2105 const Opnd3 &Op3) {
2106 return m_Intrinsic<Intrinsic::masked_load>(Op0, Op1, Op2, Op3);
2107}
2108
2109/// Matches MaskedGather Intrinsic.
2110template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2112m_MaskedGather(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2113 const Opnd3 &Op3) {
2114 return m_Intrinsic<Intrinsic::masked_gather>(Op0, Op1, Op2, Op3);
2115}
2116
2117template <Intrinsic::ID IntrID, typename T0>
2118inline typename m_Intrinsic_Ty<T0>::Ty m_Intrinsic(const T0 &Op0) {
2119 return m_CombineAnd(m_Intrinsic<IntrID>(), m_Argument<0>(Op0));
2120}
2121
2122template <Intrinsic::ID IntrID, typename T0, typename T1>
2123inline typename m_Intrinsic_Ty<T0, T1>::Ty m_Intrinsic(const T0 &Op0,
2124 const T1 &Op1) {
2125 return m_CombineAnd(m_Intrinsic<IntrID>(Op0), m_Argument<1>(Op1));
2126}
2127
2128template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2>
2129inline typename m_Intrinsic_Ty<T0, T1, T2>::Ty
2130m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2) {
2131 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1), m_Argument<2>(Op2));
2132}
2133
2134template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2135 typename T3>
2137m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3) {
2138 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2), m_Argument<3>(Op3));
2139}
2140
2141template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2142 typename T3, typename T4>
2144m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2145 const T4 &Op4) {
2146 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3),
2147 m_Argument<4>(Op4));
2148}
2149
2150template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2151 typename T3, typename T4, typename T5>
2153m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2154 const T4 &Op4, const T5 &Op5) {
2155 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3, Op4),
2156 m_Argument<5>(Op5));
2157}
2158
2159// Helper intrinsic matching specializations.
2160template <typename Opnd0>
2161inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BitReverse(const Opnd0 &Op0) {
2162 return m_Intrinsic<Intrinsic::bitreverse>(Op0);
2163}
2164
2165template <typename Opnd0>
2166inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BSwap(const Opnd0 &Op0) {
2167 return m_Intrinsic<Intrinsic::bswap>(Op0);
2168}
2169
2170template <typename Opnd0>
2171inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FAbs(const Opnd0 &Op0) {
2172 return m_Intrinsic<Intrinsic::fabs>(Op0);
2173}
2174
2175template <typename Opnd0>
2176inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FCanonicalize(const Opnd0 &Op0) {
2177 return m_Intrinsic<Intrinsic::canonicalize>(Op0);
2178}
2179
2180template <typename Opnd0, typename Opnd1>
2181inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMin(const Opnd0 &Op0,
2182 const Opnd1 &Op1) {
2183 return m_Intrinsic<Intrinsic::minnum>(Op0, Op1);
2184}
2185
2186template <typename Opnd0, typename Opnd1>
2187inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMax(const Opnd0 &Op0,
2188 const Opnd1 &Op1) {
2189 return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
2190}
2191
2192template <typename Opnd0, typename Opnd1, typename Opnd2>
2194m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2195 return m_Intrinsic<Intrinsic::fshl>(Op0, Op1, Op2);
2196}
2197
2198template <typename Opnd0, typename Opnd1, typename Opnd2>
2200m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2201 return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
2202}
2203
2204template <typename Opnd0>
2205inline typename m_Intrinsic_Ty<Opnd0>::Ty m_Sqrt(const Opnd0 &Op0) {
2206 return m_Intrinsic<Intrinsic::sqrt>(Op0);
2207}
2208
2209template <typename Opnd0, typename Opnd1>
2210inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_CopySign(const Opnd0 &Op0,
2211 const Opnd1 &Op1) {
2212 return m_Intrinsic<Intrinsic::copysign>(Op0, Op1);
2213}
2214
2215template <typename Opnd0>
2216inline typename m_Intrinsic_Ty<Opnd0>::Ty m_VecReverse(const Opnd0 &Op0) {
2217 return m_Intrinsic<Intrinsic::experimental_vector_reverse>(Op0);
2218}
2219
2220//===----------------------------------------------------------------------===//
2221// Matchers for two-operands operators with the operators in either order
2222//
2223
2224/// Matches a BinaryOperator with LHS and RHS in either order.
2225template <typename LHS, typename RHS>
2228}
2229
2230/// Matches an ICmp with a predicate over LHS and RHS in either order.
2231/// Swaps the predicate if operands are commuted.
2232template <typename LHS, typename RHS>
2234m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
2236 R);
2237}
2238
2239/// Matches a specific opcode with LHS and RHS in either order.
2240template <typename LHS, typename RHS>
2242m_c_BinOp(unsigned Opcode, const LHS &L, const RHS &R) {
2243 return SpecificBinaryOp_match<LHS, RHS, true>(Opcode, L, R);
2244}
2245
2246/// Matches a Add with LHS and RHS in either order.
2247template <typename LHS, typename RHS>
2249 const RHS &R) {
2251}
2252
2253/// Matches a Mul with LHS and RHS in either order.
2254template <typename LHS, typename RHS>
2256 const RHS &R) {
2258}
2259
2260/// Matches an And with LHS and RHS in either order.
2261template <typename LHS, typename RHS>
2263 const RHS &R) {
2265}
2266
2267/// Matches an Or with LHS and RHS in either order.
2268template <typename LHS, typename RHS>
2270 const RHS &R) {
2272}
2273
2274/// Matches an Xor with LHS and RHS in either order.
2275template <typename LHS, typename RHS>
2277 const RHS &R) {
2279}
2280
2281/// Matches a 'Neg' as 'sub 0, V'.
2282template <typename ValTy>
2283inline BinaryOp_match<cst_pred_ty<is_zero_int>, ValTy, Instruction::Sub>
2284m_Neg(const ValTy &V) {
2285 return m_Sub(m_ZeroInt(), V);
2286}
2287
2288/// Matches a 'Neg' as 'sub nsw 0, V'.
2289template <typename ValTy>
2291 Instruction::Sub,
2293m_NSWNeg(const ValTy &V) {
2294 return m_NSWSub(m_ZeroInt(), V);
2295}
2296
2297/// Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
2298/// NOTE: we first match the 'Not' (by matching '-1'),
2299/// and only then match the inner matcher!
2300template <typename ValTy>
2301inline BinaryOp_match<cst_pred_ty<is_all_ones>, ValTy, Instruction::Xor, true>
2302m_Not(const ValTy &V) {
2303 return m_c_Xor(m_AllOnes(), V);
2304}
2305
2306template <typename ValTy> struct NotForbidUndef_match {
2307 ValTy Val;
2308 NotForbidUndef_match(const ValTy &V) : Val(V) {}
2309
2310 template <typename OpTy> bool match(OpTy *V) {
2311 // We do not use m_c_Xor because that could match an arbitrary APInt that is
2312 // not -1 as C and then fail to match the other operand if it is -1.
2313 // This code should still work even when both operands are constants.
2314 Value *X;
2315 const APInt *C;
2316 if (m_Xor(m_Value(X), m_APIntForbidUndef(C)).match(V) && C->isAllOnes())
2317 return Val.match(X);
2318 if (m_Xor(m_APIntForbidUndef(C), m_Value(X)).match(V) && C->isAllOnes())
2319 return Val.match(X);
2320 return false;
2321 }
2322};
2323
2324/// Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'. For vectors, the
2325/// constant value must be composed of only -1 scalar elements.
2326template <typename ValTy>
2329}
2330
2331/// Matches an SMin with LHS and RHS in either order.
2332template <typename LHS, typename RHS>
2334m_c_SMin(const LHS &L, const RHS &R) {
2336}
2337/// Matches an SMax with LHS and RHS in either order.
2338template <typename LHS, typename RHS>
2340m_c_SMax(const LHS &L, const RHS &R) {
2342}
2343/// Matches a UMin with LHS and RHS in either order.
2344template <typename LHS, typename RHS>
2346m_c_UMin(const LHS &L, const RHS &R) {
2348}
2349/// Matches a UMax with LHS and RHS in either order.
2350template <typename LHS, typename RHS>
2352m_c_UMax(const LHS &L, const RHS &R) {
2354}
2355
2356template <typename LHS, typename RHS>
2357inline match_combine_or<
2362m_c_MaxOrMin(const LHS &L, const RHS &R) {
2363 return m_CombineOr(m_CombineOr(m_c_SMax(L, R), m_c_SMin(L, R)),
2364 m_CombineOr(m_c_UMax(L, R), m_c_UMin(L, R)));
2365}
2366
2367/// Matches FAdd with LHS and RHS in either order.
2368template <typename LHS, typename RHS>
2370m_c_FAdd(const LHS &L, const RHS &R) {
2372}
2373
2374/// Matches FMul with LHS and RHS in either order.
2375template <typename LHS, typename RHS>
2377m_c_FMul(const LHS &L, const RHS &R) {
2379}
2380
2381template <typename Opnd_t> struct Signum_match {
2382 Opnd_t Val;
2383 Signum_match(const Opnd_t &V) : Val(V) {}
2384
2385 template <typename OpTy> bool match(OpTy *V) {
2386 unsigned TypeSize = V->getType()->getScalarSizeInBits();
2387 if (TypeSize == 0)
2388 return false;
2389
2390 unsigned ShiftWidth = TypeSize - 1;
2391 Value *OpL = nullptr, *OpR = nullptr;
2392
2393 // This is the representation of signum we match:
2394 //
2395 // signum(x) == (x >> 63) | (-x >>u 63)
2396 //
2397 // An i1 value is its own signum, so it's correct to match
2398 //
2399 // signum(x) == (x >> 0) | (-x >>u 0)
2400 //
2401 // for i1 values.
2402
2403 auto LHS = m_AShr(m_Value(OpL), m_SpecificInt(ShiftWidth));
2404 auto RHS = m_LShr(m_Neg(m_Value(OpR)), m_SpecificInt(ShiftWidth));
2405 auto Signum = m_Or(LHS, RHS);
2406
2407 return Signum.match(V) && OpL == OpR && Val.match(OpL);
2408 }
2409};
2410
2411/// Matches a signum pattern.
2412///
2413/// signum(x) =
2414/// x > 0 -> 1
2415/// x == 0 -> 0
2416/// x < 0 -> -1
2417template <typename Val_t> inline Signum_match<Val_t> m_Signum(const Val_t &V) {
2418 return Signum_match<Val_t>(V);
2419}
2420
2421template <int Ind, typename Opnd_t> struct ExtractValue_match {
2422 Opnd_t Val;
2423 ExtractValue_match(const Opnd_t &V) : Val(V) {}
2424
2425 template <typename OpTy> bool match(OpTy *V) {
2426 if (auto *I = dyn_cast<ExtractValueInst>(V)) {
2427 // If Ind is -1, don't inspect indices
2428 if (Ind != -1 &&
2429 !(I->getNumIndices() == 1 && I->getIndices()[0] == (unsigned)Ind))
2430 return false;
2431 return Val.match(I->getAggregateOperand());
2432 }
2433 return false;
2434 }
2435};
2436
2437/// Match a single index ExtractValue instruction.
2438/// For example m_ExtractValue<1>(...)
2439template <int Ind, typename Val_t>
2442}
2443
2444/// Match an ExtractValue instruction with any index.
2445/// For example m_ExtractValue(...)
2446template <typename Val_t>
2447inline ExtractValue_match<-1, Val_t> m_ExtractValue(const Val_t &V) {
2448 return ExtractValue_match<-1, Val_t>(V);
2449}
2450
2451/// Matcher for a single index InsertValue instruction.
2452template <int Ind, typename T0, typename T1> struct InsertValue_match {
2455
2456 InsertValue_match(const T0 &Op0, const T1 &Op1) : Op0(Op0), Op1(Op1) {}
2457
2458 template <typename OpTy> bool match(OpTy *V) {
2459 if (auto *I = dyn_cast<InsertValueInst>(V)) {
2460 return Op0.match(I->getOperand(0)) && Op1.match(I->getOperand(1)) &&
2461 I->getNumIndices() == 1 && Ind == I->getIndices()[0];
2462 }
2463 return false;
2464 }
2465};
2466
2467/// Matches a single index InsertValue instruction.
2468template <int Ind, typename Val_t, typename Elt_t>
2470 const Elt_t &Elt) {
2471 return InsertValue_match<Ind, Val_t, Elt_t>(Val, Elt);
2472}
2473
2474/// Matches patterns for `vscale`. This can either be a call to `llvm.vscale` or
2475/// the constant expression
2476/// `ptrtoint(gep <vscale x 1 x i8>, <vscale x 1 x i8>* null, i32 1>`
2477/// under the right conditions determined by DataLayout.
2481
2482 template <typename ITy> bool match(ITy *V) {
2483 if (m_Intrinsic<Intrinsic::vscale>().match(V))
2484 return true;
2485
2486 Value *Ptr;
2487 if (m_PtrToInt(m_Value(Ptr)).match(V)) {
2488 if (auto *GEP = dyn_cast<GEPOperator>(Ptr)) {
2489 auto *DerefTy = GEP->getSourceElementType();
2490 if (GEP->getNumIndices() == 1 && isa<ScalableVectorType>(DerefTy) &&
2491 m_Zero().match(GEP->getPointerOperand()) &&
2492 m_SpecificInt(1).match(GEP->idx_begin()->get()) &&
2494 return true;
2495 }
2496 }
2497
2498 return false;
2499 }
2500};
2501
2503 return VScaleVal_match(DL);
2504}
2505
2506template <typename LHS, typename RHS, unsigned Opcode, bool Commutable = false>
2510
2511 LogicalOp_match(const LHS &L, const RHS &R) : L(L), R(R) {}
2512
2513 template <typename T> bool match(T *V) {
2514 auto *I = dyn_cast<Instruction>(V);
2515 if (!I || !I->getType()->isIntOrIntVectorTy(1))
2516 return false;
2517
2518 if (I->getOpcode() == Opcode) {
2519 auto *Op0 = I->getOperand(0);
2520 auto *Op1 = I->getOperand(1);
2521 return (L.match(Op0) && R.match(Op1)) ||
2522 (Commutable && L.match(Op1) && R.match(Op0));
2523 }
2524
2525 if (auto *Select = dyn_cast<SelectInst>(I)) {
2526 auto *Cond = Select->getCondition();
2527 auto *TVal = Select->getTrueValue();
2528 auto *FVal = Select->getFalseValue();
2529
2530 // Don't match a scalar select of bool vectors.
2531 // Transforms expect a single type for operands if this matches.
2532 if (Cond->getType() != Select->getType())
2533 return false;
2534
2535 if (Opcode == Instruction::And) {
2536 auto *C = dyn_cast<Constant>(FVal);
2537 if (C && C->isNullValue())
2538 return (L.match(Cond) && R.match(TVal)) ||
2539 (Commutable && L.match(TVal) && R.match(Cond));
2540 } else {
2541 assert(Opcode == Instruction::Or);
2542 auto *C = dyn_cast<Constant>(TVal);
2543 if (C && C->isOneValue())
2544 return (L.match(Cond) && R.match(FVal)) ||
2545 (Commutable && L.match(FVal) && R.match(Cond));
2546 }
2547 }
2548
2549 return false;
2550 }
2551};
2552
2553/// Matches L && R either in the form of L & R or L ? R : false.
2554/// Note that the latter form is poison-blocking.
2555template <typename LHS, typename RHS>
2557 const RHS &R) {
2559}
2560
2561/// Matches L && R where L and R are arbitrary values.
2562inline auto m_LogicalAnd() { return m_LogicalAnd(m_Value(), m_Value()); }
2563
2564/// Matches L && R with LHS and RHS in either order.
2565template <typename LHS, typename RHS>
2567m_c_LogicalAnd(const LHS &L, const RHS &R) {
2569}
2570
2571/// Matches L || R either in the form of L | R or L ? true : R.
2572/// Note that the latter form is poison-blocking.
2573template <typename LHS, typename RHS>
2575 const RHS &R) {
2577}
2578
2579/// Matches L || R where L and R are arbitrary values.
2580inline auto m_LogicalOr() { return m_LogicalOr(m_Value(), m_Value()); }
2581
2582/// Matches L || R with LHS and RHS in either order.
2583template <typename LHS, typename RHS>
2585m_c_LogicalOr(const LHS &L, const RHS &R) {
2587}
2588
2589/// Matches either L && R or L || R,
2590/// either one being in the either binary or logical form.
2591/// Note that the latter form is poison-blocking.
2592template <typename LHS, typename RHS, bool Commutable = false>
2593inline auto m_LogicalOp(const LHS &L, const RHS &R) {
2594 return m_CombineOr(
2597}
2598
2599/// Matches either L && R or L || R where L and R are arbitrary values.
2600inline auto m_LogicalOp() { return m_LogicalOp(m_Value(), m_Value()); }
2601
2602/// Matches either L && R or L || R with LHS and RHS in either order.
2603template <typename LHS, typename RHS>
2604inline auto m_c_LogicalOp(const LHS &L, const RHS &R) {
2605 return m_LogicalOp<LHS, RHS, /*Commutable=*/true>(L, R);
2606}
2607
2608} // end namespace PatternMatch
2609} // end namespace llvm
2610
2611#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...
SmallVector< MachineOperand, 4 > Cond
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)
@ SI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * RHS
Value * LHS
Class for arbitrary precision integers.
Definition: APInt.h:75
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:541
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:56
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:718
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:747
@ ICMP_SLE
signed less or equal
Definition: InstrTypes.h:748
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:724
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:733
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:722
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:723
@ ICMP_UGE
unsigned greater or equal
Definition: InstrTypes.h:742
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:741
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:745
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:732
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:743
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:730
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:725
@ ICMP_EQ
equal
Definition: InstrTypes.h:739
@ ICMP_SGE
signed greater or equal
Definition: InstrTypes.h:746
@ ICMP_ULE
unsigned less or equal
Definition: InstrTypes.h:744
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:731
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:998
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:256
This is the shared class of boolean and integer constants.
Definition: Constants.h:78
This is an important base class in LLVM.
Definition: Constant.h:41
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:114
TypeSize getTypeAllocSizeInBits(Type *Ty) const
Returns the offset in bits between successive objects of the specified type, including alignment padd...
Definition: DataLayout.h:520
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:224
bool isShift() const
Definition: Instruction.h:175
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:365
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:450
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.
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
Definition: TypeSize.h:163
#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:453
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:585
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:854
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
Definition: PatternMatch.h:475
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, OpTy > m_ZExtOrSelf(const OpTy &Op)
MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > m_UnordFMin(const LHS &L, const RHS &R)
Match an 'unordered' floating point minimum function.
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:979
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:576
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:626
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
CastClass_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:997
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
Definition: PatternMatch.h:544
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.
CastClass_match< OpTy, Instruction::SExt > m_SExt(const OpTy &Op)
Matches SExt.
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:564
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
br_match m_UnconditionalBr(BasicBlock *&Succ)
CastClass_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
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)
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)
bind_ty< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
Definition: PatternMatch.h:716
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
Definition: PatternMatch.h:664
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:772
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:642
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
Definition: PatternMatch.h:485
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:517
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:682
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:815
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)
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)
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:722
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:985
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:790
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
Definition: PatternMatch.h:524
CastClass_match< OpTy, Instruction::FPTrunc > m_FPTrunc(const OpTy &Op)
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.
CastClass_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
Definition: PatternMatch.h:751
specific_bbval m_SpecificBB(BasicBlock *BB)
Match a specific basic block value.
Definition: PatternMatch.h:887
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.
CastClass_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
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:495
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:617
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.
match_combine_or< match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > >, OpTy > m_ZExtOrSExtOrSelf(const OpTy &Op)
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)
match_combine_or< CastClass_match< OpTy, Instruction::Trunc >, OpTy > m_TruncOrSelf(const OpTy &Op)
CastClass_match< OpTy, Instruction::SIToFP > m_SIToFP(const OpTy &Op)
CastClass_match< OpTy, Instruction::IntToPtr > m_IntToPtr(const OpTy &Op)
Matches IntToPtr.
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
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:552
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.
CastClass_match< OpTy, Instruction::FPToSI > m_FPToSI(const OpTy &Op)
specific_fpval m_FPOne()
Match a float 1.0 or vector with all elements equal to 1.0.
Definition: PatternMatch.h:818
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.
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > > m_ZExtOrSExt(const OpTy &Op)
CastClass_match< OpTy, Instruction::FPToUI > m_FPToUI(const OpTy &Op)
CastClass_match< OpTy, Instruction::FPExt > m_FPExt(const OpTy &Op)
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.
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.
cstfp_pred_ty< is_finitenonzero > m_FiniteNonZero()
Match a finite non-zero FP constant.
Definition: PatternMatch.h:652
class_match< UnaryOperator > m_UnOp()
Match an arbitrary unary operation and ignore it.
Definition: PatternMatch.h:79
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
specific_intval< true > m_SpecificIntAllowUndef(APInt V)
Definition: PatternMatch.h:862
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:463
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:673
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.
VScaleVal_match m_VScale(const DataLayout &DL)
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:691
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
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
match_combine_or< CastClass_match< OpTy, Instruction::SExt >, OpTy > m_SExtOrSelf(const OpTy &Op)
cst_pred_ty< is_nonpositive > m_NonPositive()
Match an integer or vector of non-positive values.
Definition: PatternMatch.h:507
cstfp_pred_ty< is_nan > m_NaN()
Match an arbitrary NaN constant.
Definition: PatternMatch.h:610
CastClass_match< OpTy, Instruction::UIToFP > m_UIToFP(const OpTy &Op)
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)
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
Definition: PatternMatch.h:537
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.
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)
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:991
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:633
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:598
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:1735
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:1862
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:1762
Definition: BitVector.h:851
AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
Definition: PatternMatch.h:910
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:958
bool match(unsigned Opc, OpTy *V)
Definition: PatternMatch.h:960
CastClass_match(const Op_t &OpMatch)
CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
Exact_match(const SubPattern_t &SP)
Matcher for a single index InsertValue instruction.
InsertValue_match(const T0 &Op0, const T1 &Op1)
IntrinsicID_match(Intrinsic::ID IntrID)
LogicalOp_match(const LHS &L, const RHS &R)
MaxMin_match(const LHS_t &LHS, const RHS_t &RHS)
Matches instructions with Opcode and three operands.
OneUse_match(const SubPattern_t &SP)
Definition: PatternMatch.h:60
OverflowingBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
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.
VScaleVal_match(const DataLayout &DL)
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:776
bool isValue(const APInt &C)
Definition: PatternMatch.h:449
bool isValue(const APInt &C)
Definition: PatternMatch.h:440
bool isValue(const APFloat &C)
Definition: PatternMatch.h:660
bool isValue(const APFloat &C)
Definition: PatternMatch.h:638
bool isValue(const APFloat &C)
Definition: PatternMatch.h:648
bool isOpType(unsigned Opcode)
bool isValue(const APFloat &C)
Definition: PatternMatch.h:622
bool isOpType(unsigned Opcode)
bool isValue(const APFloat &C)
Definition: PatternMatch.h:606
bool isValue(const APFloat &C)
Definition: PatternMatch.h:678
bool isValue(const APInt &C)
Definition: PatternMatch.h:471
bool isValue(const APFloat &C)
Definition: PatternMatch.h:687
bool isValue(const APFloat &C)
Definition: PatternMatch.h:629
bool isValue(const APFloat &C)
Definition: PatternMatch.h:613
bool isValue(const APInt &C)
Definition: PatternMatch.h:513
bool isValue(const APFloat &C)
Definition: PatternMatch.h:669
bool isValue(const APInt &C)
Definition: PatternMatch.h:540
bool isOpType(unsigned Opcode)
bool isValue(const APInt &C)
Definition: PatternMatch.h:572
bool isValue(const APInt &C)
Definition: PatternMatch.h:520
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:875
Match a specified floating point value or vector of all elements of that value.
Definition: PatternMatch.h:797
Match a specified integer value or vector of all elements of that value.
Definition: PatternMatch.h:837
Match a specified Value*.
Definition: PatternMatch.h:763
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