28#ifndef LLVM_IR_PATTERNMATCH_H
29#define LLVM_IR_PATTERNMATCH_H
47namespace PatternMatch {
49template <
typename Val,
typename Pattern>
bool match(Val *V,
const Pattern &
P) {
62 template <
typename OpTy>
bool match(OpTy *V) {
72 template <
typename ITy>
bool match(ITy *V) {
return isa<Class>(V); }
93 if (isa<UndefValue>(V))
96 const auto *CA = dyn_cast<ConstantAggregate>(V);
107 for (
const Value *Op : CA->operand_values()) {
108 if (isa<UndefValue>(Op))
111 const auto *CA = dyn_cast<ConstantAggregate>(Op);
114 if (Seen.
insert(CA).second)
124 while (!Worklist.
empty()) {
130 template <
typename ITy>
bool match(ITy *V) {
return check(V); }
157 template <
typename ITy>
bool match(ITy *V) {
158 auto *
C = dyn_cast<Constant>(V);
159 return C && (isa<ConstantExpr>(
C) ||
C->containsConstantExpression());
178 template <
typename ITy>
bool match(ITy *V) {
return !
M.match(V); }
193 template <
typename ITy>
bool match(ITy *V) {
208 template <
typename ITy>
bool match(ITy *V) {
217template <
typename LTy,
typename RTy>
223template <
typename LTy,
typename RTy>
235 template <
typename ITy>
bool match(ITy *V) {
236 if (
auto *CI = dyn_cast<ConstantInt>(V)) {
237 Res = &CI->getValue();
240 if (V->getType()->isVectorTy())
241 if (
const auto *
C = dyn_cast<Constant>(V))
243 dyn_cast_or_null<ConstantInt>(
C->getSplatValue(
AllowUndef))) {
244 Res = &CI->getValue();
260 template <
typename ITy>
bool match(ITy *V) {
261 if (
auto *CI = dyn_cast<ConstantFP>(V)) {
262 Res = &CI->getValueAPF();
265 if (V->getType()->isVectorTy())
266 if (
const auto *
C = dyn_cast<Constant>(V))
268 dyn_cast_or_null<ConstantFP>(
C->getSplatValue(
AllowUndef))) {
269 Res = &CI->getValueAPF();
311 template <
typename ITy>
bool match(ITy *V) {
312 if (
const auto *CI = dyn_cast<ConstantInt>(V)) {
313 const APInt &CIV = CI->getValue();
315 return CIV ==
static_cast<uint64_t>(Val);
333template <
typename Predicate,
typename ConstantVal>
335 template <
typename ITy>
bool match(ITy *V) {
336 if (
const auto *CV = dyn_cast<ConstantVal>(V))
337 return this->isValue(CV->getValue());
338 if (
const auto *VTy = dyn_cast<VectorType>(V->getType())) {
339 if (
const auto *
C = dyn_cast<Constant>(V)) {
340 if (
const auto *CV = dyn_cast_or_null<ConstantVal>(
C->getSplatValue()))
341 return this->isValue(CV->getValue());
344 auto *FVTy = dyn_cast<FixedVectorType>(VTy);
349 unsigned NumElts = FVTy->getNumElements();
350 assert(NumElts != 0 &&
"Constant vector with no elements?");
351 bool HasNonUndefElements =
false;
352 for (
unsigned i = 0; i != NumElts; ++i) {
353 Constant *Elt =
C->getAggregateElement(i);
356 if (isa<UndefValue>(Elt))
358 auto *CV = dyn_cast<ConstantVal>(Elt);
359 if (!CV || !this->isValue(CV->getValue()))
361 HasNonUndefElements =
true;
363 return HasNonUndefElements;
371template <
typename Predicate>
375template <
typename Predicate>
380template <
typename Predicate>
struct api_pred_ty :
public Predicate {
385 template <
typename ITy>
bool match(ITy *V) {
386 if (
const auto *CI = dyn_cast<ConstantInt>(V))
387 if (this->isValue(CI->getValue())) {
388 Res = &CI->getValue();
391 if (V->getType()->isVectorTy())
392 if (
const auto *
C = dyn_cast<Constant>(V))
393 if (
auto *CI = dyn_cast_or_null<ConstantInt>(
C->getSplatValue()))
394 if (this->isValue(CI->getValue())) {
395 Res = &CI->getValue();
406template <
typename Predicate>
struct apf_pred_ty :
public Predicate {
411 template <
typename ITy>
bool match(ITy *V) {
412 if (
const auto *CI = dyn_cast<ConstantFP>(V))
413 if (this->isValue(CI->getValue())) {
414 Res = &CI->getValue();
417 if (V->getType()->isVectorTy())
418 if (
const auto *
C = dyn_cast<Constant>(V))
419 if (
auto *CI = dyn_cast_or_null<ConstantFP>(
420 C->getSplatValue(
true)))
421 if (this->isValue(CI->getValue())) {
422 Res = &CI->getValue();
529 template <
typename ITy>
bool match(ITy *V) {
530 auto *
C = dyn_cast<Constant>(V);
702 template <
typename ITy>
bool match(ITy *V) {
703 if (
auto *CV = dyn_cast<Class>(V)) {
768 template <
typename ITy>
bool match(ITy *V) {
return V ==
Val; }
781 template <
typename ITy>
bool match(ITy *
const V) {
return V ==
Val; }
802 template <
typename ITy>
bool match(ITy *V) {
803 if (
const auto *CFP = dyn_cast<ConstantFP>(V))
804 return CFP->isExactlyValue(
Val);
805 if (V->getType()->isVectorTy())
806 if (
const auto *
C = dyn_cast<Constant>(V))
807 if (
auto *CFP = dyn_cast_or_null<ConstantFP>(
C->getSplatValue()))
808 return CFP->isExactlyValue(
Val);
825 template <
typename ITy>
bool match(ITy *V) {
826 if (
const auto *CV = dyn_cast<ConstantInt>(V))
828 VR = CV->getZExtValue();
842 template <
typename ITy>
bool match(ITy *V) {
843 const auto *CI = dyn_cast<ConstantInt>(V);
844 if (!CI && V->getType()->isVectorTy())
845 if (
const auto *
C = dyn_cast<Constant>(V))
846 CI = dyn_cast_or_null<ConstantInt>(
C->getSplatValue(AllowUndefs));
880 template <
typename ITy>
bool match(ITy *V) {
881 const auto *BB = dyn_cast<BasicBlock>(V);
882 return BB && BB ==
Val;
903template <
typename LHS_t,
typename RHS_t,
bool Commutable = false>
912 template <
typename OpTy>
bool match(OpTy *V) {
913 if (
auto *
I = dyn_cast<BinaryOperator>(V))
914 return (
L.match(
I->getOperand(0)) &&
R.match(
I->getOperand(1))) ||
915 (Commutable &&
L.match(
I->getOperand(1)) &&
916 R.match(
I->getOperand(0)));
921template <
typename LHS,
typename RHS>
935 template <
typename OpTy>
bool match(OpTy *V) {
936 if (
auto *
I = dyn_cast<UnaryOperator>(V))
937 return X.match(
I->getOperand(0));
950template <
typename LHS_t,
typename RHS_t,
unsigned Opcode,
951 bool Commutable =
false>
960 template <
typename OpTy>
inline bool match(
unsigned Opc, OpTy *V) {
961 if (V->getValueID() == Value::InstructionVal + Opc) {
962 auto *
I = cast<BinaryOperator>(V);
963 return (
L.match(
I->getOperand(0)) &&
R.match(
I->getOperand(1))) ||
964 (Commutable &&
L.match(
I->getOperand(1)) &&
965 R.match(
I->getOperand(0)));
967 if (
auto *CE = dyn_cast<ConstantExpr>(V))
968 return CE->getOpcode() == Opc &&
969 ((
L.match(CE->getOperand(0)) &&
R.match(CE->getOperand(1))) ||
970 (Commutable &&
L.match(CE->getOperand(1)) &&
971 R.match(CE->getOperand(0))));
975 template <
typename OpTy>
bool match(OpTy *V) {
return match(Opcode, V); }
978template <
typename LHS,
typename RHS>
984template <
typename LHS,
typename RHS>
990template <
typename LHS,
typename RHS>
996template <
typename LHS,
typename RHS>
1006 template <
typename OpTy>
bool match(OpTy *V) {
1007 auto *FPMO = dyn_cast<FPMathOperator>(V);
1011 if (FPMO->getOpcode() == Instruction::FNeg)
1012 return X.match(FPMO->getOperand(0));
1014 if (FPMO->getOpcode() == Instruction::FSub) {
1015 if (FPMO->hasNoSignedZeros()) {
1025 return X.match(FPMO->getOperand(1));
1038template <
typename RHS>
1044template <
typename LHS,
typename RHS>
1050template <
typename LHS,
typename RHS>
1056template <
typename LHS,
typename RHS>
1062template <
typename LHS,
typename RHS>
1068template <
typename LHS,
typename RHS>
1074template <
typename LHS,
typename RHS>
1080template <
typename LHS,
typename RHS>
1086template <
typename LHS,
typename RHS>
1092template <
typename LHS,
typename RHS>
1098template <
typename LHS,
typename RHS>
1104template <
typename LHS,
typename RHS>
1110template <
typename LHS,
typename RHS>
1116template <
typename LHS,
typename RHS>
1122template <
typename LHS,
typename RHS>
1128template <
typename LHS_t,
typename RHS_t,
unsigned Opcode,
1129 unsigned WrapFlags = 0>
1137 template <
typename OpTy>
bool match(OpTy *V) {
1138 if (
auto *Op = dyn_cast<OverflowingBinaryOperator>(V)) {
1139 if (Op->getOpcode() != Opcode)
1142 !Op->hasNoUnsignedWrap())
1145 !Op->hasNoSignedWrap())
1147 return L.match(Op->getOperand(0)) &&
R.match(Op->getOperand(1));
1153template <
typename LHS,
typename RHS>
1161template <
typename LHS,
typename RHS>
1169template <
typename LHS,
typename RHS>
1177template <
typename LHS,
typename RHS>
1186template <
typename LHS,
typename RHS>
1194template <
typename LHS,
typename RHS>
1202template <
typename LHS,
typename RHS>
1210template <
typename LHS,
typename RHS>
1219template <
typename LHS_t,
typename RHS_t,
bool Commutable = false>
1227 template <
typename OpTy>
bool match(OpTy *V) {
1233template <
typename LHS,
typename RHS>
1242template <
typename LHS_t,
typename RHS_t,
typename Predicate>
1249 template <
typename OpTy>
bool match(OpTy *V) {
1250 if (
auto *
I = dyn_cast<Instruction>(V))
1251 return this->isOpType(
I->getOpcode()) &&
L.match(
I->getOperand(0)) &&
1252 R.match(
I->getOperand(1));
1253 if (
auto *CE = dyn_cast<ConstantExpr>(V))
1254 return this->isOpType(CE->getOpcode()) &&
L.match(CE->getOperand(0)) &&
1255 R.match(CE->getOperand(1));
1266 return Opcode == Instruction::LShr || Opcode == Instruction::AShr;
1272 return Opcode == Instruction::LShr || Opcode == Instruction::Shl;
1284 return Opcode == Instruction::SDiv || Opcode == Instruction::UDiv;
1290 return Opcode == Instruction::SRem || Opcode == Instruction::URem;
1295template <
typename LHS,
typename RHS>
1302template <
typename LHS,
typename RHS>
1309template <
typename LHS,
typename RHS>
1316template <
typename LHS,
typename RHS>
1323template <
typename LHS,
typename RHS>
1330template <
typename LHS,
typename RHS>
1344 template <
typename OpTy>
bool match(OpTy *V) {
1345 if (
auto *PEO = dyn_cast<PossiblyExactOperator>(V))
1346 return PEO->isExact() &&
SubPattern.match(V);
1359template <
typename LHS_t,
typename RHS_t,
typename Class,
typename PredicateTy,
1360 bool Commutable =
false>
1371 template <
typename OpTy>
bool match(OpTy *V) {
1372 if (
auto *
I = dyn_cast<Class>(V)) {
1373 if (
L.match(
I->getOperand(0)) &&
R.match(
I->getOperand(1))) {
1376 }
else if (Commutable &&
L.match(
I->getOperand(1)) &&
1377 R.match(
I->getOperand(0))) {
1386template <
typename LHS,
typename RHS>
1392template <
typename LHS,
typename RHS>
1398template <
typename LHS,
typename RHS>
1414 template <
typename OpTy>
bool match(OpTy *V) {
1415 if (V->getValueID() == Value::InstructionVal + Opcode) {
1416 auto *
I = cast<Instruction>(V);
1417 return Op1.match(
I->getOperand(0));
1430 template <
typename OpTy>
bool match(OpTy *V) {
1431 if (V->getValueID() == Value::InstructionVal + Opcode) {
1432 auto *
I = cast<Instruction>(V);
1433 return Op1.match(
I->getOperand(0)) &&
Op2.match(
I->getOperand(1));
1440template <
typename T0,
typename T1,
typename T2,
unsigned Opcode>
1449 template <
typename OpTy>
bool match(OpTy *V) {
1450 if (V->getValueID() == Value::InstructionVal + Opcode) {
1451 auto *
I = cast<Instruction>(V);
1452 return Op1.match(
I->getOperand(0)) &&
Op2.match(
I->getOperand(1)) &&
1453 Op3.match(
I->getOperand(2));
1460template <
typename Cond,
typename LHS,
typename RHS>
1468template <
int64_t L,
int64_t R,
typename Cond>
1470 Instruction::Select>
1472 return m_Select(
C, m_ConstantInt<L>(), m_ConstantInt<R>());
1476template <
typename OpTy>
1482template <
typename Val_t,
typename Elt_t,
typename Idx_t>
1490template <
typename Val_t,
typename Idx_t>
1505 template <
typename OpTy>
bool match(OpTy *V) {
1506 if (
auto *
I = dyn_cast<ShuffleVectorInst>(V)) {
1507 return Op1.match(
I->getOperand(0)) &&
Op2.match(
I->getOperand(1)) &&
1508 Mask.match(
I->getShuffleMask());
1525 return all_of(Mask, [](
int Elem) {
return Elem == 0 || Elem == -1; });
1539 const auto *First =
find_if(Mask, [](
int Elem) {
return Elem != -1; });
1540 if (First == Mask.end())
1544 [First](
int Elem) {
return Elem == *First || Elem == -1; });
1549template <
typename V1_t,
typename V2_t>
1555template <
typename V1_t,
typename V2_t,
typename Mask_t>
1557m_Shuffle(
const V1_t &v1,
const V2_t &v2,
const Mask_t &mask) {
1562template <
typename OpTy>
1568template <
typename ValueOpTy,
typename Po
interOpTy>
1570m_Store(
const ValueOpTy &ValueOp,
const PointerOpTy &PointerOp) {
1584 template <
typename OpTy>
bool match(OpTy *V) {
1585 if (
auto *O = dyn_cast<Operator>(V))
1586 return O->getOpcode() == Opcode &&
Op.match(O->getOperand(0));
1592template <
typename OpTy>
1598template <
typename OpTy>
1604template <
typename OpTy>
1610template <
typename OpTy>
1615template <
typename OpTy>
1622template <
typename OpTy>
1628template <
typename OpTy>
1633template <
typename OpTy>
1639template <
typename OpTy>
1645template <
typename OpTy>
1652template <
typename OpTy>
1661template <
typename OpTy>
1666template <
typename OpTy>
1671template <
typename OpTy>
1676template <
typename OpTy>
1681template <
typename OpTy>
1686template <
typename OpTy>
1700 template <
typename OpTy>
bool match(OpTy *V) {
1701 if (
auto *BI = dyn_cast<BranchInst>(V))
1702 if (BI->isUnconditional()) {
1703 Succ = BI->getSuccessor(0);
1712template <
typename Cond_t,
typename TrueBlock_t,
typename FalseBlock_t>
1718 brc_match(
const Cond_t &
C,
const TrueBlock_t &t,
const FalseBlock_t &f)
1721 template <
typename OpTy>
bool match(OpTy *V) {
1722 if (
auto *BI = dyn_cast<BranchInst>(V))
1723 if (BI->isConditional() &&
Cond.match(BI->getCondition()))
1724 return T.match(BI->getSuccessor(0)) &&
F.match(BI->getSuccessor(1));
1729template <
typename Cond_t>
1736template <
typename Cond_t,
typename TrueBlock_t,
typename FalseBlock_t>
1738m_Br(
const Cond_t &
C,
const TrueBlock_t &
T,
const FalseBlock_t &
F) {
1746template <
typename CmpInst_t,
typename LHS_t,
typename RHS_t,
typename Pred_t,
1747 bool Commutable =
false>
1757 template <
typename OpTy>
bool match(OpTy *V) {
1758 if (
auto *II = dyn_cast<IntrinsicInst>(V)) {
1764 Value *
LHS = II->getOperand(0), *
RHS = II->getOperand(1);
1765 return (
L.match(
LHS) &&
R.match(
RHS)) ||
1766 (Commutable &&
L.match(
RHS) &&
R.match(
LHS));
1770 auto *
SI = dyn_cast<SelectInst>(V);
1773 auto *Cmp = dyn_cast<CmpInst_t>(
SI->getCondition());
1778 auto *TrueVal =
SI->getTrueValue();
1779 auto *FalseVal =
SI->getFalseValue();
1780 auto *
LHS = Cmp->getOperand(0);
1781 auto *
RHS = Cmp->getOperand(1);
1782 if ((TrueVal !=
LHS || FalseVal !=
RHS) &&
1783 (TrueVal !=
RHS || FalseVal !=
LHS))
1785 typename CmpInst_t::Predicate Pred =
1786 LHS == TrueVal ? Cmp->getPredicate() : Cmp->getInversePredicate();
1788 if (!Pred_t::match(Pred))
1791 return (
L.match(
LHS) &&
R.match(
RHS)) ||
1792 (Commutable &&
L.match(
RHS) &&
R.match(
LHS));
1852template <
typename LHS,
typename RHS>
1858template <
typename LHS,
typename RHS>
1864template <
typename LHS,
typename RHS>
1870template <
typename LHS,
typename RHS>
1876template <
typename LHS,
typename RHS>
1896template <
typename LHS,
typename RHS>
1911template <
typename LHS,
typename RHS>
1926template <
typename LHS,
typename RHS>
1941template <
typename LHS,
typename RHS>
1952template <
typename LHS_t,
typename RHS_t,
typename Sum_t>
1961 template <
typename OpTy>
bool match(OpTy *V) {
1962 Value *ICmpLHS, *ICmpRHS;
1967 Value *AddLHS, *AddRHS;
1972 if (AddExpr.match(ICmpLHS) && (ICmpRHS == AddLHS || ICmpRHS == AddRHS))
1973 return L.match(AddLHS) &&
R.match(AddRHS) &&
S.match(ICmpLHS);
1977 if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
1978 return L.match(AddLHS) &&
R.match(AddRHS) &&
S.match(ICmpRHS);
1984 if (XorExpr.match(ICmpLHS))
1985 return L.match(Op1) &&
R.match(ICmpRHS) &&
S.match(ICmpLHS);
1989 if (XorExpr.match(ICmpRHS))
1990 return L.match(Op1) &&
R.match(ICmpLHS) &&
S.match(ICmpRHS);
1999 return L.match(AddLHS) &&
R.match(AddRHS) &&
S.match(ICmpLHS);
2004 return L.match(AddLHS) &&
R.match(AddRHS) &&
S.match(ICmpRHS);
2015template <
typename LHS_t,
typename RHS_t,
typename Sum_t>
2027 template <
typename OpTy>
bool match(OpTy *V) {
2029 if (
const auto *CI = dyn_cast<CallInst>(V))
2030 return Val.match(CI->getArgOperand(
OpI));
2036template <
unsigned OpI,
typename Opnd_t>
2047 template <
typename OpTy>
bool match(OpTy *V) {
2048 if (
const auto *CI = dyn_cast<CallInst>(V))
2049 if (
const auto *
F = CI->getCalledFunction())
2050 return F->getIntrinsicID() ==
ID;
2059template <
typename T0 = void,
typename T1 = void,
typename T2 = void,
2060 typename T3 = void,
typename T4 = void,
typename T5 = void,
2061 typename T6 = void,
typename T7 = void,
typename T8 = void,
2062 typename T9 = void,
typename T10 =
void>
2071template <
typename T0,
typename T1,
typename T2>
2076template <
typename T0,
typename T1,
typename T2,
typename T3>
2082template <
typename T0,
typename T1,
typename T2,
typename T3,
typename T4>
2088template <
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
2102template <
typename Opnd0,
typename Opnd1,
typename Opnd2,
typename Opnd3>
2106 return m_Intrinsic<Intrinsic::masked_load>(Op0, Op1, Op2, Op3);
2110template <
typename Opnd0,
typename Opnd1,
typename Opnd2,
typename Opnd3>
2114 return m_Intrinsic<Intrinsic::masked_gather>(Op0, Op1, Op2, Op3);
2117template <Intrinsic::ID IntrID,
typename T0>
2119 return m_CombineAnd(m_Intrinsic<IntrID>(), m_Argument<0>(Op0));
2122template <Intrinsic::ID IntrID,
typename T0,
typename T1>
2125 return m_CombineAnd(m_Intrinsic<IntrID>(Op0), m_Argument<1>(Op1));
2128template <Intrinsic::ID IntrID,
typename T0,
typename T1,
typename T2>
2131 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1), m_Argument<2>(Op2));
2138 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2), m_Argument<3>(Op3));
2142 typename T3,
typename T4>
2146 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3),
2147 m_Argument<4>(Op4));
2151 typename T3,
typename T4,
typename T5>
2154 const T4 &Op4,
const T5 &Op5) {
2155 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3, Op4),
2156 m_Argument<5>(Op5));
2160template <
typename Opnd0>
2162 return m_Intrinsic<Intrinsic::bitreverse>(Op0);
2165template <
typename Opnd0>
2167 return m_Intrinsic<Intrinsic::bswap>(Op0);
2170template <
typename Opnd0>
2172 return m_Intrinsic<Intrinsic::fabs>(Op0);
2175template <
typename Opnd0>
2177 return m_Intrinsic<Intrinsic::canonicalize>(Op0);
2180template <
typename Opnd0,
typename Opnd1>
2183 return m_Intrinsic<Intrinsic::minnum>(Op0, Op1);
2186template <
typename Opnd0,
typename Opnd1>
2189 return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
2192template <
typename Opnd0,
typename Opnd1,
typename Opnd2>
2194m_FShl(
const Opnd0 &Op0,
const Opnd1 &Op1,
const Opnd2 &Op2) {
2195 return m_Intrinsic<Intrinsic::fshl>(Op0, Op1, Op2);
2198template <
typename Opnd0,
typename Opnd1,
typename Opnd2>
2200m_FShr(
const Opnd0 &Op0,
const Opnd1 &Op1,
const Opnd2 &Op2) {
2201 return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
2204template <
typename Opnd0>
2206 return m_Intrinsic<Intrinsic::sqrt>(Op0);
2209template <
typename Opnd0,
typename Opnd1>
2212 return m_Intrinsic<Intrinsic::copysign>(Op0, Op1);
2215template <
typename Opnd0>
2217 return m_Intrinsic<Intrinsic::experimental_vector_reverse>(Op0);
2225template <
typename LHS,
typename RHS>
2232template <
typename LHS,
typename RHS>
2240template <
typename LHS,
typename RHS>
2247template <
typename LHS,
typename RHS>
2254template <
typename LHS,
typename RHS>
2261template <
typename LHS,
typename RHS>
2268template <
typename LHS,
typename RHS>
2275template <
typename LHS,
typename RHS>
2282template <
typename ValTy>
2289template <
typename ValTy>
2300template <
typename ValTy>
2310 template <
typename OpTy>
bool match(OpTy *V) {
2317 return Val.match(
X);
2319 return Val.match(
X);
2326template <
typename ValTy>
2332template <
typename LHS,
typename RHS>
2338template <
typename LHS,
typename RHS>
2344template <
typename LHS,
typename RHS>
2350template <
typename LHS,
typename RHS>
2356template <
typename LHS,
typename RHS>
2367template <Intrinsic::ID IntrID,
typename T0,
typename T1>
2372 m_Intrinsic<IntrID>(Op1, Op0));
2376template <
typename LHS,
typename RHS>
2383template <
typename LHS,
typename RHS>
2393 template <
typename OpTy>
bool match(OpTy *V) {
2394 unsigned TypeSize = V->getType()->getScalarSizeInBits();
2398 unsigned ShiftWidth =
TypeSize - 1;
2399 Value *OpL =
nullptr, *OpR =
nullptr;
2415 return Signum.match(V) && OpL == OpR &&
Val.match(OpL);
2433 template <
typename OpTy>
bool match(OpTy *V) {
2434 if (
auto *
I = dyn_cast<ExtractValueInst>(V)) {
2437 !(
I->getNumIndices() == 1 &&
I->getIndices()[0] == (
unsigned)Ind))
2439 return Val.match(
I->getAggregateOperand());
2447template <
int Ind,
typename Val_t>
2454template <
typename Val_t>
2466 template <
typename OpTy>
bool match(OpTy *V) {
2467 if (
auto *
I = dyn_cast<InsertValueInst>(V)) {
2468 return Op0.match(
I->getOperand(0)) &&
Op1.match(
I->getOperand(1)) &&
2469 I->getNumIndices() == 1 && Ind ==
I->getIndices()[0];
2476template <
int Ind,
typename Val_t,
typename Elt_t>
2487 template <
typename ITy>
bool match(ITy *V) {
2488 if (m_Intrinsic<Intrinsic::vscale>().
match(V))
2493 if (
auto *
GEP = dyn_cast<GEPOperator>(
Ptr)) {
2495 dyn_cast<ScalableVectorType>(
GEP->getSourceElementType());
2496 if (
GEP->getNumIndices() == 1 && DerefTy &&
2497 DerefTy->getElementType()->isIntegerTy(8) &&
2512template <
typename LHS,
typename RHS,
unsigned Opcode,
bool Commutable = false>
2520 auto *
I = dyn_cast<Instruction>(V);
2521 if (!
I || !
I->getType()->isIntOrIntVectorTy(1))
2524 if (
I->getOpcode() == Opcode) {
2525 auto *Op0 =
I->getOperand(0);
2526 auto *Op1 =
I->getOperand(1);
2527 return (
L.match(Op0) &&
R.match(Op1)) ||
2528 (Commutable &&
L.match(Op1) &&
R.match(Op0));
2531 if (
auto *
Select = dyn_cast<SelectInst>(
I)) {
2533 auto *TVal =
Select->getTrueValue();
2534 auto *FVal =
Select->getFalseValue();
2541 if (Opcode == Instruction::And) {
2542 auto *
C = dyn_cast<Constant>(FVal);
2543 if (
C &&
C->isNullValue())
2544 return (
L.match(
Cond) &&
R.match(TVal)) ||
2545 (Commutable &&
L.match(TVal) &&
R.match(
Cond));
2547 assert(Opcode == Instruction::Or);
2548 auto *
C = dyn_cast<Constant>(TVal);
2549 if (
C &&
C->isOneValue())
2550 return (
L.match(
Cond) &&
R.match(FVal)) ||
2551 (Commutable &&
L.match(FVal) &&
R.match(
Cond));
2561template <
typename LHS,
typename RHS>
2571template <
typename LHS,
typename RHS>
2579template <
typename LHS,
typename RHS>
2589template <
typename LHS,
typename RHS>
2598template <
typename LHS,
typename RHS,
bool Commutable = false>
2609template <
typename LHS,
typename RHS>
amdgpu AMDGPU Register Bank Select
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
SmallVector< MachineOperand, 4 > Cond
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Class for arbitrary precision integers.
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!...
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
@ ICMP_SLT
signed less than
@ ICMP_SLE
signed less or equal
@ FCMP_OLT
0 1 0 0 True if ordered and less than
@ FCMP_ULE
1 1 0 1 True if unordered, less than, or equal
@ FCMP_OGT
0 0 1 0 True if ordered and greater than
@ FCMP_OGE
0 0 1 1 True if ordered and greater than or equal
@ ICMP_UGE
unsigned greater or equal
@ ICMP_UGT
unsigned greater than
@ ICMP_SGT
signed greater than
@ FCMP_ULT
1 1 0 0 True if unordered or less than
@ ICMP_ULT
unsigned less than
@ FCMP_UGT
1 0 1 0 True if unordered or greater than
@ FCMP_OLE
0 1 0 1 True if ordered and less than or equal
@ ICMP_SGE
signed greater or equal
@ ICMP_ULE
unsigned less or equal
@ FCMP_UGE
1 0 1 1 True if unordered, greater than, or equal
Base class for aggregate constants (with operands).
A constant value that is initialized with an expression using other constant values.
ConstantFP - Floating Point Values [float, double].
This is the shared class of boolean and integer constants.
This is an important base class in LLVM.
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.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
reference emplace_back(ArgTypes &&... Args)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
LLVM Value Representation.
Represents an op.with.overflow intrinsic.
@ C
The default llvm calling convention, compatible with C.
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.
class_match< PoisonValue > m_Poison()
Match an arbitrary poison constant.
cst_pred_ty< is_lowbit_mask > m_LowBitMask()
Match an integer or vector with only the low bit(s) set.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
specific_intval< false > m_SpecificInt(APInt V)
Match a specific integer value or vector with all elements equal to the value.
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, OpTy > m_ZExtOrSelf(const OpTy &Op)
MaxMin_match< FCmpInst, LHS, RHS, ufmin_pred_ty > m_UnordFMin(const LHS &L, const RHS &R)
Match an 'unordered' floating point minimum function.
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
class_match< BinaryOperator > m_BinOp()
Match an arbitrary binary operation and ignore it.
apfloat_match m_APFloatAllowUndef(const APFloat *&Res)
Match APFloat while allowing undefs in splat vector constants.
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.
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.
m_Intrinsic_Ty< Opnd0 >::Ty m_BitReverse(const Opnd0 &Op0)
apint_match m_APIntAllowUndef(const APInt *&Res)
Match APInt while allowing undefs in splat vector constants.
CastClass_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(const LHS &L, const RHS &R)
cst_pred_ty< is_power2 > m_Power2()
Match an integer or vector power-of-2.
BinaryOp_match< cstfp_pred_ty< is_any_zero_fp >, RHS, Instruction::FSub > m_FNegNSZ(const RHS &X)
Match 'fneg X' as 'fsub +-0.0, X'.
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
auto m_LogicalOp()
Matches either L && R or L || R where L and R are arbitrary values.
CastClass_match< OpTy, Instruction::SExt > m_SExt(const OpTy &Op)
Matches SExt.
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
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.
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
br_match m_UnconditionalBr(BasicBlock *&Succ)
CastClass_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul(const LHS &L, const RHS &R)
bool match(Val *V, const Pattern &P)
BinOpPred_match< LHS, RHS, is_idiv_op > m_IDiv(const LHS &L, const RHS &R)
Matches integer division operations.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMax(const Opnd0 &Op0, const Opnd1 &Op1)
bind_ty< Instruction > m_Instruction(Instruction *&I)
Match an instruction, capturing it if we match.
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
constantexpr_match m_ConstantExpr()
Match a constant expression or a constant that contains a constant expression.
BinOpPred_match< LHS, RHS, is_right_shift_op > m_Shr(const LHS &L, const RHS &R)
Matches logical shift operations.
OverflowingBinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWNeg(const ValTy &V)
Matches a 'Neg' as 'sub nsw 0, V'.
TwoOps_match< Val_t, Idx_t, Instruction::ExtractElement > m_ExtractElt(const Val_t &Val, const Idx_t &Idx)
Matches ExtractElementInst.
cstfp_pred_ty< is_finite > m_Finite()
Match a finite FP constant, i.e.
cst_pred_ty< is_nonnegative > m_NonNegative()
Match an integer or vector of non-negative values.
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
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.
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.
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.
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.
CmpClass_match< LHS, RHS, FCmpInst, FCmpInst::Predicate > m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R)
m_Intrinsic_Ty< Opnd0 >::Ty m_Sqrt(const Opnd0 &Op0)
bind_ty< WithOverflowInst > m_WithOverflowInst(WithOverflowInst *&I)
Match a with overflow intrinsic, capturing it if we match.
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()...
cst_pred_ty< is_zero_int > m_ZeroInt()
Match an integer 0 or a vector with all elements equal to 0.
CastClass_match< OpTy, Instruction::FPTrunc > m_FPTrunc(const OpTy &Op)
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
OneUse_match< T > m_OneUse(const T &SubPattern)
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > m_c_SMin(const LHS &L, const RHS &R)
Matches an SMin with LHS and RHS in either order.
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
BinaryOp_match< cst_pred_ty< is_zero_int >, ValTy, Instruction::Sub > m_Neg(const ValTy &V)
Matches a 'Neg' as 'sub 0, V'.
TwoOps_match< V1_t, V2_t, Instruction::ShuffleVector > m_Shuffle(const V1_t &v1, const V2_t &v2)
Matches ShuffleVectorInst independently of mask value.
CastClass_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
match_combine_and< class_match< Constant >, match_unless< constantexpr_match > > m_ImmConstant()
Match an arbitrary immediate Constant and ignore it.
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.
CastClass_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
apint_match m_APIntForbidUndef(const APInt *&Res)
Match APInt while forbidding undefs in splat vector constants.
cst_pred_ty< is_strictlypositive > m_StrictlyPositive()
Match an integer or vector of strictly positive values.
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.
cstfp_pred_ty< is_nonnan > m_NonNaN()
Match a non-NaN FP constant.
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2, Opnd3 >::Ty m_MaskedLoad(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2, const Opnd3 &Op3)
Matches MaskedLoad Intrinsic.
match_combine_or< match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > >, OpTy > m_ZExtOrSExtOrSelf(const OpTy &Op)
OneOps_match< OpTy, Instruction::Load > m_Load(const OpTy &Op)
Matches LoadInst.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
match_combine_or< CastClass_match< OpTy, Instruction::Trunc >, OpTy > m_TruncOrSelf(const OpTy &Op)
CastClass_match< OpTy, Instruction::SIToFP > m_SIToFP(const OpTy &Op)
CastClass_match< OpTy, Instruction::IntToPtr > m_IntToPtr(const OpTy &Op)
Matches IntToPtr.
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
class_match< CmpInst > m_Cmp()
Matches any compare instruction and ignore it.
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.
auto m_c_LogicalOp(const LHS &L, const RHS &R)
Matches either L && R or L || R with LHS and RHS in either order.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate, true > m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
CastClass_match< OpTy, Instruction::FPToSI > m_FPToSI(const OpTy &Op)
specific_fpval m_FPOne()
Match a float 1.0 or vector with all elements equal to 1.0.
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > m_c_UMin(const LHS &L, const RHS &R)
Matches a UMin with LHS and RHS in either order.
BinaryOp_match< LHS, RHS, Instruction::Add, true > m_c_Add(const LHS &L, const RHS &R)
Matches a Add with LHS and RHS in either order.
match_combine_or< CastClass_match< OpTy, Instruction::ZExt >, CastClass_match< OpTy, Instruction::SExt > > m_ZExtOrSExt(const OpTy &Op)
CastClass_match< OpTy, Instruction::FPToUI > m_FPToUI(const OpTy &Op)
CastClass_match< OpTy, Instruction::FPExt > m_FPExt(const OpTy &Op)
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true > m_c_SMax(const LHS &L, const RHS &R)
Matches an SMax with LHS and RHS in either order.
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShl(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty, true > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty, true >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty, true > > > m_c_MaxOrMin(const LHS &L, const RHS &R)
MaxMin_match< FCmpInst, LHS, RHS, ufmax_pred_ty > m_UnordFMax(const LHS &L, const RHS &R)
Match an 'unordered' floating point maximum function.
cstfp_pred_ty< is_finitenonzero > m_FiniteNonZero()
Match a finite non-zero FP constant.
class_match< UnaryOperator > m_UnOp()
Match an arbitrary unary operation and ignore it.
VScaleVal_match m_VScale()
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
specific_intval< true > m_SpecificIntAllowUndef(APInt V)
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.
cst_pred_ty< is_maxsignedvalue > m_MaxSignedValue()
Match an integer or vector with values having all bits except for the high bit set (0x7f....
MaxMin_match< FCmpInst, LHS, RHS, ofmax_pred_ty > m_OrdFMax(const LHS &L, const RHS &R)
Match an 'ordered' floating point maximum function.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
AnyBinaryOp_match< LHS, RHS, true > m_c_BinOp(const LHS &L, const RHS &R)
Matches a BinaryOperator with LHS and RHS in either order.
Signum_match< Val_t > m_Signum(const Val_t &V)
Matches a signum pattern.
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
Argument_match< Opnd_t > m_Argument(const Opnd_t &Op)
Match an argument.
Exact_match< T > m_Exact(const T &SubPattern)
FNeg_match< OpTy > m_FNeg(const OpTy &X)
Match 'fneg X' as 'fsub -0.0, X'.
BinOpPred_match< LHS, RHS, is_shift_op > m_Shift(const LHS &L, const RHS &R)
Matches shift operations.
cstfp_pred_ty< is_pos_zero_fp > m_PosZeroFP()
Match a floating-point positive zero.
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.
UAddWithOverflow_match< LHS_t, RHS_t, Sum_t > m_UAddWithOverflow(const LHS_t &L, const RHS_t &R, const Sum_t &S)
Match an icmp instruction checking for unsigned overflow on addition.
BinaryOp_match< LHS, RHS, Instruction::FDiv > m_FDiv(const LHS &L, const RHS &R)
NotForbidUndef_match< ValTy > m_NotForbidUndef(const ValTy &V)
Matches a bitwise 'not' as 'xor V, -1' or 'xor -1, V'.
m_Intrinsic_Ty< Opnd0 >::Ty m_VecReverse(const Opnd0 &Op0)
BinOpPred_match< LHS, RHS, is_irem_op > m_IRem(const LHS &L, const RHS &R)
Matches integer remainder operations.
apfloat_match m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
apfloat_match m_APFloatForbidUndef(const APFloat *&Res)
Match APFloat while forbidding undefs in splat vector constants.
auto m_LogicalAnd()
Matches L && R where L and R are arbitrary values.
MaxMin_match< FCmpInst, LHS, RHS, ofmin_pred_ty > m_OrdFMin(const LHS &L, const RHS &R)
Match an 'ordered' floating point minimum function.
match_combine_or< match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > >, match_combine_or< MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty >, MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > > > m_MaxOrMin(const LHS &L, const RHS &R)
m_Intrinsic_Ty< Opnd0, Opnd1, Opnd2 >::Ty m_FShr(const Opnd0 &Op0, const Opnd1 &Op1, const Opnd2 &Op2)
ThreeOps_match< Cond, constantint_match< L >, constantint_match< R >, Instruction::Select > m_SelectCst(const Cond &C)
This matches a select of two constants, e.g.: m_SelectCst<-1, 0>(m_Value(V))
BinaryOp_match< LHS, RHS, Instruction::FRem > m_FRem(const LHS &L, const RHS &R)
class_match< BasicBlock > m_BasicBlock()
Match an arbitrary basic block value and ignore it.
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
auto m_Undef()
Match an arbitrary undef constant.
match_combine_or< CastClass_match< OpTy, Instruction::SExt >, OpTy > m_SExtOrSelf(const OpTy &Op)
cst_pred_ty< is_nonpositive > m_NonPositive()
Match an integer or vector of non-positive values.
cstfp_pred_ty< is_nan > m_NaN()
Match an arbitrary NaN constant.
CastClass_match< OpTy, Instruction::UIToFP > m_UIToFP(const OpTy &Op)
BinaryOp_match< cst_pred_ty< is_all_ones >, ValTy, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_FMin(const Opnd0 &Op0, const Opnd1 &Op1)
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
m_Intrinsic_Ty< Opnd0 >::Ty m_BSwap(const Opnd0 &Op0)
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
BinaryOp_match< LHS, RHS, Instruction::Or, true > m_c_Or(const LHS &L, const RHS &R)
Matches an Or with LHS and RHS in either order.
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
LogicalOp_match< LHS, RHS, Instruction::Or, true > m_c_LogicalOr(const LHS &L, const RHS &R)
Matches L || R with LHS and RHS in either order.
ThreeOps_match< Val_t, Elt_t, Idx_t, Instruction::InsertElement > m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx)
Matches InsertElementInst.
m_Intrinsic_Ty< Opnd0 >::Ty m_FAbs(const Opnd0 &Op0)
BinaryOp_match< LHS, RHS, Instruction::Mul, true > m_c_Mul(const LHS &L, const RHS &R)
Matches a Mul with LHS and RHS in either order.
m_Intrinsic_Ty< Opnd0, Opnd1 >::Ty m_CopySign(const Opnd0 &Op0, const Opnd1 &Op1)
OverflowingBinaryOp_match< LHS, RHS, Instruction::Mul, OverflowingBinaryOperator::NoSignedWrap > m_NSWMul(const LHS &L, const RHS &R)
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
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.
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.
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
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.
This is an optimization pass for GlobalISel generic memory operations.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
AnyBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
AnyUnaryOp_match(const OP_t &X)
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)
CastClass_match(const Op_t &OpMatch)
CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
Exact_match(const SubPattern_t &SP)
FNeg_match(const Op_t &Op)
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)
NotForbidUndef_match(const ValTy &V)
Matches instructions with Opcode and three operands.
OneOps_match(const T0 &Op1)
OneUse_match(const SubPattern_t &SP)
OverflowingBinaryOp_match(const LHS_t &LHS, const RHS_t &RHS)
Shuffle_match(const T0 &Op1, const T1 &Op2, const T2 &Mask)
Signum_match(const Opnd_t &V)
SpecificBinaryOp_match(unsigned Opcode, const LHS_t &LHS, const RHS_t &RHS)
Matches instructions with Opcode and three operands.
ThreeOps_match(const T0 &Op1, const T1 &Op2, const T2 &Op3)
Matches instructions with Opcode and three operands.
TwoOps_match(const T0 &Op1, const T1 &Op2)
UAddWithOverflow_match(const LHS_t &L, const RHS_t &R, const Sum_t &S)
Matches patterns for vscale.
This helper class is used to match scalar and vector constants that satisfy a specified predicate,...
apf_pred_ty(const APFloat *&R)
apfloat_match(const APFloat *&Res, bool AllowUndef)
This helper class is used to match scalar and vector constants that satisfy a specified predicate,...
api_pred_ty(const APInt *&R)
apint_match(const APInt *&Res, bool AllowUndef)
bind_const_intval_ty(uint64_t &V)
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...
Stores a reference to the Value *, not the Value * itself, thus can be used in commutative matchers.
deferredval_ty(Class *const &V)
bool isValue(const APInt &C)
bool isValue(const APInt &C)
bool isValue(const APInt &C)
bool isValue(const APFloat &C)
bool isOpType(unsigned Opcode)
bool isValue(const APFloat &C)
bool isValue(const APFloat &C)
bool isOpType(unsigned Opcode)
bool isValue(const APFloat &C)
bool isOpType(unsigned Opcode)
bool isOpType(unsigned Opcode)
bool isValue(const APInt &C)
bool isValue(const APInt &C)
bool isValue(const APFloat &C)
bool isValue(const APFloat &C)
bool isValue(const APInt &C)
bool isValue(const APInt &C)
bool isValue(const APFloat &C)
bool isValue(const APFloat &C)
bool isValue(const APFloat &C)
bool isValue(const APInt &C)
bool isValue(const APInt &C)
bool isValue(const APInt &C)
bool isValue(const APFloat &C)
bool isValue(const APInt &C)
bool isValue(const APInt &C)
bool isOpType(unsigned Opcode)
bool isOpType(unsigned Opcode)
bool isValue(const APInt &C)
bool isValue(const APInt &C)
bool isValue(const APInt &C)
Intrinsic matches are combinations of ID matchers, and argument matchers.
bool match(ArrayRef< int > Mask)
ArrayRef< int > & MaskRef
m_Mask(ArrayRef< int > &MaskRef)
ArrayRef< int > & MaskRef
bool match(ArrayRef< int > Mask)
m_SpecificMask(ArrayRef< int > &MaskRef)
m_SplatOrUndefMask(int &SplatIndex)
bool match(ArrayRef< int > Mask)
bool match(ArrayRef< int > Mask)
match_combine_and(const LTy &Left, const RTy &Right)
match_combine_or(const LTy &Left, const RTy &Right)
match_unless(const Ty &Matcher)
Helper class for identifying ordered max predicates.
static bool match(FCmpInst::Predicate Pred)
Helper class for identifying ordered min predicates.
static bool match(FCmpInst::Predicate Pred)
Helper class for identifying signed max predicates.
static bool match(ICmpInst::Predicate Pred)
Helper class for identifying signed min predicates.
static bool match(ICmpInst::Predicate Pred)
Match a specified basic block value.
specific_bbval(BasicBlock *Val)
Match a specified floating point value or vector of all elements of that value.
Match a specified integer value or vector of all elements of that value.
Match a specified Value*.
specificval_ty(const Value *V)
Helper class for identifying unordered max predicates.
static bool match(FCmpInst::Predicate Pred)
Helper class for identifying unordered min predicates.
static bool match(FCmpInst::Predicate Pred)
Helper class for identifying unsigned max predicates.
static bool match(ICmpInst::Predicate Pred)
Helper class for identifying unsigned min predicates.
static bool match(ICmpInst::Predicate Pred)
static bool check(const Value *V)