LLVM 20.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 SubPattern_t> struct AllowReassoc_match {
72 SubPattern_t SubPattern;
73
74 AllowReassoc_match(const SubPattern_t &SP) : SubPattern(SP) {}
75
76 template <typename OpTy> bool match(OpTy *V) {
77 auto *I = dyn_cast<FPMathOperator>(V);
78 return I && I->hasAllowReassoc() && SubPattern.match(I);
79 }
80};
81
82template <typename T>
83inline AllowReassoc_match<T> m_AllowReassoc(const T &SubPattern) {
84 return SubPattern;
85}
86
87template <typename Class> struct class_match {
88 template <typename ITy> bool match(ITy *V) { return isa<Class>(V); }
89};
90
91/// Match an arbitrary value and ignore it.
93
94/// Match an arbitrary unary operation and ignore it.
97}
98
99/// Match an arbitrary binary operation and ignore it.
102}
103
104/// Matches any compare instruction and ignore it.
106
108 static bool check(const Value *V) {
109 if (isa<UndefValue>(V))
110 return true;
111
112 const auto *CA = dyn_cast<ConstantAggregate>(V);
113 if (!CA)
114 return false;
115
118
119 // Either UndefValue, PoisonValue, or an aggregate that only contains
120 // these is accepted by matcher.
121 // CheckValue returns false if CA cannot satisfy this constraint.
122 auto CheckValue = [&](const ConstantAggregate *CA) {
123 for (const Value *Op : CA->operand_values()) {
124 if (isa<UndefValue>(Op))
125 continue;
126
127 const auto *CA = dyn_cast<ConstantAggregate>(Op);
128 if (!CA)
129 return false;
130 if (Seen.insert(CA).second)
131 Worklist.emplace_back(CA);
132 }
133
134 return true;
135 };
136
137 if (!CheckValue(CA))
138 return false;
139
140 while (!Worklist.empty()) {
141 if (!CheckValue(Worklist.pop_back_val()))
142 return false;
143 }
144 return true;
145 }
146 template <typename ITy> bool match(ITy *V) { return check(V); }
147};
148
149/// Match an arbitrary undef constant. This matches poison as well.
150/// If this is an aggregate and contains a non-aggregate element that is
151/// neither undef nor poison, the aggregate is not matched.
152inline auto m_Undef() { return undef_match(); }
153
154/// Match an arbitrary UndefValue constant.
157}
158
159/// Match an arbitrary poison constant.
162}
163
164/// Match an arbitrary Constant and ignore it.
166
167/// Match an arbitrary ConstantInt and ignore it.
170}
171
172/// Match an arbitrary ConstantFP and ignore it.
175}
176
178 template <typename ITy> bool match(ITy *V) {
179 auto *C = dyn_cast<Constant>(V);
180 return C && (isa<ConstantExpr>(C) || C->containsConstantExpression());
181 }
182};
183
184/// Match a constant expression or a constant that contains a constant
185/// expression.
187
188/// Match an arbitrary basic block value and ignore it.
191}
192
193/// Inverting matcher
194template <typename Ty> struct match_unless {
195 Ty M;
196
197 match_unless(const Ty &Matcher) : M(Matcher) {}
198
199 template <typename ITy> bool match(ITy *V) { return !M.match(V); }
200};
201
202/// Match if the inner matcher does *NOT* match.
203template <typename Ty> inline match_unless<Ty> m_Unless(const Ty &M) {
204 return match_unless<Ty>(M);
205}
206
207/// Matching combinators
208template <typename LTy, typename RTy> struct match_combine_or {
209 LTy L;
210 RTy R;
211
212 match_combine_or(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
213
214 template <typename ITy> bool match(ITy *V) {
215 if (L.match(V))
216 return true;
217 if (R.match(V))
218 return true;
219 return false;
220 }
221};
222
223template <typename LTy, typename RTy> struct match_combine_and {
224 LTy L;
225 RTy R;
226
227 match_combine_and(const LTy &Left, const RTy &Right) : L(Left), R(Right) {}
228
229 template <typename ITy> bool match(ITy *V) {
230 if (L.match(V))
231 if (R.match(V))
232 return true;
233 return false;
234 }
235};
236
237/// Combine two pattern matchers matching L || R
238template <typename LTy, typename RTy>
239inline match_combine_or<LTy, RTy> m_CombineOr(const LTy &L, const RTy &R) {
240 return match_combine_or<LTy, RTy>(L, R);
241}
242
243/// Combine two pattern matchers matching L && R
244template <typename LTy, typename RTy>
245inline match_combine_and<LTy, RTy> m_CombineAnd(const LTy &L, const RTy &R) {
246 return match_combine_and<LTy, RTy>(L, R);
247}
248
250 const APInt *&Res;
252
255
256 template <typename ITy> bool match(ITy *V) {
257 if (auto *CI = dyn_cast<ConstantInt>(V)) {
258 Res = &CI->getValue();
259 return true;
260 }
261 if (V->getType()->isVectorTy())
262 if (const auto *C = dyn_cast<Constant>(V))
263 if (auto *CI =
264 dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowPoison))) {
265 Res = &CI->getValue();
266 return true;
267 }
268 return false;
269 }
270};
271// Either constexpr if or renaming ConstantFP::getValueAPF to
272// ConstantFP::getValue is needed to do it via single template
273// function for both apint/apfloat.
275 const APFloat *&Res;
277
280
281 template <typename ITy> bool match(ITy *V) {
282 if (auto *CI = dyn_cast<ConstantFP>(V)) {
283 Res = &CI->getValueAPF();
284 return true;
285 }
286 if (V->getType()->isVectorTy())
287 if (const auto *C = dyn_cast<Constant>(V))
288 if (auto *CI =
289 dyn_cast_or_null<ConstantFP>(C->getSplatValue(AllowPoison))) {
290 Res = &CI->getValueAPF();
291 return true;
292 }
293 return false;
294 }
295};
296
297/// Match a ConstantInt or splatted ConstantVector, binding the
298/// specified pointer to the contained APInt.
299inline apint_match m_APInt(const APInt *&Res) {
300 // Forbid poison by default to maintain previous behavior.
301 return apint_match(Res, /* AllowPoison */ false);
302}
303
304/// Match APInt while allowing poison in splat vector constants.
306 return apint_match(Res, /* AllowPoison */ true);
307}
308
309/// Match APInt while forbidding poison in splat vector constants.
311 return apint_match(Res, /* AllowPoison */ false);
312}
313
314/// Match a ConstantFP or splatted ConstantVector, binding the
315/// specified pointer to the contained APFloat.
316inline apfloat_match m_APFloat(const APFloat *&Res) {
317 // Forbid undefs by default to maintain previous behavior.
318 return apfloat_match(Res, /* AllowPoison */ false);
319}
320
321/// Match APFloat while allowing poison in splat vector constants.
323 return apfloat_match(Res, /* AllowPoison */ true);
324}
325
326/// Match APFloat while forbidding poison in splat vector constants.
328 return apfloat_match(Res, /* AllowPoison */ false);
329}
330
331template <int64_t Val> struct constantint_match {
332 template <typename ITy> bool match(ITy *V) {
333 if (const auto *CI = dyn_cast<ConstantInt>(V)) {
334 const APInt &CIV = CI->getValue();
335 if (Val >= 0)
336 return CIV == static_cast<uint64_t>(Val);
337 // If Val is negative, and CI is shorter than it, truncate to the right
338 // number of bits. If it is larger, then we have to sign extend. Just
339 // compare their negated values.
340 return -CIV == -Val;
341 }
342 return false;
343 }
344};
345
346/// Match a ConstantInt with a specific value.
347template <int64_t Val> inline constantint_match<Val> m_ConstantInt() {
348 return constantint_match<Val>();
349}
350
351/// This helper class is used to match constant scalars, vector splats,
352/// and fixed width vectors that satisfy a specified predicate.
353/// For fixed width vector constants, poison elements are ignored if AllowPoison
354/// is true.
355template <typename Predicate, typename ConstantVal, bool AllowPoison>
356struct cstval_pred_ty : public Predicate {
357 const Constant **Res = nullptr;
358 template <typename ITy> bool match_impl(ITy *V) {
359 if (const auto *CV = dyn_cast<ConstantVal>(V))
360 return this->isValue(CV->getValue());
361 if (const auto *VTy = dyn_cast<VectorType>(V->getType())) {
362 if (const auto *C = dyn_cast<Constant>(V)) {
363 if (const auto *CV = dyn_cast_or_null<ConstantVal>(C->getSplatValue()))
364 return this->isValue(CV->getValue());
365
366 // Number of elements of a scalable vector unknown at compile time
367 auto *FVTy = dyn_cast<FixedVectorType>(VTy);
368 if (!FVTy)
369 return false;
370
371 // Non-splat vector constant: check each element for a match.
372 unsigned NumElts = FVTy->getNumElements();
373 assert(NumElts != 0 && "Constant vector with no elements?");
374 bool HasNonPoisonElements = false;
375 for (unsigned i = 0; i != NumElts; ++i) {
376 Constant *Elt = C->getAggregateElement(i);
377 if (!Elt)
378 return false;
379 if (AllowPoison && isa<PoisonValue>(Elt))
380 continue;
381 auto *CV = dyn_cast<ConstantVal>(Elt);
382 if (!CV || !this->isValue(CV->getValue()))
383 return false;
384 HasNonPoisonElements = true;
385 }
386 return HasNonPoisonElements;
387 }
388 }
389 return false;
390 }
391
392 template <typename ITy> bool match(ITy *V) {
393 if (this->match_impl(V)) {
394 if (Res)
395 *Res = cast<Constant>(V);
396 return true;
397 }
398 return false;
399 }
400};
401
402/// specialization of cstval_pred_ty for ConstantInt
403template <typename Predicate, bool AllowPoison = true>
405
406/// specialization of cstval_pred_ty for ConstantFP
407template <typename Predicate>
409 /*AllowPoison=*/true>;
410
411/// This helper class is used to match scalar and vector constants that
412/// satisfy a specified predicate, and bind them to an APInt.
413template <typename Predicate> struct api_pred_ty : public Predicate {
414 const APInt *&Res;
415
416 api_pred_ty(const APInt *&R) : Res(R) {}
417
418 template <typename ITy> bool match(ITy *V) {
419 if (const auto *CI = dyn_cast<ConstantInt>(V))
420 if (this->isValue(CI->getValue())) {
421 Res = &CI->getValue();
422 return true;
423 }
424 if (V->getType()->isVectorTy())
425 if (const auto *C = dyn_cast<Constant>(V))
426 if (auto *CI = dyn_cast_or_null<ConstantInt>(
427 C->getSplatValue(/*AllowPoison=*/true)))
428 if (this->isValue(CI->getValue())) {
429 Res = &CI->getValue();
430 return true;
431 }
432
433 return false;
434 }
435};
436
437/// This helper class is used to match scalar and vector constants that
438/// satisfy a specified predicate, and bind them to an APFloat.
439/// Poison is allowed in splat vector constants.
440template <typename Predicate> struct apf_pred_ty : public Predicate {
441 const APFloat *&Res;
442
443 apf_pred_ty(const APFloat *&R) : Res(R) {}
444
445 template <typename ITy> bool match(ITy *V) {
446 if (const auto *CI = dyn_cast<ConstantFP>(V))
447 if (this->isValue(CI->getValue())) {
448 Res = &CI->getValue();
449 return true;
450 }
451 if (V->getType()->isVectorTy())
452 if (const auto *C = dyn_cast<Constant>(V))
453 if (auto *CI = dyn_cast_or_null<ConstantFP>(
454 C->getSplatValue(/* AllowPoison */ true)))
455 if (this->isValue(CI->getValue())) {
456 Res = &CI->getValue();
457 return true;
458 }
459
460 return false;
461 }
462};
463
464///////////////////////////////////////////////////////////////////////////////
465//
466// Encapsulate constant value queries for use in templated predicate matchers.
467// This allows checking if constants match using compound predicates and works
468// with vector constants, possibly with relaxed constraints. For example, ignore
469// undef values.
470//
471///////////////////////////////////////////////////////////////////////////////
472
473template <typename APTy> struct custom_checkfn {
474 function_ref<bool(const APTy &)> CheckFn;
475 bool isValue(const APTy &C) { return CheckFn(C); }
476};
477
478/// Match an integer or vector where CheckFn(ele) for each element is true.
479/// For vectors, poison elements are assumed to match.
481m_CheckedInt(function_ref<bool(const APInt &)> CheckFn) {
482 return cst_pred_ty<custom_checkfn<APInt>>{{CheckFn}};
483}
484
486m_CheckedInt(const Constant *&V, function_ref<bool(const APInt &)> CheckFn) {
487 return cst_pred_ty<custom_checkfn<APInt>>{{CheckFn}, &V};
488}
489
490/// Match a float or vector where CheckFn(ele) for each element is true.
491/// For vectors, poison elements are assumed to match.
493m_CheckedFp(function_ref<bool(const APFloat &)> CheckFn) {
494 return cstfp_pred_ty<custom_checkfn<APFloat>>{{CheckFn}};
495}
496
498m_CheckedFp(const Constant *&V, function_ref<bool(const APFloat &)> CheckFn) {
499 return cstfp_pred_ty<custom_checkfn<APFloat>>{{CheckFn}, &V};
500}
501
503 bool isValue(const APInt &C) { return true; }
504};
505/// Match an integer or vector with any integral constant.
506/// For vectors, this includes constants with undefined elements.
509}
510
512 bool isValue(const APInt &C) { return C.isShiftedMask(); }
513};
514
517}
518
520 bool isValue(const APInt &C) { return C.isAllOnes(); }
521};
522/// Match an integer or vector with all bits set.
523/// For vectors, this includes constants with undefined elements.
526}
527
530}
531
533 bool isValue(const APInt &C) { return C.isMaxSignedValue(); }
534};
535/// Match an integer or vector with values having all bits except for the high
536/// bit set (0x7f...).
537/// For vectors, this includes constants with undefined elements.
540}
542 return V;
543}
544
546 bool isValue(const APInt &C) { return C.isNegative(); }
547};
548/// Match an integer or vector of negative values.
549/// For vectors, this includes constants with undefined elements.
552}
553inline api_pred_ty<is_negative> m_Negative(const APInt *&V) { return V; }
554
556 bool isValue(const APInt &C) { return C.isNonNegative(); }
557};
558/// Match an integer or vector of non-negative values.
559/// For vectors, this includes constants with undefined elements.
562}
563inline api_pred_ty<is_nonnegative> m_NonNegative(const APInt *&V) { return V; }
564
566 bool isValue(const APInt &C) { return C.isStrictlyPositive(); }
567};
568/// Match an integer or vector of strictly positive values.
569/// For vectors, this includes constants with undefined elements.
572}
574 return V;
575}
576
578 bool isValue(const APInt &C) { return C.isNonPositive(); }
579};
580/// Match an integer or vector of non-positive values.
581/// For vectors, this includes constants with undefined elements.
584}
585inline api_pred_ty<is_nonpositive> m_NonPositive(const APInt *&V) { return V; }
586
587struct is_one {
588 bool isValue(const APInt &C) { return C.isOne(); }
589};
590/// Match an integer 1 or a vector with all elements equal to 1.
591/// For vectors, this includes constants with undefined elements.
593
595 bool isValue(const APInt &C) { return C.isZero(); }
596};
597/// Match an integer 0 or a vector with all elements equal to 0.
598/// For vectors, this includes constants with undefined elements.
601}
602
603struct is_zero {
604 template <typename ITy> bool match(ITy *V) {
605 auto *C = dyn_cast<Constant>(V);
606 // FIXME: this should be able to do something for scalable vectors
607 return C && (C->isNullValue() || cst_pred_ty<is_zero_int>().match(C));
608 }
609};
610/// Match any null constant or a vector with all elements equal to 0.
611/// For vectors, this includes constants with undefined elements.
612inline is_zero m_Zero() { return is_zero(); }
613
614struct is_power2 {
615 bool isValue(const APInt &C) { return C.isPowerOf2(); }
616};
617/// Match an integer or vector power-of-2.
618/// For vectors, this includes constants with undefined elements.
620inline api_pred_ty<is_power2> m_Power2(const APInt *&V) { return V; }
621
623 bool isValue(const APInt &C) { return C.isNegatedPowerOf2(); }
624};
625/// Match a integer or vector negated power-of-2.
626/// For vectors, this includes constants with undefined elements.
629}
631 return V;
632}
633
635 bool isValue(const APInt &C) { return !C || C.isNegatedPowerOf2(); }
636};
637/// Match a integer or vector negated power-of-2.
638/// For vectors, this includes constants with undefined elements.
641}
644 return V;
645}
646
648 bool isValue(const APInt &C) { return !C || C.isPowerOf2(); }
649};
650/// Match an integer or vector of 0 or power-of-2 values.
651/// For vectors, this includes constants with undefined elements.
654}
656 return V;
657}
658
660 bool isValue(const APInt &C) { return C.isSignMask(); }
661};
662/// Match an integer or vector with only the sign bit(s) set.
663/// For vectors, this includes constants with undefined elements.
666}
667
669 bool isValue(const APInt &C) { return C.isMask(); }
670};
671/// Match an integer or vector with only the low bit(s) set.
672/// For vectors, this includes constants with undefined elements.
675}
676inline api_pred_ty<is_lowbit_mask> m_LowBitMask(const APInt *&V) { return V; }
677
679 bool isValue(const APInt &C) { return !C || C.isMask(); }
680};
681/// Match an integer or vector with only the low bit(s) set.
682/// For vectors, this includes constants with undefined elements.
685}
687 return V;
688}
689
692 const APInt *Thr;
693 bool isValue(const APInt &C) { return ICmpInst::compare(C, *Thr, Pred); }
694};
695/// Match an integer or vector with every element comparing 'pred' (eg/ne/...)
696/// to Threshold. For vectors, this includes constants with undefined elements.
698m_SpecificInt_ICMP(ICmpInst::Predicate Predicate, const APInt &Threshold) {
700 P.Pred = Predicate;
701 P.Thr = &Threshold;
702 return P;
703}
704
705struct is_nan {
706 bool isValue(const APFloat &C) { return C.isNaN(); }
707};
708/// Match an arbitrary NaN constant. This includes quiet and signalling nans.
709/// For vectors, this includes constants with undefined elements.
711
712struct is_nonnan {
713 bool isValue(const APFloat &C) { return !C.isNaN(); }
714};
715/// Match a non-NaN FP constant.
716/// For vectors, this includes constants with undefined elements.
719}
720
721struct is_inf {
722 bool isValue(const APFloat &C) { return C.isInfinity(); }
723};
724/// Match a positive or negative infinity FP constant.
725/// For vectors, this includes constants with undefined elements.
727
728struct is_noninf {
729 bool isValue(const APFloat &C) { return !C.isInfinity(); }
730};
731/// Match a non-infinity FP constant, i.e. finite or NaN.
732/// For vectors, this includes constants with undefined elements.
735}
736
737struct is_finite {
738 bool isValue(const APFloat &C) { return C.isFinite(); }
739};
740/// Match a finite FP constant, i.e. not infinity or NaN.
741/// For vectors, this includes constants with undefined elements.
744}
745inline apf_pred_ty<is_finite> m_Finite(const APFloat *&V) { return V; }
746
748 bool isValue(const APFloat &C) { return C.isFiniteNonZero(); }
749};
750/// Match a finite non-zero FP constant.
751/// For vectors, this includes constants with undefined elements.
754}
756 return V;
757}
758
760 bool isValue(const APFloat &C) { return C.isZero(); }
761};
762/// Match a floating-point negative zero or positive zero.
763/// For vectors, this includes constants with undefined elements.
766}
767
769 bool isValue(const APFloat &C) { return C.isPosZero(); }
770};
771/// Match a floating-point positive zero.
772/// For vectors, this includes constants with undefined elements.
775}
776
778 bool isValue(const APFloat &C) { return C.isNegZero(); }
779};
780/// Match a floating-point negative zero.
781/// For vectors, this includes constants with undefined elements.
784}
785
787 bool isValue(const APFloat &C) { return C.isNonZero(); }
788};
789/// Match a floating-point non-zero.
790/// For vectors, this includes constants with undefined elements.
793}
794
795///////////////////////////////////////////////////////////////////////////////
796
797template <typename Class> struct bind_ty {
798 Class *&VR;
799
800 bind_ty(Class *&V) : VR(V) {}
801
802 template <typename ITy> bool match(ITy *V) {
803 if (auto *CV = dyn_cast<Class>(V)) {
804 VR = CV;
805 return true;
806 }
807 return false;
808 }
809};
810
811/// Match a value, capturing it if we match.
812inline bind_ty<Value> m_Value(Value *&V) { return V; }
813inline bind_ty<const Value> m_Value(const Value *&V) { return V; }
814
815/// Match an instruction, capturing it if we match.
817/// Match a unary operator, capturing it if we match.
819/// Match a binary operator, capturing it if we match.
821/// Match a with overflow intrinsic, capturing it if we match.
823 return I;
824}
827 return I;
828}
829
830/// Match an UndefValue, capturing the value if we match.
832
833/// Match a Constant, capturing the value if we match.
835
836/// Match a ConstantInt, capturing the value if we match.
838
839/// Match a ConstantFP, capturing the value if we match.
841
842/// Match a ConstantExpr, capturing the value if we match.
844
845/// Match a basic block value, capturing it if we match.
848 return V;
849}
850
851/// Match an arbitrary immediate Constant and ignore it.
856}
857
858/// Match an immediate Constant, capturing the value if we match.
863}
864
865/// Match a specified Value*.
867 const Value *Val;
868
869 specificval_ty(const Value *V) : Val(V) {}
870
871 template <typename ITy> bool match(ITy *V) { return V == Val; }
872};
873
874/// Match if we have a specific specified value.
875inline specificval_ty m_Specific(const Value *V) { return V; }
876
877/// Stores a reference to the Value *, not the Value * itself,
878/// thus can be used in commutative matchers.
879template <typename Class> struct deferredval_ty {
880 Class *const &Val;
881
882 deferredval_ty(Class *const &V) : Val(V) {}
883
884 template <typename ITy> bool match(ITy *const V) { return V == Val; }
885};
886
887/// Like m_Specific(), but works if the specific value to match is determined
888/// as part of the same match() expression. For example:
889/// m_Add(m_Value(X), m_Specific(X)) is incorrect, because m_Specific() will
890/// bind X before the pattern match starts.
891/// m_Add(m_Value(X), m_Deferred(X)) is correct, and will check against
892/// whichever value m_Value(X) populated.
893inline deferredval_ty<Value> m_Deferred(Value *const &V) { return V; }
895 return V;
896}
897
898/// Match a specified floating point value or vector of all elements of
899/// that value.
901 double Val;
902
903 specific_fpval(double V) : Val(V) {}
904
905 template <typename ITy> bool match(ITy *V) {
906 if (const auto *CFP = dyn_cast<ConstantFP>(V))
907 return CFP->isExactlyValue(Val);
908 if (V->getType()->isVectorTy())
909 if (const auto *C = dyn_cast<Constant>(V))
910 if (auto *CFP = dyn_cast_or_null<ConstantFP>(C->getSplatValue()))
911 return CFP->isExactlyValue(Val);
912 return false;
913 }
914};
915
916/// Match a specific floating point value or vector with all elements
917/// equal to the value.
918inline specific_fpval m_SpecificFP(double V) { return specific_fpval(V); }
919
920/// Match a float 1.0 or vector with all elements equal to 1.0.
921inline specific_fpval m_FPOne() { return m_SpecificFP(1.0); }
922
925
927
928 template <typename ITy> bool match(ITy *V) {
929 if (const auto *CV = dyn_cast<ConstantInt>(V))
930 if (CV->getValue().ule(UINT64_MAX)) {
931 VR = CV->getZExtValue();
932 return true;
933 }
934 return false;
935 }
936};
937
938/// Match a specified integer value or vector of all elements of that
939/// value.
940template <bool AllowPoison> struct specific_intval {
941 const APInt &Val;
942
943 specific_intval(const APInt &V) : Val(V) {}
944
945 template <typename ITy> bool match(ITy *V) {
946 const auto *CI = dyn_cast<ConstantInt>(V);
947 if (!CI && V->getType()->isVectorTy())
948 if (const auto *C = dyn_cast<Constant>(V))
949 CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowPoison));
950
951 return CI && APInt::isSameValue(CI->getValue(), Val);
952 }
953};
954
955template <bool AllowPoison> struct specific_intval64 {
957
959
960 template <typename ITy> bool match(ITy *V) {
961 const auto *CI = dyn_cast<ConstantInt>(V);
962 if (!CI && V->getType()->isVectorTy())
963 if (const auto *C = dyn_cast<Constant>(V))
964 CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue(AllowPoison));
965
966 return CI && CI->getValue() == Val;
967 }
968};
969
970/// Match a specific integer value or vector with all elements equal to
971/// the value.
973 return specific_intval<false>(V);
974}
975
977 return specific_intval64<false>(V);
978}
979
981 return specific_intval<true>(V);
982}
983
985 return specific_intval64<true>(V);
986}
987
988/// Match a ConstantInt and bind to its value. This does not match
989/// ConstantInts wider than 64-bits.
991
992/// Match a specified basic block value.
995
997
998 template <typename ITy> bool match(ITy *V) {
999 const auto *BB = dyn_cast<BasicBlock>(V);
1000 return BB && BB == Val;
1001 }
1002};
1003
1004/// Match a specific basic block value.
1006 return specific_bbval(BB);
1007}
1008
1009/// A commutative-friendly version of m_Specific().
1011 return BB;
1012}
1014m_Deferred(const BasicBlock *const &BB) {
1015 return BB;
1016}
1017
1018//===----------------------------------------------------------------------===//
1019// Matcher for any binary operator.
1020//
1021template <typename LHS_t, typename RHS_t, bool Commutable = false>
1025
1026 // The evaluation order is always stable, regardless of Commutability.
1027 // The LHS is always matched first.
1028 AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1029
1030 template <typename OpTy> bool match(OpTy *V) {
1031 if (auto *I = dyn_cast<BinaryOperator>(V))
1032 return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
1033 (Commutable && L.match(I->getOperand(1)) &&
1034 R.match(I->getOperand(0)));
1035 return false;
1036 }
1037};
1038
1039template <typename LHS, typename RHS>
1040inline AnyBinaryOp_match<LHS, RHS> m_BinOp(const LHS &L, const RHS &R) {
1041 return AnyBinaryOp_match<LHS, RHS>(L, R);
1042}
1043
1044//===----------------------------------------------------------------------===//
1045// Matcher for any unary operator.
1046// TODO fuse unary, binary matcher into n-ary matcher
1047//
1048template <typename OP_t> struct AnyUnaryOp_match {
1049 OP_t X;
1050
1051 AnyUnaryOp_match(const OP_t &X) : X(X) {}
1052
1053 template <typename OpTy> bool match(OpTy *V) {
1054 if (auto *I = dyn_cast<UnaryOperator>(V))
1055 return X.match(I->getOperand(0));
1056 return false;
1057 }
1058};
1059
1060template <typename OP_t> inline AnyUnaryOp_match<OP_t> m_UnOp(const OP_t &X) {
1061 return AnyUnaryOp_match<OP_t>(X);
1062}
1063
1064//===----------------------------------------------------------------------===//
1065// Matchers for specific binary operators.
1066//
1067
1068template <typename LHS_t, typename RHS_t, unsigned Opcode,
1069 bool Commutable = false>
1073
1074 // The evaluation order is always stable, regardless of Commutability.
1075 // The LHS is always matched first.
1076 BinaryOp_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1077
1078 template <typename OpTy> inline bool match(unsigned Opc, OpTy *V) {
1079 if (V->getValueID() == Value::InstructionVal + Opc) {
1080 auto *I = cast<BinaryOperator>(V);
1081 return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
1082 (Commutable && L.match(I->getOperand(1)) &&
1083 R.match(I->getOperand(0)));
1084 }
1085 return false;
1086 }
1087
1088 template <typename OpTy> bool match(OpTy *V) { return match(Opcode, V); }
1089};
1090
1091template <typename LHS, typename RHS>
1093 const RHS &R) {
1095}
1096
1097template <typename LHS, typename RHS>
1099 const RHS &R) {
1101}
1102
1103template <typename LHS, typename RHS>
1105 const RHS &R) {
1107}
1108
1109template <typename LHS, typename RHS>
1111 const RHS &R) {
1113}
1114
1115template <typename Op_t> struct FNeg_match {
1116 Op_t X;
1117
1118 FNeg_match(const Op_t &Op) : X(Op) {}
1119 template <typename OpTy> bool match(OpTy *V) {
1120 auto *FPMO = dyn_cast<FPMathOperator>(V);
1121 if (!FPMO)
1122 return false;
1123
1124 if (FPMO->getOpcode() == Instruction::FNeg)
1125 return X.match(FPMO->getOperand(0));
1126
1127 if (FPMO->getOpcode() == Instruction::FSub) {
1128 if (FPMO->hasNoSignedZeros()) {
1129 // With 'nsz', any zero goes.
1130 if (!cstfp_pred_ty<is_any_zero_fp>().match(FPMO->getOperand(0)))
1131 return false;
1132 } else {
1133 // Without 'nsz', we need fsub -0.0, X exactly.
1134 if (!cstfp_pred_ty<is_neg_zero_fp>().match(FPMO->getOperand(0)))
1135 return false;
1136 }
1137
1138 return X.match(FPMO->getOperand(1));
1139 }
1140
1141 return false;
1142 }
1143};
1144
1145/// Match 'fneg X' as 'fsub -0.0, X'.
1146template <typename OpTy> inline FNeg_match<OpTy> m_FNeg(const OpTy &X) {
1147 return FNeg_match<OpTy>(X);
1148}
1149
1150/// Match 'fneg X' as 'fsub +-0.0, X'.
1151template <typename RHS>
1152inline BinaryOp_match<cstfp_pred_ty<is_any_zero_fp>, RHS, Instruction::FSub>
1153m_FNegNSZ(const RHS &X) {
1154 return m_FSub(m_AnyZeroFP(), X);
1155}
1156
1157template <typename LHS, typename RHS>
1159 const RHS &R) {
1161}
1162
1163template <typename LHS, typename RHS>
1165 const RHS &R) {
1167}
1168
1169template <typename LHS, typename RHS>
1171 const RHS &R) {
1173}
1174
1175template <typename LHS, typename RHS>
1177 const RHS &R) {
1179}
1180
1181template <typename LHS, typename RHS>
1183 const RHS &R) {
1185}
1186
1187template <typename LHS, typename RHS>
1189 const RHS &R) {
1191}
1192
1193template <typename LHS, typename RHS>
1195 const RHS &R) {
1197}
1198
1199template <typename LHS, typename RHS>
1201 const RHS &R) {
1203}
1204
1205template <typename LHS, typename RHS>
1207 const RHS &R) {
1209}
1210
1211template <typename LHS, typename RHS>
1213 const RHS &R) {
1215}
1216
1217template <typename LHS, typename RHS>
1219 const RHS &R) {
1221}
1222
1223template <typename LHS, typename RHS>
1225 const RHS &R) {
1227}
1228
1229template <typename LHS, typename RHS>
1231 const RHS &R) {
1233}
1234
1235template <typename LHS, typename RHS>
1237 const RHS &R) {
1239}
1240
1241template <typename LHS_t, typename RHS_t, unsigned Opcode,
1242 unsigned WrapFlags = 0, bool Commutable = false>
1246
1248 : L(LHS), R(RHS) {}
1249
1250 template <typename OpTy> bool match(OpTy *V) {
1251 if (auto *Op = dyn_cast<OverflowingBinaryOperator>(V)) {
1252 if (Op->getOpcode() != Opcode)
1253 return false;
1255 !Op->hasNoUnsignedWrap())
1256 return false;
1257 if ((WrapFlags & OverflowingBinaryOperator::NoSignedWrap) &&
1258 !Op->hasNoSignedWrap())
1259 return false;
1260 return (L.match(Op->getOperand(0)) && R.match(Op->getOperand(1))) ||
1261 (Commutable && L.match(Op->getOperand(1)) &&
1262 R.match(Op->getOperand(0)));
1263 }
1264 return false;
1265 }
1266};
1267
1268template <typename LHS, typename RHS>
1269inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1271m_NSWAdd(const LHS &L, const RHS &R) {
1272 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1274 R);
1275}
1276template <typename LHS, typename RHS>
1277inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1279m_NSWSub(const LHS &L, const RHS &R) {
1280 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1282 R);
1283}
1284template <typename LHS, typename RHS>
1285inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1287m_NSWMul(const LHS &L, const RHS &R) {
1288 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1290 R);
1291}
1292template <typename LHS, typename RHS>
1293inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1295m_NSWShl(const LHS &L, const RHS &R) {
1296 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1298 R);
1299}
1300
1301template <typename LHS, typename RHS>
1302inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1304m_NUWAdd(const LHS &L, const RHS &R) {
1305 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1307 L, R);
1308}
1309
1310template <typename LHS, typename RHS>
1312 LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true>
1313m_c_NUWAdd(const LHS &L, const RHS &R) {
1314 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1316 true>(L, R);
1317}
1318
1319template <typename LHS, typename RHS>
1320inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1322m_NUWSub(const LHS &L, const RHS &R) {
1323 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Sub,
1325 L, R);
1326}
1327template <typename LHS, typename RHS>
1328inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1330m_NUWMul(const LHS &L, const RHS &R) {
1331 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Mul,
1333 L, R);
1334}
1335template <typename LHS, typename RHS>
1336inline OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1338m_NUWShl(const LHS &L, const RHS &R) {
1339 return OverflowingBinaryOp_match<LHS, RHS, Instruction::Shl,
1341 L, R);
1342}
1343
1344template <typename LHS_t, typename RHS_t, bool Commutable = false>
1346 : public BinaryOp_match<LHS_t, RHS_t, 0, Commutable> {
1347 unsigned Opcode;
1348
1350 : BinaryOp_match<LHS_t, RHS_t, 0, Commutable>(LHS, RHS), Opcode(Opcode) {}
1351
1352 template <typename OpTy> bool match(OpTy *V) {
1354 }
1355};
1356
1357/// Matches a specific opcode.
1358template <typename LHS, typename RHS>
1359inline SpecificBinaryOp_match<LHS, RHS> m_BinOp(unsigned Opcode, const LHS &L,
1360 const RHS &R) {
1361 return SpecificBinaryOp_match<LHS, RHS>(Opcode, L, R);
1362}
1363
1364template <typename LHS, typename RHS, bool Commutable = false>
1368
1369 DisjointOr_match(const LHS &L, const RHS &R) : L(L), R(R) {}
1370
1371 template <typename OpTy> bool match(OpTy *V) {
1372 if (auto *PDI = dyn_cast<PossiblyDisjointInst>(V)) {
1373 assert(PDI->getOpcode() == Instruction::Or && "Only or can be disjoint");
1374 if (!PDI->isDisjoint())
1375 return false;
1376 return (L.match(PDI->getOperand(0)) && R.match(PDI->getOperand(1))) ||
1377 (Commutable && L.match(PDI->getOperand(1)) &&
1378 R.match(PDI->getOperand(0)));
1379 }
1380 return false;
1381 }
1382};
1383
1384template <typename LHS, typename RHS>
1386 return DisjointOr_match<LHS, RHS>(L, R);
1387}
1388
1389template <typename LHS, typename RHS>
1391 const RHS &R) {
1393}
1394
1395/// Match either "add" or "or disjoint".
1396template <typename LHS, typename RHS>
1399m_AddLike(const LHS &L, const RHS &R) {
1400 return m_CombineOr(m_Add(L, R), m_DisjointOr(L, R));
1401}
1402
1403/// Match either "add nsw" or "or disjoint"
1404template <typename LHS, typename RHS>
1405inline match_combine_or<
1406 OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1409m_NSWAddLike(const LHS &L, const RHS &R) {
1410 return m_CombineOr(m_NSWAdd(L, R), m_DisjointOr(L, R));
1411}
1412
1413/// Match either "add nuw" or "or disjoint"
1414template <typename LHS, typename RHS>
1415inline match_combine_or<
1416 OverflowingBinaryOp_match<LHS, RHS, Instruction::Add,
1419m_NUWAddLike(const LHS &L, const RHS &R) {
1420 return m_CombineOr(m_NUWAdd(L, R), m_DisjointOr(L, R));
1421}
1422
1423//===----------------------------------------------------------------------===//
1424// Class that matches a group of binary opcodes.
1425//
1426template <typename LHS_t, typename RHS_t, typename Predicate,
1427 bool Commutable = false>
1428struct BinOpPred_match : Predicate {
1431
1432 BinOpPred_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
1433
1434 template <typename OpTy> bool match(OpTy *V) {
1435 if (auto *I = dyn_cast<Instruction>(V))
1436 return this->isOpType(I->getOpcode()) &&
1437 ((L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
1438 (Commutable && L.match(I->getOperand(1)) &&
1439 R.match(I->getOperand(0))));
1440 return false;
1441 }
1442};
1443
1445 bool isOpType(unsigned Opcode) { return Instruction::isShift(Opcode); }
1446};
1447
1449 bool isOpType(unsigned Opcode) {
1450 return Opcode == Instruction::LShr || Opcode == Instruction::AShr;
1451 }
1452};
1453
1455 bool isOpType(unsigned Opcode) {
1456 return Opcode == Instruction::LShr || Opcode == Instruction::Shl;
1457 }
1458};
1459
1461 bool isOpType(unsigned Opcode) {
1462 return Instruction::isBitwiseLogicOp(Opcode);
1463 }
1464};
1465
1467 bool isOpType(unsigned Opcode) {
1468 return Opcode == Instruction::SDiv || Opcode == Instruction::UDiv;
1469 }
1470};
1471
1473 bool isOpType(unsigned Opcode) {
1474 return Opcode == Instruction::SRem || Opcode == Instruction::URem;
1475 }
1476};
1477
1478/// Matches shift operations.
1479template <typename LHS, typename RHS>
1481 const RHS &R) {
1483}
1484
1485/// Matches logical shift operations.
1486template <typename LHS, typename RHS>
1488 const RHS &R) {
1490}
1491
1492/// Matches logical shift operations.
1493template <typename LHS, typename RHS>
1495m_LogicalShift(const LHS &L, const RHS &R) {
1497}
1498
1499/// Matches bitwise logic operations.
1500template <typename LHS, typename RHS>
1502m_BitwiseLogic(const LHS &L, const RHS &R) {
1504}
1505
1506/// Matches bitwise logic operations in either order.
1507template <typename LHS, typename RHS>
1509m_c_BitwiseLogic(const LHS &L, const RHS &R) {
1511}
1512
1513/// Matches integer division operations.
1514template <typename LHS, typename RHS>
1516 const RHS &R) {
1518}
1519
1520/// Matches integer remainder operations.
1521template <typename LHS, typename RHS>
1523 const RHS &R) {
1525}
1526
1527//===----------------------------------------------------------------------===//
1528// Class that matches exact binary ops.
1529//
1530template <typename SubPattern_t> struct Exact_match {
1531 SubPattern_t SubPattern;
1532
1533 Exact_match(const SubPattern_t &SP) : SubPattern(SP) {}
1534
1535 template <typename OpTy> bool match(OpTy *V) {
1536 if (auto *PEO = dyn_cast<PossiblyExactOperator>(V))
1537 return PEO->isExact() && SubPattern.match(V);
1538 return false;
1539 }
1540};
1541
1542template <typename T> inline Exact_match<T> m_Exact(const T &SubPattern) {
1543 return SubPattern;
1544}
1545
1546//===----------------------------------------------------------------------===//
1547// Matchers for CmpInst classes
1548//
1549
1550template <typename LHS_t, typename RHS_t, typename Class, typename PredicateTy,
1551 bool Commutable = false>
1553 PredicateTy *Predicate;
1556
1557 // The evaluation order is always stable, regardless of Commutability.
1558 // The LHS is always matched first.
1559 CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
1560 : Predicate(&Pred), L(LHS), R(RHS) {}
1562 : Predicate(nullptr), L(LHS), R(RHS) {}
1563
1564 template <typename OpTy> bool match(OpTy *V) {
1565 if (auto *I = dyn_cast<Class>(V)) {
1566 if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
1567 if (Predicate)
1568 *Predicate = I->getPredicate();
1569 return true;
1570 } else if (Commutable && L.match(I->getOperand(1)) &&
1571 R.match(I->getOperand(0))) {
1572 if (Predicate)
1573 *Predicate = I->getSwappedPredicate();
1574 return true;
1575 }
1576 }
1577 return false;
1578 }
1579};
1580
1581template <typename LHS, typename RHS>
1583m_Cmp(CmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1585}
1586
1587template <typename LHS, typename RHS>
1589m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1591}
1592
1593template <typename LHS, typename RHS>
1595m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
1597}
1598
1599template <typename LHS, typename RHS>
1601m_Cmp(const LHS &L, const RHS &R) {
1603}
1604
1605template <typename LHS, typename RHS>
1607m_ICmp(const LHS &L, const RHS &R) {
1609}
1610
1611template <typename LHS, typename RHS>
1613m_FCmp(const LHS &L, const RHS &R) {
1615}
1616
1617// Same as CmpClass, but instead of saving Pred as out output variable, match a
1618// specific input pred for equality.
1619template <typename LHS_t, typename RHS_t, typename Class, typename PredicateTy,
1620 bool Commutable = false>
1622 const PredicateTy Predicate;
1625
1626 SpecificCmpClass_match(PredicateTy Pred, const LHS_t &LHS, const RHS_t &RHS)
1627 : Predicate(Pred), L(LHS), R(RHS) {}
1628
1629 template <typename OpTy> bool match(OpTy *V) {
1630 if (auto *I = dyn_cast<Class>(V)) {
1631 if (I->getPredicate() == Predicate && L.match(I->getOperand(0)) &&
1632 R.match(I->getOperand(1)))
1633 return true;
1634 if constexpr (Commutable) {
1635 if (I->getPredicate() == Class::getSwappedPredicate(Predicate) &&
1636 L.match(I->getOperand(1)) && R.match(I->getOperand(0)))
1637 return true;
1638 }
1639 }
1640
1641 return false;
1642 }
1643};
1644
1645template <typename LHS, typename RHS>
1647m_SpecificCmp(CmpInst::Predicate MatchPred, const LHS &L, const RHS &R) {
1649 MatchPred, L, R);
1650}
1651
1652template <typename LHS, typename RHS>
1654m_SpecificICmp(ICmpInst::Predicate MatchPred, const LHS &L, const RHS &R) {
1656 MatchPred, L, R);
1657}
1658
1659template <typename LHS, typename RHS>
1661m_c_SpecificICmp(ICmpInst::Predicate MatchPred, const LHS &L, const RHS &R) {
1663 MatchPred, L, R);
1664}
1665
1666template <typename LHS, typename RHS>
1668m_SpecificFCmp(FCmpInst::Predicate MatchPred, const LHS &L, const RHS &R) {
1670 MatchPred, L, R);
1671}
1672
1673//===----------------------------------------------------------------------===//
1674// Matchers for instructions with a given opcode and number of operands.
1675//
1676
1677/// Matches instructions with Opcode and three operands.
1678template <typename T0, unsigned Opcode> struct OneOps_match {
1680
1681 OneOps_match(const T0 &Op1) : Op1(Op1) {}
1682
1683 template <typename OpTy> bool match(OpTy *V) {
1684 if (V->getValueID() == Value::InstructionVal + Opcode) {
1685 auto *I = cast<Instruction>(V);
1686 return Op1.match(I->getOperand(0));
1687 }
1688 return false;
1689 }
1690};
1691
1692/// Matches instructions with Opcode and three operands.
1693template <typename T0, typename T1, unsigned Opcode> struct TwoOps_match {
1696
1697 TwoOps_match(const T0 &Op1, const T1 &Op2) : Op1(Op1), Op2(Op2) {}
1698
1699 template <typename OpTy> bool match(OpTy *V) {
1700 if (V->getValueID() == Value::InstructionVal + Opcode) {
1701 auto *I = cast<Instruction>(V);
1702 return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1));
1703 }
1704 return false;
1705 }
1706};
1707
1708/// Matches instructions with Opcode and three operands.
1709template <typename T0, typename T1, typename T2, unsigned Opcode>
1714
1715 ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
1716 : Op1(Op1), Op2(Op2), Op3(Op3) {}
1717
1718 template <typename OpTy> bool match(OpTy *V) {
1719 if (V->getValueID() == Value::InstructionVal + Opcode) {
1720 auto *I = cast<Instruction>(V);
1721 return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1722 Op3.match(I->getOperand(2));
1723 }
1724 return false;
1725 }
1726};
1727
1728/// Matches instructions with Opcode and any number of operands
1729template <unsigned Opcode, typename... OperandTypes> struct AnyOps_match {
1730 std::tuple<OperandTypes...> Operands;
1731
1732 AnyOps_match(const OperandTypes &...Ops) : Operands(Ops...) {}
1733
1734 // Operand matching works by recursively calling match_operands, matching the
1735 // operands left to right. The first version is called for each operand but
1736 // the last, for which the second version is called. The second version of
1737 // match_operands is also used to match each individual operand.
1738 template <int Idx, int Last>
1739 std::enable_if_t<Idx != Last, bool> match_operands(const Instruction *I) {
1740 return match_operands<Idx, Idx>(I) && match_operands<Idx + 1, Last>(I);
1741 }
1742
1743 template <int Idx, int Last>
1744 std::enable_if_t<Idx == Last, bool> match_operands(const Instruction *I) {
1745 return std::get<Idx>(Operands).match(I->getOperand(Idx));
1746 }
1747
1748 template <typename OpTy> bool match(OpTy *V) {
1749 if (V->getValueID() == Value::InstructionVal + Opcode) {
1750 auto *I = cast<Instruction>(V);
1751 return I->getNumOperands() == sizeof...(OperandTypes) &&
1752 match_operands<0, sizeof...(OperandTypes) - 1>(I);
1753 }
1754 return false;
1755 }
1756};
1757
1758/// Matches SelectInst.
1759template <typename Cond, typename LHS, typename RHS>
1761m_Select(const Cond &C, const LHS &L, const RHS &R) {
1763}
1764
1765/// This matches a select of two constants, e.g.:
1766/// m_SelectCst<-1, 0>(m_Value(V))
1767template <int64_t L, int64_t R, typename Cond>
1769 Instruction::Select>
1771 return m_Select(C, m_ConstantInt<L>(), m_ConstantInt<R>());
1772}
1773
1774/// Matches FreezeInst.
1775template <typename OpTy>
1778}
1779
1780/// Matches InsertElementInst.
1781template <typename Val_t, typename Elt_t, typename Idx_t>
1783m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx) {
1785 Val, Elt, Idx);
1786}
1787
1788/// Matches ExtractElementInst.
1789template <typename Val_t, typename Idx_t>
1791m_ExtractElt(const Val_t &Val, const Idx_t &Idx) {
1793}
1794
1795/// Matches shuffle.
1796template <typename T0, typename T1, typename T2> struct Shuffle_match {
1800
1801 Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
1802 : Op1(Op1), Op2(Op2), Mask(Mask) {}
1803
1804 template <typename OpTy> bool match(OpTy *V) {
1805 if (auto *I = dyn_cast<ShuffleVectorInst>(V)) {
1806 return Op1.match(I->getOperand(0)) && Op2.match(I->getOperand(1)) &&
1807 Mask.match(I->getShuffleMask());
1808 }
1809 return false;
1810 }
1811};
1812
1813struct m_Mask {
1817 MaskRef = Mask;
1818 return true;
1819 }
1820};
1821
1824 return all_of(Mask, [](int Elem) { return Elem == 0 || Elem == -1; });
1825 }
1826};
1827
1831 bool match(ArrayRef<int> Mask) { return MaskRef == Mask; }
1832};
1833
1838 const auto *First = find_if(Mask, [](int Elem) { return Elem != -1; });
1839 if (First == Mask.end())
1840 return false;
1841 SplatIndex = *First;
1842 return all_of(Mask,
1843 [First](int Elem) { return Elem == *First || Elem == -1; });
1844 }
1845};
1846
1847template <typename PointerOpTy, typename OffsetOpTy> struct PtrAdd_match {
1848 PointerOpTy PointerOp;
1849 OffsetOpTy OffsetOp;
1850
1851 PtrAdd_match(const PointerOpTy &PointerOp, const OffsetOpTy &OffsetOp)
1853
1854 template <typename OpTy> bool match(OpTy *V) {
1855 auto *GEP = dyn_cast<GEPOperator>(V);
1856 return GEP && GEP->getSourceElementType()->isIntegerTy(8) &&
1857 PointerOp.match(GEP->getPointerOperand()) &&
1858 OffsetOp.match(GEP->idx_begin()->get());
1859 }
1860};
1861
1862/// Matches ShuffleVectorInst independently of mask value.
1863template <typename V1_t, typename V2_t>
1865m_Shuffle(const V1_t &v1, const V2_t &v2) {
1867}
1868
1869template <typename V1_t, typename V2_t, typename Mask_t>
1871m_Shuffle(const V1_t &v1, const V2_t &v2, const Mask_t &mask) {
1872 return Shuffle_match<V1_t, V2_t, Mask_t>(v1, v2, mask);
1873}
1874
1875/// Matches LoadInst.
1876template <typename OpTy>
1879}
1880
1881/// Matches StoreInst.
1882template <typename ValueOpTy, typename PointerOpTy>
1884m_Store(const ValueOpTy &ValueOp, const PointerOpTy &PointerOp) {
1886 PointerOp);
1887}
1888
1889/// Matches GetElementPtrInst.
1890template <typename... OperandTypes>
1891inline auto m_GEP(const OperandTypes &...Ops) {
1892 return AnyOps_match<Instruction::GetElementPtr, OperandTypes...>(Ops...);
1893}
1894
1895/// Matches GEP with i8 source element type
1896template <typename PointerOpTy, typename OffsetOpTy>
1898m_PtrAdd(const PointerOpTy &PointerOp, const OffsetOpTy &OffsetOp) {
1899 return PtrAdd_match<PointerOpTy, OffsetOpTy>(PointerOp, OffsetOp);
1900}
1901
1902//===----------------------------------------------------------------------===//
1903// Matchers for CastInst classes
1904//
1905
1906template <typename Op_t, unsigned Opcode> struct CastOperator_match {
1907 Op_t Op;
1908
1909 CastOperator_match(const Op_t &OpMatch) : Op(OpMatch) {}
1910
1911 template <typename OpTy> bool match(OpTy *V) {
1912 if (auto *O = dyn_cast<Operator>(V))
1913 return O->getOpcode() == Opcode && Op.match(O->getOperand(0));
1914 return false;
1915 }
1916};
1917
1918template <typename Op_t, typename Class> struct CastInst_match {
1919 Op_t Op;
1920
1921 CastInst_match(const Op_t &OpMatch) : Op(OpMatch) {}
1922
1923 template <typename OpTy> bool match(OpTy *V) {
1924 if (auto *I = dyn_cast<Class>(V))
1925 return Op.match(I->getOperand(0));
1926 return false;
1927 }
1928};
1929
1930template <typename Op_t> struct PtrToIntSameSize_match {
1932 Op_t Op;
1933
1934 PtrToIntSameSize_match(const DataLayout &DL, const Op_t &OpMatch)
1935 : DL(DL), Op(OpMatch) {}
1936
1937 template <typename OpTy> bool match(OpTy *V) {
1938 if (auto *O = dyn_cast<Operator>(V))
1939 return O->getOpcode() == Instruction::PtrToInt &&
1940 DL.getTypeSizeInBits(O->getType()) ==
1941 DL.getTypeSizeInBits(O->getOperand(0)->getType()) &&
1942 Op.match(O->getOperand(0));
1943 return false;
1944 }
1945};
1946
1947template <typename Op_t> struct NNegZExt_match {
1948 Op_t Op;
1949
1950 NNegZExt_match(const Op_t &OpMatch) : Op(OpMatch) {}
1951
1952 template <typename OpTy> bool match(OpTy *V) {
1953 if (auto *I = dyn_cast<ZExtInst>(V))
1954 return I->hasNonNeg() && Op.match(I->getOperand(0));
1955 return false;
1956 }
1957};
1958
1959template <typename Op_t, unsigned WrapFlags = 0> struct NoWrapTrunc_match {
1960 Op_t Op;
1961
1962 NoWrapTrunc_match(const Op_t &OpMatch) : Op(OpMatch) {}
1963
1964 template <typename OpTy> bool match(OpTy *V) {
1965 if (auto *I = dyn_cast<TruncInst>(V))
1966 return (I->getNoWrapKind() & WrapFlags) == WrapFlags &&
1967 Op.match(I->getOperand(0));
1968 return false;
1969 }
1970};
1971
1972/// Matches BitCast.
1973template <typename OpTy>
1975m_BitCast(const OpTy &Op) {
1977}
1978
1979template <typename Op_t> struct ElementWiseBitCast_match {
1980 Op_t Op;
1981
1982 ElementWiseBitCast_match(const Op_t &OpMatch) : Op(OpMatch) {}
1983
1984 template <typename OpTy> bool match(OpTy *V) {
1985 auto *I = dyn_cast<BitCastInst>(V);
1986 if (!I)
1987 return false;
1988 Type *SrcType = I->getSrcTy();
1989 Type *DstType = I->getType();
1990 // Make sure the bitcast doesn't change between scalar and vector and
1991 // doesn't change the number of vector elements.
1992 if (SrcType->isVectorTy() != DstType->isVectorTy())
1993 return false;
1994 if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcType);
1995 SrcVecTy && SrcVecTy->getElementCount() !=
1996 cast<VectorType>(DstType)->getElementCount())
1997 return false;
1998 return Op.match(I->getOperand(0));
1999 }
2000};
2001
2002template <typename OpTy>
2005}
2006
2007/// Matches PtrToInt.
2008template <typename OpTy>
2010m_PtrToInt(const OpTy &Op) {
2012}
2013
2014template <typename OpTy>
2016 const OpTy &Op) {
2018}
2019
2020/// Matches IntToPtr.
2021template <typename OpTy>
2023m_IntToPtr(const OpTy &Op) {
2025}
2026
2027/// Matches Trunc.
2028template <typename OpTy>
2031}
2032
2033/// Matches trunc nuw.
2034template <typename OpTy>
2036m_NUWTrunc(const OpTy &Op) {
2038}
2039
2040/// Matches trunc nsw.
2041template <typename OpTy>
2043m_NSWTrunc(const OpTy &Op) {
2045}
2046
2047template <typename OpTy>
2049m_TruncOrSelf(const OpTy &Op) {
2050 return m_CombineOr(m_Trunc(Op), Op);
2051}
2052
2053/// Matches SExt.
2054template <typename OpTy>
2057}
2058
2059/// Matches ZExt.
2060template <typename OpTy>
2063}
2064
2065template <typename OpTy>
2067 return NNegZExt_match<OpTy>(Op);
2068}
2069
2070template <typename OpTy>
2072m_ZExtOrSelf(const OpTy &Op) {
2073 return m_CombineOr(m_ZExt(Op), Op);
2074}
2075
2076template <typename OpTy>
2078m_SExtOrSelf(const OpTy &Op) {
2079 return m_CombineOr(m_SExt(Op), Op);
2080}
2081
2082/// Match either "sext" or "zext nneg".
2083template <typename OpTy>
2085m_SExtLike(const OpTy &Op) {
2086 return m_CombineOr(m_SExt(Op), m_NNegZExt(Op));
2087}
2088
2089template <typename OpTy>
2092m_ZExtOrSExt(const OpTy &Op) {
2093 return m_CombineOr(m_ZExt(Op), m_SExt(Op));
2094}
2095
2096template <typename OpTy>
2099 OpTy>
2101 return m_CombineOr(m_ZExtOrSExt(Op), Op);
2102}
2103
2104template <typename OpTy>
2107}
2108
2109template <typename OpTy>
2112}
2113
2114template <typename OpTy>
2117}
2118
2119template <typename OpTy>
2122}
2123
2124template <typename OpTy>
2127}
2128
2129template <typename OpTy>
2132}
2133
2134//===----------------------------------------------------------------------===//
2135// Matchers for control flow.
2136//
2137
2138struct br_match {
2140
2142
2143 template <typename OpTy> bool match(OpTy *V) {
2144 if (auto *BI = dyn_cast<BranchInst>(V))
2145 if (BI->isUnconditional()) {
2146 Succ = BI->getSuccessor(0);
2147 return true;
2148 }
2149 return false;
2150 }
2151};
2152
2153inline br_match m_UnconditionalBr(BasicBlock *&Succ) { return br_match(Succ); }
2154
2155template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
2157 Cond_t Cond;
2158 TrueBlock_t T;
2159 FalseBlock_t F;
2160
2161 brc_match(const Cond_t &C, const TrueBlock_t &t, const FalseBlock_t &f)
2162 : Cond(C), T(t), F(f) {}
2163
2164 template <typename OpTy> bool match(OpTy *V) {
2165 if (auto *BI = dyn_cast<BranchInst>(V))
2166 if (BI->isConditional() && Cond.match(BI->getCondition()))
2167 return T.match(BI->getSuccessor(0)) && F.match(BI->getSuccessor(1));
2168 return false;
2169 }
2170};
2171
2172template <typename Cond_t>
2174m_Br(const Cond_t &C, BasicBlock *&T, BasicBlock *&F) {
2177}
2178
2179template <typename Cond_t, typename TrueBlock_t, typename FalseBlock_t>
2181m_Br(const Cond_t &C, const TrueBlock_t &T, const FalseBlock_t &F) {
2183}
2184
2185//===----------------------------------------------------------------------===//
2186// Matchers for max/min idioms, eg: "select (sgt x, y), x, y" -> smax(x,y).
2187//
2188
2189template <typename CmpInst_t, typename LHS_t, typename RHS_t, typename Pred_t,
2190 bool Commutable = false>
2192 using PredType = Pred_t;
2195
2196 // The evaluation order is always stable, regardless of Commutability.
2197 // The LHS is always matched first.
2198 MaxMin_match(const LHS_t &LHS, const RHS_t &RHS) : L(LHS), R(RHS) {}
2199
2200 template <typename OpTy> bool match(OpTy *V) {
2201 if (auto *II = dyn_cast<IntrinsicInst>(V)) {
2202 Intrinsic::ID IID = II->getIntrinsicID();
2203 if ((IID == Intrinsic::smax && Pred_t::match(ICmpInst::ICMP_SGT)) ||
2204 (IID == Intrinsic::smin && Pred_t::match(ICmpInst::ICMP_SLT)) ||
2205 (IID == Intrinsic::umax && Pred_t::match(ICmpInst::ICMP_UGT)) ||
2206 (IID == Intrinsic::umin && Pred_t::match(ICmpInst::ICMP_ULT))) {
2207 Value *LHS = II->getOperand(0), *RHS = II->getOperand(1);
2208 return (L.match(LHS) && R.match(RHS)) ||
2209 (Commutable && L.match(RHS) && R.match(LHS));
2210 }
2211 }
2212 // Look for "(x pred y) ? x : y" or "(x pred y) ? y : x".
2213 auto *SI = dyn_cast<SelectInst>(V);
2214 if (!SI)
2215 return false;
2216 auto *Cmp = dyn_cast<CmpInst_t>(SI->getCondition());
2217 if (!Cmp)
2218 return false;
2219 // At this point we have a select conditioned on a comparison. Check that
2220 // it is the values returned by the select that are being compared.
2221 auto *TrueVal = SI->getTrueValue();
2222 auto *FalseVal = SI->getFalseValue();
2223 auto *LHS = Cmp->getOperand(0);
2224 auto *RHS = Cmp->getOperand(1);
2225 if ((TrueVal != LHS || FalseVal != RHS) &&
2226 (TrueVal != RHS || FalseVal != LHS))
2227 return false;
2228 typename CmpInst_t::Predicate Pred =
2229 LHS == TrueVal ? Cmp->getPredicate() : Cmp->getInversePredicate();
2230 // Does "(x pred y) ? x : y" represent the desired max/min operation?
2231 if (!Pred_t::match(Pred))
2232 return false;
2233 // It does! Bind the operands.
2234 return (L.match(LHS) && R.match(RHS)) ||
2235 (Commutable && L.match(RHS) && R.match(LHS));
2236 }
2237};
2238
2239/// Helper class for identifying signed max predicates.
2241 static bool match(ICmpInst::Predicate Pred) {
2242 return Pred == CmpInst::ICMP_SGT || Pred == CmpInst::ICMP_SGE;
2243 }
2244};
2245
2246/// Helper class for identifying signed min predicates.
2248 static bool match(ICmpInst::Predicate Pred) {
2249 return Pred == CmpInst::ICMP_SLT || Pred == CmpInst::ICMP_SLE;
2250 }
2251};
2252
2253/// Helper class for identifying unsigned max predicates.
2255 static bool match(ICmpInst::Predicate Pred) {
2256 return Pred == CmpInst::ICMP_UGT || Pred == CmpInst::ICMP_UGE;
2257 }
2258};
2259
2260/// Helper class for identifying unsigned min predicates.
2262 static bool match(ICmpInst::Predicate Pred) {
2263 return Pred == CmpInst::ICMP_ULT || Pred == CmpInst::ICMP_ULE;
2264 }
2265};
2266
2267/// Helper class for identifying ordered max predicates.
2269 static bool match(FCmpInst::Predicate Pred) {
2270 return Pred == CmpInst::FCMP_OGT || Pred == CmpInst::FCMP_OGE;
2271 }
2272};
2273
2274/// Helper class for identifying ordered min predicates.
2276 static bool match(FCmpInst::Predicate Pred) {
2277 return Pred == CmpInst::FCMP_OLT || Pred == CmpInst::FCMP_OLE;
2278 }
2279};
2280
2281/// Helper class for identifying unordered max predicates.
2283 static bool match(FCmpInst::Predicate Pred) {
2284 return Pred == CmpInst::FCMP_UGT || Pred == CmpInst::FCMP_UGE;
2285 }
2286};
2287
2288/// Helper class for identifying unordered min predicates.
2290 static bool match(FCmpInst::Predicate Pred) {
2291 return Pred == CmpInst::FCMP_ULT || Pred == CmpInst::FCMP_ULE;
2292 }
2293};
2294
2295template <typename LHS, typename RHS>
2297 const RHS &R) {
2299}
2300
2301template <typename LHS, typename RHS>
2303 const RHS &R) {
2305}
2306
2307template <typename LHS, typename RHS>
2309 const RHS &R) {
2311}
2312
2313template <typename LHS, typename RHS>
2315 const RHS &R) {
2317}
2318
2319template <typename LHS, typename RHS>
2320inline match_combine_or<
2325m_MaxOrMin(const LHS &L, const RHS &R) {
2326 return m_CombineOr(m_CombineOr(m_SMax(L, R), m_SMin(L, R)),
2327 m_CombineOr(m_UMax(L, R), m_UMin(L, R)));
2328}
2329
2330/// Match an 'ordered' floating point maximum function.
2331/// Floating point has one special value 'NaN'. Therefore, there is no total
2332/// order. However, if we can ignore the 'NaN' value (for example, because of a
2333/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
2334/// semantics. In the presence of 'NaN' we have to preserve the original
2335/// select(fcmp(ogt/ge, L, R), L, R) semantics matched by this predicate.
2336///
2337/// max(L, R) iff L and R are not NaN
2338/// m_OrdFMax(L, R) = R iff L or R are NaN
2339template <typename LHS, typename RHS>
2341 const RHS &R) {
2343}
2344
2345/// Match an 'ordered' floating point minimum function.
2346/// Floating point has one special value 'NaN'. Therefore, there is no total
2347/// order. However, if we can ignore the 'NaN' value (for example, because of a
2348/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
2349/// semantics. In the presence of 'NaN' we have to preserve the original
2350/// select(fcmp(olt/le, L, R), L, R) semantics matched by this predicate.
2351///
2352/// min(L, R) iff L and R are not NaN
2353/// m_OrdFMin(L, R) = R iff L or R are NaN
2354template <typename LHS, typename RHS>
2356 const RHS &R) {
2358}
2359
2360/// Match an 'unordered' floating point maximum function.
2361/// Floating point has one special value 'NaN'. Therefore, there is no total
2362/// order. However, if we can ignore the 'NaN' value (for example, because of a
2363/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
2364/// semantics. In the presence of 'NaN' we have to preserve the original
2365/// select(fcmp(ugt/ge, L, R), L, R) semantics matched by this predicate.
2366///
2367/// max(L, R) iff L and R are not NaN
2368/// m_UnordFMax(L, R) = L iff L or R are NaN
2369template <typename LHS, typename RHS>
2371m_UnordFMax(const LHS &L, const RHS &R) {
2373}
2374
2375/// Match an 'unordered' floating point minimum function.
2376/// Floating point has one special value 'NaN'. Therefore, there is no total
2377/// order. However, if we can ignore the 'NaN' value (for example, because of a
2378/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
2379/// semantics. In the presence of 'NaN' we have to preserve the original
2380/// select(fcmp(ult/le, L, R), L, R) semantics matched by this predicate.
2381///
2382/// min(L, R) iff L and R are not NaN
2383/// m_UnordFMin(L, R) = L iff L or R are NaN
2384template <typename LHS, typename RHS>
2386m_UnordFMin(const LHS &L, const RHS &R) {
2388}
2389
2390/// Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
2391/// NOTE: we first match the 'Not' (by matching '-1'),
2392/// and only then match the inner matcher!
2393template <typename ValTy>
2394inline BinaryOp_match<cst_pred_ty<is_all_ones>, ValTy, Instruction::Xor, true>
2395m_Not(const ValTy &V) {
2396 return m_c_Xor(m_AllOnes(), V);
2397}
2398
2399template <typename ValTy>
2400inline BinaryOp_match<cst_pred_ty<is_all_ones, false>, ValTy, Instruction::Xor,
2401 true>
2402m_NotForbidPoison(const ValTy &V) {
2403 return m_c_Xor(m_AllOnesForbidPoison(), V);
2404}
2405
2406//===----------------------------------------------------------------------===//
2407// Matchers for overflow check patterns: e.g. (a + b) u< a, (a ^ -1) <u b
2408// Note that S might be matched to other instructions than AddInst.
2409//
2410
2411template <typename LHS_t, typename RHS_t, typename Sum_t>
2415 Sum_t S;
2416
2417 UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
2418 : L(L), R(R), S(S) {}
2419
2420 template <typename OpTy> bool match(OpTy *V) {
2421 Value *ICmpLHS, *ICmpRHS;
2423 if (!m_ICmp(Pred, m_Value(ICmpLHS), m_Value(ICmpRHS)).match(V))
2424 return false;
2425
2426 Value *AddLHS, *AddRHS;
2427 auto AddExpr = m_Add(m_Value(AddLHS), m_Value(AddRHS));
2428
2429 // (a + b) u< a, (a + b) u< b
2430 if (Pred == ICmpInst::ICMP_ULT)
2431 if (AddExpr.match(ICmpLHS) && (ICmpRHS == AddLHS || ICmpRHS == AddRHS))
2432 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
2433
2434 // a >u (a + b), b >u (a + b)
2435 if (Pred == ICmpInst::ICMP_UGT)
2436 if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
2437 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
2438
2439 Value *Op1;
2440 auto XorExpr = m_OneUse(m_Not(m_Value(Op1)));
2441 // (~a) <u b
2442 if (Pred == ICmpInst::ICMP_ULT) {
2443 if (XorExpr.match(ICmpLHS))
2444 return L.match(Op1) && R.match(ICmpRHS) && S.match(ICmpLHS);
2445 }
2446 // b > u (~a)
2447 if (Pred == ICmpInst::ICMP_UGT) {
2448 if (XorExpr.match(ICmpRHS))
2449 return L.match(Op1) && R.match(ICmpLHS) && S.match(ICmpRHS);
2450 }
2451
2452 // Match special-case for increment-by-1.
2453 if (Pred == ICmpInst::ICMP_EQ) {
2454 // (a + 1) == 0
2455 // (1 + a) == 0
2456 if (AddExpr.match(ICmpLHS) && m_ZeroInt().match(ICmpRHS) &&
2457 (m_One().match(AddLHS) || m_One().match(AddRHS)))
2458 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpLHS);
2459 // 0 == (a + 1)
2460 // 0 == (1 + a)
2461 if (m_ZeroInt().match(ICmpLHS) && AddExpr.match(ICmpRHS) &&
2462 (m_One().match(AddLHS) || m_One().match(AddRHS)))
2463 return L.match(AddLHS) && R.match(AddRHS) && S.match(ICmpRHS);
2464 }
2465
2466 return false;
2467 }
2468};
2469
2470/// Match an icmp instruction checking for unsigned overflow on addition.
2471///
2472/// S is matched to the addition whose result is being checked for overflow, and
2473/// L and R are matched to the LHS and RHS of S.
2474template <typename LHS_t, typename RHS_t, typename Sum_t>
2476m_UAddWithOverflow(const LHS_t &L, const RHS_t &R, const Sum_t &S) {
2478}
2479
2480template <typename Opnd_t> struct Argument_match {
2481 unsigned OpI;
2482 Opnd_t Val;
2483
2484 Argument_match(unsigned OpIdx, const Opnd_t &V) : OpI(OpIdx), Val(V) {}
2485
2486 template <typename OpTy> bool match(OpTy *V) {
2487 // FIXME: Should likely be switched to use `CallBase`.
2488 if (const auto *CI = dyn_cast<CallInst>(V))
2489 return Val.match(CI->getArgOperand(OpI));
2490 return false;
2491 }
2492};
2493
2494/// Match an argument.
2495template <unsigned OpI, typename Opnd_t>
2496inline Argument_match<Opnd_t> m_Argument(const Opnd_t &Op) {
2497 return Argument_match<Opnd_t>(OpI, Op);
2498}
2499
2500/// Intrinsic matchers.
2502 unsigned ID;
2503
2505
2506 template <typename OpTy> bool match(OpTy *V) {
2507 if (const auto *CI = dyn_cast<CallInst>(V))
2508 if (const auto *F = CI->getCalledFunction())
2509 return F->getIntrinsicID() == ID;
2510 return false;
2511 }
2512};
2513
2514/// Intrinsic matches are combinations of ID matchers, and argument
2515/// matchers. Higher arity matcher are defined recursively in terms of and-ing
2516/// them with lower arity matchers. Here's some convenient typedefs for up to
2517/// several arguments, and more can be added as needed
2518template <typename T0 = void, typename T1 = void, typename T2 = void,
2519 typename T3 = void, typename T4 = void, typename T5 = void,
2520 typename T6 = void, typename T7 = void, typename T8 = void,
2521 typename T9 = void, typename T10 = void>
2523template <typename T0> struct m_Intrinsic_Ty<T0> {
2525};
2526template <typename T0, typename T1> struct m_Intrinsic_Ty<T0, T1> {
2527 using Ty =
2529};
2530template <typename T0, typename T1, typename T2>
2531struct m_Intrinsic_Ty<T0, T1, T2> {
2534};
2535template <typename T0, typename T1, typename T2, typename T3>
2536struct m_Intrinsic_Ty<T0, T1, T2, T3> {
2539};
2540
2541template <typename T0, typename T1, typename T2, typename T3, typename T4>
2542struct m_Intrinsic_Ty<T0, T1, T2, T3, T4> {
2545};
2546
2547template <typename T0, typename T1, typename T2, typename T3, typename T4,
2548 typename T5>
2549struct m_Intrinsic_Ty<T0, T1, T2, T3, T4, T5> {
2552};
2553
2554/// Match intrinsic calls like this:
2555/// m_Intrinsic<Intrinsic::fabs>(m_Value(X))
2556template <Intrinsic::ID IntrID> inline IntrinsicID_match m_Intrinsic() {
2557 return IntrinsicID_match(IntrID);
2558}
2559
2560/// Matches MaskedLoad Intrinsic.
2561template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2563m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2564 const Opnd3 &Op3) {
2565 return m_Intrinsic<Intrinsic::masked_load>(Op0, Op1, Op2, Op3);
2566}
2567
2568/// Matches MaskedGather Intrinsic.
2569template <typename Opnd0, typename Opnd1, typename Opnd2, typename Opnd3>
2571m_MaskedGather(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2,
2572 const Opnd3 &Op3) {
2573 return m_Intrinsic<Intrinsic::masked_gather>(Op0, Op1, Op2, Op3);
2574}
2575
2576template <Intrinsic::ID IntrID, typename T0>
2577inline typename m_Intrinsic_Ty<T0>::Ty m_Intrinsic(const T0 &Op0) {
2578 return m_CombineAnd(m_Intrinsic<IntrID>(), m_Argument<0>(Op0));
2579}
2580
2581template <Intrinsic::ID IntrID, typename T0, typename T1>
2582inline typename m_Intrinsic_Ty<T0, T1>::Ty m_Intrinsic(const T0 &Op0,
2583 const T1 &Op1) {
2584 return m_CombineAnd(m_Intrinsic<IntrID>(Op0), m_Argument<1>(Op1));
2585}
2586
2587template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2>
2588inline typename m_Intrinsic_Ty<T0, T1, T2>::Ty
2589m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2) {
2590 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1), m_Argument<2>(Op2));
2591}
2592
2593template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2594 typename T3>
2596m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3) {
2597 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2), m_Argument<3>(Op3));
2598}
2599
2600template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2601 typename T3, typename T4>
2603m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2604 const T4 &Op4) {
2605 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3),
2606 m_Argument<4>(Op4));
2607}
2608
2609template <Intrinsic::ID IntrID, typename T0, typename T1, typename T2,
2610 typename T3, typename T4, typename T5>
2612m_Intrinsic(const T0 &Op0, const T1 &Op1, const T2 &Op2, const T3 &Op3,
2613 const T4 &Op4, const T5 &Op5) {
2614 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3, Op4),
2615 m_Argument<5>(Op5));
2616}
2617
2618// Helper intrinsic matching specializations.
2619template <typename Opnd0>
2620inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BitReverse(const Opnd0 &Op0) {
2621 return m_Intrinsic<Intrinsic::bitreverse>(Op0);
2622}
2623
2624template <typename Opnd0>
2625inline typename m_Intrinsic_Ty<Opnd0>::Ty m_BSwap(const Opnd0 &Op0) {
2626 return m_Intrinsic<Intrinsic::bswap>(Op0);
2627}
2628
2629template <typename Opnd0>
2630inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FAbs(const Opnd0 &Op0) {
2631 return m_Intrinsic<Intrinsic::fabs>(Op0);
2632}
2633
2634template <typename Opnd0>
2635inline typename m_Intrinsic_Ty<Opnd0>::Ty m_FCanonicalize(const Opnd0 &Op0) {
2636 return m_Intrinsic<Intrinsic::canonicalize>(Op0);
2637}
2638
2639template <typename Opnd0, typename Opnd1>
2640inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMin(const Opnd0 &Op0,
2641 const Opnd1 &Op1) {
2642 return m_Intrinsic<Intrinsic::minnum>(Op0, Op1);
2643}
2644
2645template <typename Opnd0, typename Opnd1>
2646inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_FMax(const Opnd0 &Op0,
2647 const Opnd1 &Op1) {
2648 return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
2649}
2650
2651template <typename Opnd0, typename Opnd1, typename Opnd2>
2653m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2654 return m_Intrinsic<Intrinsic::fshl>(Op0, Op1, Op2);
2655}
2656
2657template <typename Opnd0, typename Opnd1, typename Opnd2>
2659m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2) {
2660 return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
2661}
2662
2663template <typename Opnd0>
2664inline typename m_Intrinsic_Ty<Opnd0>::Ty m_Sqrt(const Opnd0 &Op0) {
2665 return m_Intrinsic<Intrinsic::sqrt>(Op0);
2666}
2667
2668template <typename Opnd0, typename Opnd1>
2669inline typename m_Intrinsic_Ty<Opnd0, Opnd1>::Ty m_CopySign(const Opnd0 &Op0,
2670 const Opnd1 &Op1) {
2671 return m_Intrinsic<Intrinsic::copysign>(Op0, Op1);
2672}
2673
2674template <typename Opnd0>
2675inline typename m_Intrinsic_Ty<Opnd0>::Ty m_VecReverse(const Opnd0 &Op0) {
2676 return m_Intrinsic<Intrinsic::vector_reverse>(Op0);
2677}
2678
2679//===----------------------------------------------------------------------===//
2680// Matchers for two-operands operators with the operators in either order
2681//
2682
2683/// Matches a BinaryOperator with LHS and RHS in either order.
2684template <typename LHS, typename RHS>
2687}
2688
2689/// Matches an ICmp with a predicate over LHS and RHS in either order.
2690/// Swaps the predicate if operands are commuted.
2691template <typename LHS, typename RHS>
2693m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
2695 R);
2696}
2697
2698template <typename LHS, typename RHS>
2700m_c_ICmp(const LHS &L, const RHS &R) {
2702}
2703
2704/// Matches a specific opcode with LHS and RHS in either order.
2705template <typename LHS, typename RHS>
2707m_c_BinOp(unsigned Opcode, const LHS &L, const RHS &R) {
2708 return SpecificBinaryOp_match<LHS, RHS, true>(Opcode, L, R);
2709}
2710
2711/// Matches a Add with LHS and RHS in either order.
2712template <typename LHS, typename RHS>
2714 const RHS &R) {
2716}
2717
2718/// Matches a Mul with LHS and RHS in either order.
2719template <typename LHS, typename RHS>
2721 const RHS &R) {
2723}
2724
2725/// Matches an And with LHS and RHS in either order.
2726template <typename LHS, typename RHS>
2728 const RHS &R) {
2730}
2731
2732/// Matches an Or with LHS and RHS in either order.
2733template <typename LHS, typename RHS>
2735 const RHS &R) {
2737}
2738
2739/// Matches an Xor with LHS and RHS in either order.
2740template <typename LHS, typename RHS>
2742 const RHS &R) {
2744}
2745
2746/// Matches a 'Neg' as 'sub 0, V'.
2747template <typename ValTy>
2748inline BinaryOp_match<cst_pred_ty<is_zero_int>, ValTy, Instruction::Sub>
2749m_Neg(const ValTy &V) {
2750 return m_Sub(m_ZeroInt(), V);
2751}
2752
2753/// Matches a 'Neg' as 'sub nsw 0, V'.
2754template <typename ValTy>
2756 Instruction::Sub,
2758m_NSWNeg(const ValTy &V) {
2759 return m_NSWSub(m_ZeroInt(), V);
2760}
2761
2762/// Matches an SMin with LHS and RHS in either order.
2763template <typename LHS, typename RHS>
2765m_c_SMin(const LHS &L, const RHS &R) {
2767}
2768/// Matches an SMax with LHS and RHS in either order.
2769template <typename LHS, typename RHS>
2771m_c_SMax(const LHS &L, const RHS &R) {
2773}
2774/// Matches a UMin with LHS and RHS in either order.
2775template <typename LHS, typename RHS>
2777m_c_UMin(const LHS &L, const RHS &R) {
2779}
2780/// Matches a UMax with LHS and RHS in either order.
2781template <typename LHS, typename RHS>
2783m_c_UMax(const LHS &L, const RHS &R) {
2785}
2786
2787template <typename LHS, typename RHS>
2788inline match_combine_or<
2793m_c_MaxOrMin(const LHS &L, const RHS &R) {
2794 return m_CombineOr(m_CombineOr(m_c_SMax(L, R), m_c_SMin(L, R)),
2795 m_CombineOr(m_c_UMax(L, R), m_c_UMin(L, R)));
2796}
2797
2798template <Intrinsic::ID IntrID, typename T0, typename T1>
2801m_c_Intrinsic(const T0 &Op0, const T1 &Op1) {
2802 return m_CombineOr(m_Intrinsic<IntrID>(Op0, Op1),
2803 m_Intrinsic<IntrID>(Op1, Op0));
2804}
2805
2806/// Matches FAdd with LHS and RHS in either order.
2807template <typename LHS, typename RHS>
2809m_c_FAdd(const LHS &L, const RHS &R) {
2811}
2812
2813/// Matches FMul with LHS and RHS in either order.
2814template <typename LHS, typename RHS>
2816m_c_FMul(const LHS &L, const RHS &R) {
2818}
2819
2820template <typename Opnd_t> struct Signum_match {
2821 Opnd_t Val;
2822 Signum_match(const Opnd_t &V) : Val(V) {}
2823
2824 template <typename OpTy> bool match(OpTy *V) {
2825 unsigned TypeSize = V->getType()->getScalarSizeInBits();
2826 if (TypeSize == 0)
2827 return false;
2828
2829 unsigned ShiftWidth = TypeSize - 1;
2830 Value *OpL = nullptr, *OpR = nullptr;
2831
2832 // This is the representation of signum we match:
2833 //
2834 // signum(x) == (x >> 63) | (-x >>u 63)
2835 //
2836 // An i1 value is its own signum, so it's correct to match
2837 //
2838 // signum(x) == (x >> 0) | (-x >>u 0)
2839 //
2840 // for i1 values.
2841
2842 auto LHS = m_AShr(m_Value(OpL), m_SpecificInt(ShiftWidth));
2843 auto RHS = m_LShr(m_Neg(m_Value(OpR)), m_SpecificInt(ShiftWidth));
2844 auto Signum = m_Or(LHS, RHS);
2845
2846 return Signum.match(V) && OpL == OpR && Val.match(OpL);
2847 }
2848};
2849
2850/// Matches a signum pattern.
2851///
2852/// signum(x) =
2853/// x > 0 -> 1
2854/// x == 0 -> 0
2855/// x < 0 -> -1
2856template <typename Val_t> inline Signum_match<Val_t> m_Signum(const Val_t &V) {
2857 return Signum_match<Val_t>(V);
2858}
2859
2860template <int Ind, typename Opnd_t> struct ExtractValue_match {
2861 Opnd_t Val;
2862 ExtractValue_match(const Opnd_t &V) : Val(V) {}
2863
2864 template <typename OpTy> bool match(OpTy *V) {
2865 if (auto *I = dyn_cast<ExtractValueInst>(V)) {
2866 // If Ind is -1, don't inspect indices
2867 if (Ind != -1 &&
2868 !(I->getNumIndices() == 1 && I->getIndices()[0] == (unsigned)Ind))
2869 return false;
2870 return Val.match(I->getAggregateOperand());
2871 }
2872 return false;
2873 }
2874};
2875
2876/// Match a single index ExtractValue instruction.
2877/// For example m_ExtractValue<1>(...)
2878template <int Ind, typename Val_t>
2881}
2882
2883/// Match an ExtractValue instruction with any index.
2884/// For example m_ExtractValue(...)
2885template <typename Val_t>
2886inline ExtractValue_match<-1, Val_t> m_ExtractValue(const Val_t &V) {
2887 return ExtractValue_match<-1, Val_t>(V);
2888}
2889
2890/// Matcher for a single index InsertValue instruction.
2891template <int Ind, typename T0, typename T1> struct InsertValue_match {
2894
2895 InsertValue_match(const T0 &Op0, const T1 &Op1) : Op0(Op0), Op1(Op1) {}
2896
2897 template <typename OpTy> bool match(OpTy *V) {
2898 if (auto *I = dyn_cast<InsertValueInst>(V)) {
2899 return Op0.match(I->getOperand(0)) && Op1.match(I->getOperand(1)) &&
2900 I->getNumIndices() == 1 && Ind == I->getIndices()[0];
2901 }
2902 return false;
2903 }
2904};
2905
2906/// Matches a single index InsertValue instruction.
2907template <int Ind, typename Val_t, typename Elt_t>
2909 const Elt_t &Elt) {
2910 return InsertValue_match<Ind, Val_t, Elt_t>(Val, Elt);
2911}
2912
2913/// Matches patterns for `vscale`. This can either be a call to `llvm.vscale` or
2914/// the constant expression
2915/// `ptrtoint(gep <vscale x 1 x i8>, <vscale x 1 x i8>* null, i32 1>`
2916/// under the right conditions determined by DataLayout.
2918 template <typename ITy> bool match(ITy *V) {
2919 if (m_Intrinsic<Intrinsic::vscale>().match(V))
2920 return true;
2921
2922 Value *Ptr;
2923 if (m_PtrToInt(m_Value(Ptr)).match(V)) {
2924 if (auto *GEP = dyn_cast<GEPOperator>(Ptr)) {
2925 auto *DerefTy =
2926 dyn_cast<ScalableVectorType>(GEP->getSourceElementType());
2927 if (GEP->getNumIndices() == 1 && DerefTy &&
2928 DerefTy->getElementType()->isIntegerTy(8) &&
2929 m_Zero().match(GEP->getPointerOperand()) &&
2930 m_SpecificInt(1).match(GEP->idx_begin()->get()))
2931 return true;
2932 }
2933 }
2934
2935 return false;
2936 }
2937};
2938
2940 return VScaleVal_match();
2941}
2942
2943template <typename Opnd0, typename Opnd1>
2945m_Interleave2(const Opnd0 &Op0, const Opnd1 &Op1) {
2946 return m_Intrinsic<Intrinsic::vector_interleave2>(Op0, Op1);
2947}
2948
2949template <typename Opnd>
2950inline typename m_Intrinsic_Ty<Opnd>::Ty m_Deinterleave2(const Opnd &Op) {
2951 return m_Intrinsic<Intrinsic::vector_deinterleave2>(Op);
2952}
2953
2954template <typename LHS, typename RHS, unsigned Opcode, bool Commutable = false>
2958
2959 LogicalOp_match(const LHS &L, const RHS &R) : L(L), R(R) {}
2960
2961 template <typename T> bool match(T *V) {
2962 auto *I = dyn_cast<Instruction>(V);
2963 if (!I || !I->getType()->isIntOrIntVectorTy(1))
2964 return false;
2965
2966 if (I->getOpcode() == Opcode) {
2967 auto *Op0 = I->getOperand(0);
2968 auto *Op1 = I->getOperand(1);
2969 return (L.match(Op0) && R.match(Op1)) ||
2970 (Commutable && L.match(Op1) && R.match(Op0));
2971 }
2972
2973 if (auto *Select = dyn_cast<SelectInst>(I)) {
2974 auto *Cond = Select->getCondition();
2975 auto *TVal = Select->getTrueValue();
2976 auto *FVal = Select->getFalseValue();
2977
2978 // Don't match a scalar select of bool vectors.
2979 // Transforms expect a single type for operands if this matches.
2980 if (Cond->getType() != Select->getType())
2981 return false;
2982
2983 if (Opcode == Instruction::And) {
2984 auto *C = dyn_cast<Constant>(FVal);
2985 if (C && C->isNullValue())
2986 return (L.match(Cond) && R.match(TVal)) ||
2987 (Commutable && L.match(TVal) && R.match(Cond));
2988 } else {
2989 assert(Opcode == Instruction::Or);
2990 auto *C = dyn_cast<Constant>(TVal);
2991 if (C && C->isOneValue())
2992 return (L.match(Cond) && R.match(FVal)) ||
2993 (Commutable && L.match(FVal) && R.match(Cond));
2994 }
2995 }
2996
2997 return false;
2998 }
2999};
3000
3001/// Matches L && R either in the form of L & R or L ? R : false.
3002/// Note that the latter form is poison-blocking.
3003template <typename LHS, typename RHS>
3005 const RHS &R) {
3007}
3008
3009/// Matches L && R where L and R are arbitrary values.
3010inline auto m_LogicalAnd() { return m_LogicalAnd(m_Value(), m_Value()); }
3011
3012/// Matches L && R with LHS and RHS in either order.
3013template <typename LHS, typename RHS>
3015m_c_LogicalAnd(const LHS &L, const RHS &R) {
3017}
3018
3019/// Matches L || R either in the form of L | R or L ? true : R.
3020/// Note that the latter form is poison-blocking.
3021template <typename LHS, typename RHS>
3023 const RHS &R) {
3025}
3026
3027/// Matches L || R where L and R are arbitrary values.
3028inline auto m_LogicalOr() { return m_LogicalOr(m_Value(), m_Value()); }
3029
3030/// Matches L || R with LHS and RHS in either order.
3031template <typename LHS, typename RHS>
3033m_c_LogicalOr(const LHS &L, const RHS &R) {
3035}
3036
3037/// Matches either L && R or L || R,
3038/// either one being in the either binary or logical form.
3039/// Note that the latter form is poison-blocking.
3040template <typename LHS, typename RHS, bool Commutable = false>
3041inline auto m_LogicalOp(const LHS &L, const RHS &R) {
3042 return m_CombineOr(
3045}
3046
3047/// Matches either L && R or L || R where L and R are arbitrary values.
3048inline auto m_LogicalOp() { return m_LogicalOp(m_Value(), m_Value()); }
3049
3050/// Matches either L && R or L || R with LHS and RHS in either order.
3051template <typename LHS, typename RHS>
3052inline auto m_c_LogicalOp(const LHS &L, const RHS &R) {
3053 return m_LogicalOp<LHS, RHS, /*Commutable=*/true>(L, R);
3054}
3055
3056} // end namespace PatternMatch
3057} // end namespace llvm
3058
3059#endif // LLVM_IR_PATTERNMATCH_H
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...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
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")
Hexagon Common GEP
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define T1
uint64_t IntrinsicInst * II
#define P(N)
const SmallVectorImpl< MachineOperand > & Cond
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * RHS
Value * LHS
Class for arbitrary precision integers.
Definition: APInt.h:77
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:530
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:61
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:757
@ ICMP_SLT
signed less than
Definition: InstrTypes.h:786
@ ICMP_SLE
signed less or equal
Definition: InstrTypes.h:787
@ FCMP_OLT
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:763
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:772
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:761
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:762
@ ICMP_UGE
unsigned greater or equal
Definition: InstrTypes.h:781
@ ICMP_UGT
unsigned greater than
Definition: InstrTypes.h:780
@ ICMP_SGT
signed greater than
Definition: InstrTypes.h:784
@ FCMP_ULT
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:771
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:782
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:769
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:764
@ ICMP_EQ
equal
Definition: InstrTypes.h:778
@ ICMP_SGE
signed greater or equal
Definition: InstrTypes.h:785
@ ICMP_ULE
unsigned less or equal
Definition: InstrTypes.h:783
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:770
Base class for aggregate constants (with operands).
Definition: Constants.h:400
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:1097
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:269
This is the shared class of boolean and integer constants.
Definition: Constants.h:81
This is an important base class in LLVM.
Definition: Constant.h:42
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:63
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
Definition: DataLayout.h:621
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:328
bool isShift() const
Definition: Instruction.h:281
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:367
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:502
bool empty() const
Definition: SmallVector.h:94
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:950
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:261
'undef' values are things that do not have specified contents.
Definition: Constants.h:1398
LLVM Value Representation.
Definition: Value.h:74
Base class of all SIMD vector types.
Definition: DerivedTypes.h:403
ElementCount getElementCount() const
Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...
Definition: DerivedTypes.h:641
Represents an op.with.overflow intrinsic.
An efficient, type-erasing, non-owning reference to a callable.
#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:524
class_match< PoisonValue > m_Poison()
Match an arbitrary poison constant.
Definition: PatternMatch.h:160
cst_pred_ty< is_lowbit_mask > m_LowBitMask()
Match an integer or vector with only the low bit(s) set.
Definition: PatternMatch.h:673
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
PtrAdd_match< PointerOpTy, OffsetOpTy > m_PtrAdd(const PointerOpTy &PointerOp, const OffsetOpTy &OffsetOp)
Matches GEP with i8 source element type.
apfloat_match m_APFloatForbidPoison(const APFloat *&Res)
Match APFloat while forbidding poison in splat vector constants.
Definition: PatternMatch.h:327
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
Definition: PatternMatch.h:550
BinaryOp_match< cst_pred_ty< is_all_ones, false >, ValTy, Instruction::Xor, true > m_NotForbidPoison(const ValTy &V)
MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > m_UnordFMin(const LHS &L, const RHS &R)
Match an 'unordered' floating point minimum function.
PtrToIntSameSize_match< OpTy > m_PtrToIntSameSize(const DataLayout &DL, const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
Definition: PatternMatch.h:100
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:664
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:726
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse(const Opnd0 &Op0)
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(const LHS &L, const RHS &R)
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
Definition: PatternMatch.h:619
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)
match_combine_or< CastInst_match< OpTy, TruncInst >, OpTy > m_TruncOrSelf(const OpTy &Op)
auto m_LogicalOp()
Matches either L && R or L || R where L and R are arbitrary values.
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
Definition: PatternMatch.h:165
AllowReassoc_match< T > m_AllowReassoc(const T &SubPattern)
Definition: PatternMatch.h:83
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:652
CastInst_match< OpTy, TruncInst > m_Trunc(const OpTy &Op)
Matches Trunc.
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
br_match m_UnconditionalBr(BasicBlock *&Succ)
SpecificCmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate, true > m_c_SpecificICmp(ICmpInst::Predicate MatchPred, const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
specific_intval< false > m_SpecificInt(const APInt &V)
Match a specific integer value or vector with all elements equal to the value.
Definition: PatternMatch.h:972
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul(const LHS &L, const RHS &R)
match_combine_or< CastInst_match< OpTy, ZExtInst >, OpTy > m_ZExtOrSelf(const OpTy &Op)
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
BinOpPred_match< LHS, RHS, is_idiv_op > m_IDiv(const LHS &L, const RHS &R)
Matches integer division operations.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMax(const Opnd0 &Op0, const Opnd1 &Op1)
cst_pred_ty< is_shifted_mask > m_ShiftedMask()
Definition: PatternMatch.h:515
bind_ty< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
Definition: PatternMatch.h:816
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
Definition: PatternMatch.h:764
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:875
DisjointOr_match< LHS, RHS > m_DisjointOr(const LHS &L, const RHS &R)
constantexpr_match m_ConstantExpr()
Match a constant expression or a constant that contains a constant expression.
Definition: PatternMatch.h:186
BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)
Matches logical shift operations.
specific_intval< true > m_SpecificIntAllowPoison(const APInt &V)
Definition: PatternMatch.h:980
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap, true > m_c_NUWAdd(const LHS &L, const RHS &R)
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:742
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
Definition: PatternMatch.h:560
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:168
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:592
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:782
match_combine_or< CastInst_match< OpTy, SExtInst >, OpTy > m_SExtOrSelf(const OpTy &Op)
InsertValue_match< Ind, Val_t, Elt_t > m_InsertValue(const Val_t &Val, const Elt_t &Elt)
Matches a single index InsertValue instruction.
specific_fpval m_SpecificFP(double V)
Match a specific floating point value or vector with all elements equal to the value.
Definition: PatternMatch.h:918
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_Interleave2(const Opnd0 &Op0, const Opnd1 &Op1)
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:245
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:507
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R)
CastInst_match< OpTy, FPToUIInst > m_FPToUI(const OpTy &Op)
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:822
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)
match_combine_or< typename m_Intrinsic_Ty< T0, T1 >::Ty, typename m_Intrinsic_Ty< T1, T0 >::Ty > m_c_Intrinsic(const T0 &Op0, const T1 &Op1)
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
deferredval_ty< Value > m_Deferred(Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match()...
Definition: PatternMatch.h:893
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
Definition: PatternMatch.h:599
apint_match m_APIntAllowPoison(const APInt *&Res)
Match APInt while allowing poison in splat vector constants.
Definition: PatternMatch.h:305
NoWrapTrunc_match< OpTy, TruncInst::NoSignedWrap > m_NSWTrunc(const OpTy &Op)
Matches trunc nsw.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
match_combine_or< match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > >, OpTy > m_ZExtOrSExtOrSelf(const OpTy &Op)
OneUse_match< T > m_OneUse(const T &SubPattern)
Definition: PatternMatch.h:67
NNegZExt_match< OpTy > m_NNegZExt(const OpTy &Op)
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > m_c_SMin(const LHS &L, const RHS &R)
Matches an SMin with LHS and RHS in either order.
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
Definition: PatternMatch.h:854
specific_bbval m_SpecificBB(BasicBlock *BB)
Match a specific basic block value.
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.
auto m_GEP(const OperandTypes &...Ops)
Matches GetElementPtrInst.
cst_pred_ty< is_strictlypositive > m_StrictlyPositive()
Match an integer or vector of strictly positive values.
Definition: PatternMatch.h:570
CastInst_match< OpTy, FPExtInst > m_FPExt(const OpTy &Op)
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:173
cstfp_pred_ty< is_nonnan > m_NonNaN()
Match a non-NaN FP constant.
Definition: PatternMatch.h:717
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2, Opnd3 >::Ty m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2, const Opnd3 &Op3)
Matches MaskedLoad Intrinsic.
OneOps_match< OpTy, Instruction::Load > m_Load(const OpTy &Op)
Matches LoadInst.
apint_match m_APIntForbidPoison(const APInt *&Res)
Match APInt while forbidding poison in splat vector constants.
Definition: PatternMatch.h:310
CastInst_match< OpTy, ZExtInst > m_ZExt(const OpTy &Op)
Matches ZExt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
cst_pred_ty< is_all_ones, false > m_AllOnesForbidPoison()
Definition: PatternMatch.h:528
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)
BinOpPred_match< LHS, RHS, is_bitwiselogic_op, true > m_c_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations in either order.
class_match< UndefValue > m_UndefValue()
Match an arbitrary UndefValue constant.
Definition: PatternMatch.h:155
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:105
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:627
cst_pred_ty< is_negated_power2_or_zero > m_NegatedPower2OrZero()
Match a integer or vector negated power-of-2.
Definition: PatternMatch.h:639
auto m_c_LogicalOp(const LHS &L, const RHS &R)
Matches either L && R or L || R with LHS and RHS in either order.
NoWrapTrunc_match< OpTy, TruncInst::NoUnsignedWrap > m_NUWTrunc(const OpTy &Op)
Matches trunc nuw.
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.
cst_pred_ty< custom_checkfn< APInt > > m_CheckedInt(function_ref< bool(const APInt &)> CheckFn)
Match an integer or vector where CheckFn(ele) for each element is true.
Definition: PatternMatch.h:481
cst_pred_ty< is_lowbit_mask_or_zero > m_LowBitMaskOrZero()
Match an integer or vector with only the low bit(s) set.
Definition: PatternMatch.h:683
specific_fpval m_FPOne()
Match a float 1.0 or vector with all elements equal to 1.0.
Definition: PatternMatch.h:921
DisjointOr_match< LHS, RHS, true > m_c_DisjointOr(const LHS &L, const RHS &R)
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.
apfloat_match m_APFloatAllowPoison(const APFloat *&Res)
Match APFloat while allowing poison in splat vector constants.
Definition: PatternMatch.h:322
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Add >, DisjointOr_match< LHS, RHS > > m_AddLike(const LHS &L, const RHS &R)
Match either "add" or "or disjoint".
SpecificCmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_SpecificICmp(ICmpInst::Predicate MatchPred, const LHS &L, const RHS &R)
CastInst_match< OpTy, UIToFPInst > m_UIToFP(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.
CastOperator_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > > > m_c_MaxOrMin(const LHS &L, const RHS &R)
MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > m_UnordFMax(const LHS &L, const RHS &R)
Match an 'unordered' floating point maximum function.
match_combine_or< CastInst_match< OpTy, SExtInst >, NNegZExt_match< OpTy > > m_SExtLike(const OpTy &Op)
Match either "sext" or "zext nneg".
cstfp_pred_ty< is_finitenonzero > m_FiniteNonZero()
Match a finite non-zero FP constant.
Definition: PatternMatch.h:752
class_match< UnaryOperator > m_UnOp()
Match an arbitrary unary operation and ignore it.
Definition: PatternMatch.h:95
VScaleVal_match m_VScale()
CastInst_match< OpTy, FPToSIInst > m_FPToSI(const OpTy &Op)
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
cstfp_pred_ty< custom_checkfn< APFloat > > m_CheckedFp(function_ref< bool(const APFloat &)> CheckFn)
Match a float or vector where CheckFn(ele) for each element is true.
Definition: PatternMatch.h:493
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:299
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:538
MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty > m_OrdFMax(const LHS &L, const RHS &R)
Match an 'ordered' floating point maximum function.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap >, DisjointOr_match< LHS, RHS > > m_NSWAddLike(const LHS &L, const RHS &R)
Match either "add nsw" or "or disjoint".
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:92
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)
CastInst_match< OpTy, SIToFPInst > m_SIToFP(const OpTy &Op)
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.
match_combine_or< CastInst_match< OpTy, ZExtInst >, CastInst_match< OpTy, SExtInst > > m_ZExtOrSExt(const OpTy &Op)
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:773
BinaryOp_match< LHS, RHS, Instruction::FAdd, true > m_c_FAdd(const LHS &L, const RHS &R)
Matches FAdd with LHS and RHS in either order.
LogicalOp_match< LHS, RHS, Instruction::And, true > m_c_LogicalAnd(const LHS &L, const RHS &R)
Matches L && R with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
cstfp_pred_ty< is_non_zero_fp > m_NonZeroFP()
Match a floating-point non-zero.
Definition: PatternMatch.h:791
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)
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:316
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)
SpecificCmpClass_match< LHS, RHS, CmpInst, CmpInst::Predicate > m_SpecificCmp(CmpInst::Predicate MatchPred, const LHS &L, const RHS &R)
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)
CastInst_match< OpTy, FPTruncInst > m_FPTrunc(const OpTy &Op)
class_match< BasicBlock > m_BasicBlock()
Match an arbitrary basic block value and ignore it.
Definition: PatternMatch.h:189
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:152
SpecificCmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > m_SpecificFCmp(FCmpInst::Predicate MatchPred, const LHS &L, const RHS &R)
cst_pred_ty< is_nonpositive > m_NonPositive()
Match an integer or vector of non-positive values.
Definition: PatternMatch.h:582
cstfp_pred_ty< is_nan > m_NaN()
Match an arbitrary NaN constant.
Definition: PatternMatch.h:710
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)
CastInst_match< OpTy, SExtInst > m_SExt(const OpTy &Op)
Matches SExt.
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
Definition: PatternMatch.h:612
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.
match_combine_or< OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap >, DisjointOr_match< LHS, RHS > > m_NUWAddLike(const LHS &L, const RHS &R)
Match either "add nuw" or "or disjoint".
CastOperator_match< OpTy, Instruction::IntToPtr > m_IntToPtr(const OpTy &Op)
Matches IntToPtr.
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
LogicalOp_match< LHS, RHS, Instruction::Or, true > m_c_LogicalOr(const LHS &L, const RHS &R)
Matches L || R with LHS and RHS in either order.
ThreeOps_match< Val_t, Elt_t, Idx_t, Instruction::InsertElement > m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx)
Matches InsertElementInst.
ElementWiseBitCast_match< OpTy > m_ElementWiseBitCast(const OpTy &Op)
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
BinaryOp_match< LHS, RHS, Instruction::Mul, true > m_c_Mul(const LHS &L, const RHS &R)
Matches a Mul with LHS and RHS in either order.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_CopySign(const Opnd0 &Op0, const Opnd1 &Op1)
CastOperator_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > m_NSWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
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:733
m_Intrinsic_Ty< Opnd >::Ty m_Deinterleave2(const Opnd &Op)
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:203
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
Definition: PatternMatch.h:239
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:698
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:1722
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
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:1749
AllowReassoc_match(const SubPattern_t &SP)
Definition: PatternMatch.h:74
AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
Matches instructions with Opcode and any number of operands.
std::enable_if_t< Idx==Last, bool > match_operands(const Instruction *I)
std::enable_if_t< Idx !=Last, bool > match_operands(const Instruction *I)
std::tuple< OperandTypes... > Operands
AnyOps_match(const OperandTypes &...Ops)
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)
bool match(unsigned Opc, OpTy *V)
CastInst_match(const Op_t &OpMatch)
CmpClass_match(const LHS_t &LHS, const RHS_t &RHS)
CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
DisjointOr_match(const LHS &L, const RHS &R)
Exact_match(const SubPattern_t &SP)
Matcher for a single index InsertValue instruction.
InsertValue_match(const T0 &Op0, const T1 &Op1)
IntrinsicID_match(Intrinsic::ID IntrID)
LogicalOp_match(const LHS &L, const RHS &R)
MaxMin_match(const LHS_t &LHS, const RHS_t &RHS)
NNegZExt_match(const Op_t &OpMatch)
NoWrapTrunc_match(const Op_t &OpMatch)
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)
PtrAdd_match(const PointerOpTy &PointerOp, const OffsetOpTy &OffsetOp)
PtrToIntSameSize_match(const DataLayout &DL, const Op_t &OpMatch)
Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
SpecificBinaryOp_match(unsigned Opcode, const LHS_t &LHS, const RHS_t &RHS)
SpecificCmpClass_match(PredicateTy Pred, const LHS_t &LHS, const RHS_t &RHS)
Matches instructions with Opcode and three operands.
ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
Matches instructions with Opcode and three operands.
TwoOps_match(const T0 &Op1, const T1 &Op2)
UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
Matches patterns for vscale.
This helper class is used to match scalar and vector constants that satisfy a specified predicate,...
Definition: PatternMatch.h:440
apf_pred_ty(const APFloat *&R)
Definition: PatternMatch.h:443
apfloat_match(const APFloat *&Res, bool AllowPoison)
Definition: PatternMatch.h:278
This helper class is used to match scalar and vector constants that satisfy a specified predicate,...
Definition: PatternMatch.h:413
apint_match(const APInt *&Res, bool AllowPoison)
Definition: PatternMatch.h:253
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:356
function_ref< bool(const APTy &)> CheckFn
Definition: PatternMatch.h:474
Stores a reference to the Value *, not the Value * itself, thus can be used in commutative matchers.
Definition: PatternMatch.h:879
bool isValue(const APInt &C)
Definition: PatternMatch.h:520
bool isValue(const APInt &C)
Definition: PatternMatch.h:503
bool isValue(const APFloat &C)
Definition: PatternMatch.h:760
bool isValue(const APFloat &C)
Definition: PatternMatch.h:738