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) {
76 template <
typename OpTy>
bool match(OpTy *V) {
77 auto *
I = dyn_cast<FPMathOperator>(V);
88 template <
typename ITy>
bool match(ITy *V) {
return isa<Class>(V); }
109 if (isa<UndefValue>(V))
112 const auto *CA = dyn_cast<ConstantAggregate>(V);
123 for (
const Value *
Op : CA->operand_values()) {
124 if (isa<UndefValue>(
Op))
127 const auto *CA = dyn_cast<ConstantAggregate>(
Op);
130 if (Seen.
insert(CA).second)
140 while (!Worklist.
empty()) {
146 template <
typename ITy>
bool match(ITy *V) {
return check(V); }
173 template <
typename ITy>
bool match(ITy *V) {
174 auto *
C = dyn_cast<Constant>(V);
175 return C && (isa<ConstantExpr>(
C) ||
C->containsConstantExpression());
194 template <
typename ITy>
bool match(ITy *V) {
return !
M.match(V); }
209 template <
typename ITy>
bool match(ITy *V) {
224 template <
typename ITy>
bool match(ITy *V) {
233template <
typename LTy,
typename RTy>
239template <
typename LTy,
typename RTy>
251 template <
typename ITy>
bool match(ITy *V) {
252 if (
auto *CI = dyn_cast<ConstantInt>(V)) {
253 Res = &CI->getValue();
256 if (V->getType()->isVectorTy())
257 if (
const auto *
C = dyn_cast<Constant>(V))
259 dyn_cast_or_null<ConstantInt>(
C->getSplatValue(
AllowUndef))) {
260 Res = &CI->getValue();
276 template <
typename ITy>
bool match(ITy *V) {
277 if (
auto *CI = dyn_cast<ConstantFP>(V)) {
278 Res = &CI->getValueAPF();
281 if (V->getType()->isVectorTy())
282 if (
const auto *
C = dyn_cast<Constant>(V))
284 dyn_cast_or_null<ConstantFP>(
C->getSplatValue(
AllowUndef))) {
285 Res = &CI->getValueAPF();
327 template <
typename ITy>
bool match(ITy *V) {
328 if (
const auto *CI = dyn_cast<ConstantInt>(V)) {
329 const APInt &CIV = CI->getValue();
331 return CIV ==
static_cast<uint64_t>(Val);
349template <
typename Predicate,
typename ConstantVal>
351 template <
typename ITy>
bool match(ITy *V) {
352 if (
const auto *CV = dyn_cast<ConstantVal>(V))
353 return this->isValue(CV->getValue());
354 if (
const auto *VTy = dyn_cast<VectorType>(V->getType())) {
355 if (
const auto *
C = dyn_cast<Constant>(V)) {
356 if (
const auto *CV = dyn_cast_or_null<ConstantVal>(
C->getSplatValue()))
357 return this->isValue(CV->getValue());
360 auto *FVTy = dyn_cast<FixedVectorType>(VTy);
365 unsigned NumElts = FVTy->getNumElements();
366 assert(NumElts != 0 &&
"Constant vector with no elements?");
367 bool HasNonUndefElements =
false;
368 for (
unsigned i = 0; i != NumElts; ++i) {
369 Constant *Elt =
C->getAggregateElement(i);
372 if (isa<UndefValue>(Elt))
374 auto *CV = dyn_cast<ConstantVal>(Elt);
375 if (!CV || !this->isValue(CV->getValue()))
377 HasNonUndefElements =
true;
379 return HasNonUndefElements;
387template <
typename Predicate>
391template <
typename Predicate>
396template <
typename Predicate>
struct api_pred_ty :
public Predicate {
401 template <
typename ITy>
bool match(ITy *V) {
402 if (
const auto *CI = dyn_cast<ConstantInt>(V))
403 if (this->isValue(CI->getValue())) {
404 Res = &CI->getValue();
407 if (V->getType()->isVectorTy())
408 if (
const auto *
C = dyn_cast<Constant>(V))
409 if (
auto *CI = dyn_cast_or_null<ConstantInt>(
C->getSplatValue()))
410 if (this->isValue(CI->getValue())) {
411 Res = &CI->getValue();
422template <
typename Predicate>
struct apf_pred_ty :
public Predicate {
427 template <
typename ITy>
bool match(ITy *V) {
428 if (
const auto *CI = dyn_cast<ConstantFP>(V))
429 if (this->isValue(CI->getValue())) {
430 Res = &CI->getValue();
433 if (V->getType()->isVectorTy())
434 if (
const auto *
C = dyn_cast<Constant>(V))
435 if (
auto *CI = dyn_cast_or_null<ConstantFP>(
436 C->getSplatValue(
true)))
437 if (this->isValue(CI->getValue())) {
438 Res = &CI->getValue();
553 template <
typename ITy>
bool match(ITy *V) {
554 auto *
C = dyn_cast<Constant>(V);
751 template <
typename ITy>
bool match(ITy *V) {
752 if (
auto *CV = dyn_cast<Class>(V)) {
817 template <
typename ITy>
bool match(ITy *V) {
return V ==
Val; }
830 template <
typename ITy>
bool match(ITy *
const V) {
return V ==
Val; }
851 template <
typename ITy>
bool match(ITy *V) {
852 if (
const auto *CFP = dyn_cast<ConstantFP>(V))
853 return CFP->isExactlyValue(
Val);
854 if (V->getType()->isVectorTy())
855 if (
const auto *
C = dyn_cast<Constant>(V))
856 if (
auto *CFP = dyn_cast_or_null<ConstantFP>(
C->getSplatValue()))
857 return CFP->isExactlyValue(
Val);
874 template <
typename ITy>
bool match(ITy *V) {
875 if (
const auto *CV = dyn_cast<ConstantInt>(V))
877 VR = CV->getZExtValue();
891 template <
typename ITy>
bool match(ITy *V) {
892 const auto *CI = dyn_cast<ConstantInt>(V);
893 if (!CI && V->getType()->isVectorTy())
894 if (
const auto *
C = dyn_cast<Constant>(V))
895 CI = dyn_cast_or_null<ConstantInt>(
C->getSplatValue(AllowUndefs));
929 template <
typename ITy>
bool match(ITy *V) {
930 const auto *BB = dyn_cast<BasicBlock>(V);
931 return BB && BB ==
Val;
952template <
typename LHS_t,
typename RHS_t,
bool Commutable = false>
961 template <
typename OpTy>
bool match(OpTy *V) {
962 if (
auto *
I = dyn_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)));
970template <
typename LHS,
typename RHS>
984 template <
typename OpTy>
bool match(OpTy *V) {
985 if (
auto *
I = dyn_cast<UnaryOperator>(V))
986 return X.match(
I->getOperand(0));
999template <
typename LHS_t,
typename RHS_t,
unsigned Opcode,
1000 bool Commutable =
false>
1009 template <
typename OpTy>
inline bool match(
unsigned Opc, OpTy *V) {
1010 if (V->getValueID() == Value::InstructionVal + Opc) {
1011 auto *
I = cast<BinaryOperator>(V);
1012 return (
L.match(
I->getOperand(0)) &&
R.match(
I->getOperand(1))) ||
1013 (Commutable &&
L.match(
I->getOperand(1)) &&
1014 R.match(
I->getOperand(0)));
1019 template <
typename OpTy>
bool match(OpTy *V) {
return match(Opcode, V); }
1022template <
typename LHS,
typename RHS>
1028template <
typename LHS,
typename RHS>
1034template <
typename LHS,
typename RHS>
1040template <
typename LHS,
typename RHS>
1050 template <
typename OpTy>
bool match(OpTy *V) {
1051 auto *FPMO = dyn_cast<FPMathOperator>(V);
1055 if (FPMO->getOpcode() == Instruction::FNeg)
1056 return X.match(FPMO->getOperand(0));
1058 if (FPMO->getOpcode() == Instruction::FSub) {
1059 if (FPMO->hasNoSignedZeros()) {
1069 return X.match(FPMO->getOperand(1));
1082template <
typename RHS>
1088template <
typename LHS,
typename RHS>
1094template <
typename LHS,
typename RHS>
1100template <
typename LHS,
typename RHS>
1106template <
typename LHS,
typename RHS>
1112template <
typename LHS,
typename RHS>
1118template <
typename LHS,
typename RHS>
1124template <
typename LHS,
typename RHS>
1130template <
typename LHS,
typename RHS>
1136template <
typename LHS,
typename RHS>
1142template <
typename LHS,
typename RHS>
1148template <
typename LHS,
typename RHS>
1154template <
typename LHS,
typename RHS>
1160template <
typename LHS,
typename RHS>
1166template <
typename LHS,
typename RHS>
1172template <
typename LHS_t,
typename RHS_t,
unsigned Opcode,
1173 unsigned WrapFlags = 0>
1181 template <
typename OpTy>
bool match(OpTy *V) {
1182 if (
auto *
Op = dyn_cast<OverflowingBinaryOperator>(V)) {
1183 if (
Op->getOpcode() != Opcode)
1186 !
Op->hasNoUnsignedWrap())
1189 !
Op->hasNoSignedWrap())
1191 return L.match(
Op->getOperand(0)) &&
R.match(
Op->getOperand(1));
1197template <
typename LHS,
typename RHS>
1205template <
typename LHS,
typename RHS>
1213template <
typename LHS,
typename RHS>
1221template <
typename LHS,
typename RHS>
1230template <
typename LHS,
typename RHS>
1238template <
typename LHS,
typename RHS>
1246template <
typename LHS,
typename RHS>
1254template <
typename LHS,
typename RHS>
1263template <
typename LHS_t,
typename RHS_t,
bool Commutable = false>
1271 template <
typename OpTy>
bool match(OpTy *V) {
1277template <
typename LHS,
typename RHS>
1283template <
typename LHS,
typename RHS,
bool Commutable = false>
1290 template <
typename OpTy>
bool match(OpTy *V) {
1291 if (
auto *PDI = dyn_cast<PossiblyDisjointInst>(V)) {
1292 assert(PDI->getOpcode() == Instruction::Or &&
"Only or can be disjoint");
1293 if (!PDI->isDisjoint())
1295 return (
L.match(PDI->getOperand(0)) &&
R.match(PDI->getOperand(1))) ||
1296 (Commutable &&
L.match(PDI->getOperand(1)) &&
1297 R.match(PDI->getOperand(0)));
1303template <
typename LHS,
typename RHS>
1308template <
typename LHS,
typename RHS>
1315template <
typename LHS,
typename RHS>
1325template <
typename LHS_t,
typename RHS_t,
typename Predicate>
1332 template <
typename OpTy>
bool match(OpTy *V) {
1333 if (
auto *
I = dyn_cast<Instruction>(V))
1334 return this->isOpType(
I->getOpcode()) &&
L.match(
I->getOperand(0)) &&
1335 R.match(
I->getOperand(1));
1346 return Opcode == Instruction::LShr || Opcode == Instruction::AShr;
1352 return Opcode == Instruction::LShr || Opcode == Instruction::Shl;
1364 return Opcode == Instruction::SDiv || Opcode == Instruction::UDiv;
1370 return Opcode == Instruction::SRem || Opcode == Instruction::URem;
1375template <
typename LHS,
typename RHS>
1382template <
typename LHS,
typename RHS>
1389template <
typename LHS,
typename RHS>
1396template <
typename LHS,
typename RHS>
1403template <
typename LHS,
typename RHS>
1410template <
typename LHS,
typename RHS>
1424 template <
typename OpTy>
bool match(OpTy *V) {
1425 if (
auto *PEO = dyn_cast<PossiblyExactOperator>(V))
1426 return PEO->isExact() &&
SubPattern.match(V);
1439template <
typename LHS_t,
typename RHS_t,
typename Class,
typename PredicateTy,
1440 bool Commutable =
false>
1451 template <
typename OpTy>
bool match(OpTy *V) {
1452 if (
auto *
I = dyn_cast<Class>(V)) {
1453 if (
L.match(
I->getOperand(0)) &&
R.match(
I->getOperand(1))) {
1456 }
else if (Commutable &&
L.match(
I->getOperand(1)) &&
1457 R.match(
I->getOperand(0))) {
1466template <
typename LHS,
typename RHS>
1472template <
typename LHS,
typename RHS>
1478template <
typename LHS,
typename RHS>
1494 template <
typename OpTy>
bool match(OpTy *V) {
1495 if (V->getValueID() == Value::InstructionVal + Opcode) {
1496 auto *
I = cast<Instruction>(V);
1497 return Op1.match(
I->getOperand(0));
1510 template <
typename OpTy>
bool match(OpTy *V) {
1511 if (V->getValueID() == Value::InstructionVal + Opcode) {
1512 auto *
I = cast<Instruction>(V);
1513 return Op1.match(
I->getOperand(0)) &&
Op2.match(
I->getOperand(1));
1520template <
typename T0,
typename T1,
typename T2,
unsigned Opcode>
1529 template <
typename OpTy>
bool match(OpTy *V) {
1530 if (V->getValueID() == Value::InstructionVal + Opcode) {
1531 auto *
I = cast<Instruction>(V);
1532 return Op1.match(
I->getOperand(0)) &&
Op2.match(
I->getOperand(1)) &&
1533 Op3.match(
I->getOperand(2));
1549 template <
int Idx,
int Last>
1551 return match_operands<Idx, Idx>(
I) && match_operands<Idx + 1, Last>(
I);
1554 template <
int Idx,
int Last>
1556 return std::get<Idx>(
Operands).match(
I->getOperand(
Idx));
1559 template <
typename OpTy>
bool match(OpTy *V) {
1560 if (V->getValueID() == Value::InstructionVal + Opcode) {
1561 auto *
I = cast<Instruction>(V);
1562 return I->getNumOperands() ==
sizeof...(OperandTypes) &&
1570template <
typename Cond,
typename LHS,
typename RHS>
1578template <
int64_t L,
int64_t R,
typename Cond>
1580 Instruction::Select>
1582 return m_Select(
C, m_ConstantInt<L>(), m_ConstantInt<R>());
1586template <
typename OpTy>
1592template <
typename Val_t,
typename Elt_t,
typename Idx_t>
1600template <
typename Val_t,
typename Idx_t>
1615 template <
typename OpTy>
bool match(OpTy *V) {
1616 if (
auto *
I = dyn_cast<ShuffleVectorInst>(V)) {
1617 return Op1.match(
I->getOperand(0)) &&
Op2.match(
I->getOperand(1)) &&
1618 Mask.match(
I->getShuffleMask());
1635 return all_of(Mask, [](
int Elem) {
return Elem == 0 || Elem == -1; });
1649 const auto *
First =
find_if(Mask, [](
int Elem) {
return Elem != -1; });
1650 if (
First == Mask.end())
1654 [
First](
int Elem) {
return Elem == *
First || Elem == -1; });
1665 template <
typename OpTy>
bool match(OpTy *V) {
1666 auto *
GEP = dyn_cast<GEPOperator>(V);
1667 return GEP &&
GEP->getSourceElementType()->isIntegerTy(8) &&
1674template <
typename V1_t,
typename V2_t>
1680template <
typename V1_t,
typename V2_t,
typename Mask_t>
1682m_Shuffle(
const V1_t &v1,
const V2_t &v2,
const Mask_t &mask) {
1687template <
typename OpTy>
1693template <
typename ValueOpTy,
typename Po
interOpTy>
1695m_Store(
const ValueOpTy &ValueOp,
const PointerOpTy &PointerOp) {
1701template <
typename... OperandTypes>
1702inline auto m_GEP(
const OperandTypes &...Ops) {
1703 return AnyOps_match<Instruction::GetElementPtr, OperandTypes...>(Ops...);
1707template <
typename Po
interOpTy,
typename OffsetOpTy>
1709m_PtrAdd(
const PointerOpTy &PointerOp,
const OffsetOpTy &OffsetOp) {
1722 template <
typename OpTy>
bool match(OpTy *V) {
1723 if (
auto *O = dyn_cast<Operator>(V))
1724 return O->getOpcode() == Opcode &&
Op.match(O->getOperand(0));
1734 template <
typename OpTy>
bool match(OpTy *V) {
1735 if (
auto *
I = dyn_cast<Class>(V))
1736 return Op.match(
I->getOperand(0));
1748 template <
typename OpTy>
bool match(OpTy *V) {
1749 if (
auto *O = dyn_cast<Operator>(V))
1750 return O->getOpcode() == Instruction::PtrToInt &&
1753 Op.match(O->getOperand(0));
1763 template <
typename OpTy>
bool match(OpTy *V) {
1764 if (
auto *
I = dyn_cast<ZExtInst>(V))
1765 return I->hasNonNeg() &&
Op.match(
I->getOperand(0));
1771template <
typename OpTy>
1782 template <
typename OpTy>
bool match(OpTy *V) {
1786 Type *SrcType =
I->getSrcTy();
1787 Type *DstType =
I->getType();
1792 if (
VectorType *SrcVecTy = dyn_cast<VectorType>(SrcType);
1794 cast<VectorType>(DstType)->getElementCount())
1796 return Op.match(
I->getOperand(0));
1800template <
typename OpTy>
1806template <
typename OpTy>
1812template <
typename OpTy>
1819template <
typename OpTy>
1826template <
typename OpTy>
1831template <
typename OpTy>
1838template <
typename OpTy>
1844template <
typename OpTy>
1849template <
typename OpTy>
1854template <
typename OpTy>
1860template <
typename OpTy>
1867template <
typename OpTy>
1873template <
typename OpTy>
1880template <
typename OpTy>
1888template <
typename OpTy>
1893template <
typename OpTy>
1898template <
typename OpTy>
1903template <
typename OpTy>
1908template <
typename OpTy>
1913template <
typename OpTy>
1927 template <
typename OpTy>
bool match(OpTy *V) {
1928 if (
auto *BI = dyn_cast<BranchInst>(V))
1929 if (BI->isUnconditional()) {
1930 Succ = BI->getSuccessor(0);
1939template <
typename Cond_t,
typename TrueBlock_t,
typename FalseBlock_t>
1945 brc_match(
const Cond_t &
C,
const TrueBlock_t &t,
const FalseBlock_t &f)
1948 template <
typename OpTy>
bool match(OpTy *V) {
1949 if (
auto *BI = dyn_cast<BranchInst>(V))
1950 if (BI->isConditional() &&
Cond.match(BI->getCondition()))
1951 return T.match(BI->getSuccessor(0)) &&
F.match(BI->getSuccessor(1));
1956template <
typename Cond_t>
1963template <
typename Cond_t,
typename TrueBlock_t,
typename FalseBlock_t>
1965m_Br(
const Cond_t &
C,
const TrueBlock_t &
T,
const FalseBlock_t &
F) {
1973template <
typename CmpInst_t,
typename LHS_t,
typename RHS_t,
typename Pred_t,
1974 bool Commutable =
false>
1984 template <
typename OpTy>
bool match(OpTy *V) {
1985 if (
auto *II = dyn_cast<IntrinsicInst>(V)) {
1991 Value *
LHS = II->getOperand(0), *
RHS = II->getOperand(1);
1992 return (
L.match(
LHS) &&
R.match(
RHS)) ||
1993 (Commutable &&
L.match(
RHS) &&
R.match(
LHS));
1997 auto *SI = dyn_cast<SelectInst>(V);
2000 auto *Cmp = dyn_cast<CmpInst_t>(SI->getCondition());
2005 auto *TrueVal = SI->getTrueValue();
2006 auto *FalseVal = SI->getFalseValue();
2007 auto *
LHS = Cmp->getOperand(0);
2008 auto *
RHS = Cmp->getOperand(1);
2009 if ((TrueVal !=
LHS || FalseVal !=
RHS) &&
2010 (TrueVal !=
RHS || FalseVal !=
LHS))
2012 typename CmpInst_t::Predicate Pred =
2013 LHS == TrueVal ? Cmp->getPredicate() : Cmp->getInversePredicate();
2015 if (!Pred_t::match(Pred))
2018 return (
L.match(
LHS) &&
R.match(
RHS)) ||
2019 (Commutable &&
L.match(
RHS) &&
R.match(
LHS));
2079template <
typename LHS,
typename RHS>
2085template <
typename LHS,
typename RHS>
2091template <
typename LHS,
typename RHS>
2097template <
typename LHS,
typename RHS>
2103template <
typename LHS,
typename RHS>
2123template <
typename LHS,
typename RHS>
2138template <
typename LHS,
typename RHS>
2153template <
typename LHS,
typename RHS>
2168template <
typename LHS,
typename RHS>
2179template <
typename LHS_t,
typename RHS_t,
typename Sum_t>
2188 template <
typename OpTy>
bool match(OpTy *V) {
2189 Value *ICmpLHS, *ICmpRHS;
2194 Value *AddLHS, *AddRHS;
2199 if (AddExpr.match(ICmpLHS) && (ICmpRHS == AddLHS || ICmpRHS == AddRHS))
2200 return L.match(AddLHS) &&
R.match(AddRHS) &&
S.match(ICmpLHS);
2204 if (AddExpr.match(ICmpRHS) && (ICmpLHS == AddLHS || ICmpLHS == AddRHS))
2205 return L.match(AddLHS) &&
R.match(AddRHS) &&
S.match(ICmpRHS);
2211 if (XorExpr.match(ICmpLHS))
2212 return L.match(Op1) &&
R.match(ICmpRHS) &&
S.match(ICmpLHS);
2216 if (XorExpr.match(ICmpRHS))
2217 return L.match(Op1) &&
R.match(ICmpLHS) &&
S.match(ICmpRHS);
2226 return L.match(AddLHS) &&
R.match(AddRHS) &&
S.match(ICmpLHS);
2231 return L.match(AddLHS) &&
R.match(AddRHS) &&
S.match(ICmpRHS);
2242template <
typename LHS_t,
typename RHS_t,
typename Sum_t>
2254 template <
typename OpTy>
bool match(OpTy *V) {
2256 if (
const auto *CI = dyn_cast<CallInst>(V))
2257 return Val.match(CI->getArgOperand(
OpI));
2263template <
unsigned OpI,
typename Opnd_t>
2274 template <
typename OpTy>
bool match(OpTy *V) {
2275 if (
const auto *CI = dyn_cast<CallInst>(V))
2276 if (
const auto *
F = CI->getCalledFunction())
2277 return F->getIntrinsicID() ==
ID;
2286template <
typename T0 = void,
typename T1 = void,
typename T2 = void,
2287 typename T3 = void,
typename T4 = void,
typename T5 = void,
2288 typename T6 = void,
typename T7 = void,
typename T8 = void,
2289 typename T9 = void,
typename T10 =
void>
2298template <
typename T0,
typename T1,
typename T2>
2303template <
typename T0,
typename T1,
typename T2,
typename T3>
2309template <
typename T0,
typename T1,
typename T2,
typename T3,
typename T4>
2315template <
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
2329template <
typename Opnd0,
typename Opnd1,
typename Opnd2,
typename Opnd3>
2333 return m_Intrinsic<Intrinsic::masked_load>(Op0, Op1, Op2, Op3);
2337template <
typename Opnd0,
typename Opnd1,
typename Opnd2,
typename Opnd3>
2341 return m_Intrinsic<Intrinsic::masked_gather>(Op0, Op1, Op2, Op3);
2344template <Intrinsic::ID IntrID,
typename T0>
2346 return m_CombineAnd(m_Intrinsic<IntrID>(), m_Argument<0>(Op0));
2349template <Intrinsic::ID IntrID,
typename T0,
typename T1>
2352 return m_CombineAnd(m_Intrinsic<IntrID>(Op0), m_Argument<1>(Op1));
2355template <Intrinsic::ID IntrID,
typename T0,
typename T1,
typename T2>
2358 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1), m_Argument<2>(Op2));
2365 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2), m_Argument<3>(Op3));
2369 typename T3,
typename T4>
2373 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3),
2374 m_Argument<4>(Op4));
2378 typename T3,
typename T4,
typename T5>
2381 const T4 &Op4,
const T5 &Op5) {
2382 return m_CombineAnd(m_Intrinsic<IntrID>(Op0, Op1, Op2, Op3, Op4),
2383 m_Argument<5>(Op5));
2387template <
typename Opnd0>
2389 return m_Intrinsic<Intrinsic::bitreverse>(Op0);
2392template <
typename Opnd0>
2394 return m_Intrinsic<Intrinsic::bswap>(Op0);
2397template <
typename Opnd0>
2399 return m_Intrinsic<Intrinsic::fabs>(Op0);
2402template <
typename Opnd0>
2404 return m_Intrinsic<Intrinsic::canonicalize>(Op0);
2407template <
typename Opnd0,
typename Opnd1>
2410 return m_Intrinsic<Intrinsic::minnum>(Op0, Op1);
2413template <
typename Opnd0,
typename Opnd1>
2416 return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
2419template <
typename Opnd0,
typename Opnd1,
typename Opnd2>
2421m_FShl(
const Opnd0 &Op0,
const Opnd1 &Op1,
const Opnd2 &Op2) {
2422 return m_Intrinsic<Intrinsic::fshl>(Op0, Op1, Op2);
2425template <
typename Opnd0,
typename Opnd1,
typename Opnd2>
2427m_FShr(
const Opnd0 &Op0,
const Opnd1 &Op1,
const Opnd2 &Op2) {
2428 return m_Intrinsic<Intrinsic::fshr>(Op0, Op1, Op2);
2431template <
typename Opnd0>
2433 return m_Intrinsic<Intrinsic::sqrt>(Op0);
2436template <
typename Opnd0,
typename Opnd1>
2439 return m_Intrinsic<Intrinsic::copysign>(Op0, Op1);
2442template <
typename Opnd0>
2444 return m_Intrinsic<Intrinsic::experimental_vector_reverse>(Op0);
2452template <
typename LHS,
typename RHS>
2459template <
typename LHS,
typename RHS>
2467template <
typename LHS,
typename RHS>
2474template <
typename LHS,
typename RHS>
2481template <
typename LHS,
typename RHS>
2488template <
typename LHS,
typename RHS>
2495template <
typename LHS,
typename RHS>
2502template <
typename LHS,
typename RHS>
2509template <
typename ValTy>
2516template <
typename ValTy>
2527template <
typename ValTy>
2537 template <
typename OpTy>
bool match(OpTy *V) {
2544 return Val.match(
X);
2546 return Val.match(
X);
2553template <
typename ValTy>
2559template <
typename LHS,
typename RHS>
2565template <
typename LHS,
typename RHS>
2571template <
typename LHS,
typename RHS>
2577template <
typename LHS,
typename RHS>
2583template <
typename LHS,
typename RHS>
2594template <Intrinsic::ID IntrID,
typename T0,
typename T1>
2599 m_Intrinsic<IntrID>(Op1, Op0));
2603template <
typename LHS,
typename RHS>
2610template <
typename LHS,
typename RHS>
2620 template <
typename OpTy>
bool match(OpTy *V) {
2621 unsigned TypeSize = V->getType()->getScalarSizeInBits();
2625 unsigned ShiftWidth =
TypeSize - 1;
2626 Value *OpL =
nullptr, *OpR =
nullptr;
2642 return Signum.match(V) && OpL == OpR &&
Val.match(OpL);
2660 template <
typename OpTy>
bool match(OpTy *V) {
2661 if (
auto *
I = dyn_cast<ExtractValueInst>(V)) {
2664 !(
I->getNumIndices() == 1 &&
I->getIndices()[0] == (
unsigned)Ind))
2666 return Val.match(
I->getAggregateOperand());
2674template <
int Ind,
typename Val_t>
2681template <
typename Val_t>
2693 template <
typename OpTy>
bool match(OpTy *V) {
2694 if (
auto *
I = dyn_cast<InsertValueInst>(V)) {
2695 return Op0.match(
I->getOperand(0)) &&
Op1.match(
I->getOperand(1)) &&
2696 I->getNumIndices() == 1 && Ind ==
I->getIndices()[0];
2703template <
int Ind,
typename Val_t,
typename Elt_t>
2714 template <
typename ITy>
bool match(ITy *V) {
2715 if (m_Intrinsic<Intrinsic::vscale>().
match(V))
2720 if (
auto *
GEP = dyn_cast<GEPOperator>(
Ptr)) {
2722 dyn_cast<ScalableVectorType>(
GEP->getSourceElementType());
2723 if (
GEP->getNumIndices() == 1 && DerefTy &&
2724 DerefTy->getElementType()->isIntegerTy(8) &&
2739template <
typename LHS,
typename RHS,
unsigned Opcode,
bool Commutable = false>
2747 auto *
I = dyn_cast<Instruction>(V);
2748 if (!
I || !
I->getType()->isIntOrIntVectorTy(1))
2751 if (
I->getOpcode() == Opcode) {
2752 auto *Op0 =
I->getOperand(0);
2753 auto *Op1 =
I->getOperand(1);
2754 return (
L.match(Op0) &&
R.match(Op1)) ||
2755 (Commutable &&
L.match(Op1) &&
R.match(Op0));
2758 if (
auto *
Select = dyn_cast<SelectInst>(
I)) {
2760 auto *TVal =
Select->getTrueValue();
2761 auto *FVal =
Select->getFalseValue();
2768 if (Opcode == Instruction::And) {
2769 auto *
C = dyn_cast<Constant>(FVal);
2770 if (
C &&
C->isNullValue())
2771 return (
L.match(
Cond) &&
R.match(TVal)) ||
2772 (Commutable &&
L.match(TVal) &&
R.match(
Cond));
2774 assert(Opcode == Instruction::Or);
2775 auto *
C = dyn_cast<Constant>(TVal);
2776 if (
C &&
C->isOneValue())
2777 return (
L.match(
Cond) &&
R.match(FVal)) ||
2778 (Commutable &&
L.match(FVal) &&
R.match(
Cond));
2788template <
typename LHS,
typename RHS>
2798template <
typename LHS,
typename RHS>
2806template <
typename LHS,
typename RHS>
2816template <
typename LHS,
typename RHS>
2825template <
typename LHS,
typename RHS,
bool Commutable = false>
2836template <
typename LHS,
typename RHS>
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
amdgpu AMDGPU Register Bank Select
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
const SmallVectorImpl< MachineOperand > & Cond
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.
This class represents a no-op cast from one type to another.
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.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
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.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
LLVM Value Representation.
Base class of all SIMD vector types.
ElementCount getElementCount() const
Return an ElementCount instance to represent the (possibly scalable) number of elements in the vector...
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.
PtrAdd_match< PointerOpTy, OffsetOpTy > m_PtrAdd(const PointerOpTy &PointerOp, const OffsetOpTy &OffsetOp)
Matches GEP with i8 source element type.
cst_pred_ty< is_negative > m_Negative()
Match an integer or vector of negative values.
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.
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.
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.
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
AllowReassoc_match< T > m_AllowReassoc(const T &SubPattern)
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)
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)
match_combine_or< CastInst_match< OpTy, ZExtInst >, OpTy > m_ZExtOrSelf(const OpTy &Op)
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)
cst_pred_ty< is_shifted_mask > m_ShiftedMask()
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.
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.
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.
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.
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)
CastOperator_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
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.
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.
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)
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.
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.
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.
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.
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.
OneOps_match< OpTy, Instruction::Load > m_Load(const OpTy &Op)
Matches LoadInst.
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)
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)
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.
cst_pred_ty< is_negated_power2_or_zero > m_NegatedPower2OrZero()
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.
cst_pred_ty< is_lowbit_mask_or_zero > m_LowBitMaskOrZero()
Match an integer or vector with only the low bit(s) set.
specific_fpval m_FPOne()
Match a float 1.0 or vector with all elements equal to 1.0.
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.
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".
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< CastOperator_match< OpTy, Instruction::Trunc >, OpTy > m_TruncOrSelf(const OpTy &Op)
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.
class_match< UnaryOperator > m_UnOp()
Match an arbitrary unary operation and ignore it.
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)
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)
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.
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)
CastInst_match< OpTy, FPTruncInst > m_FPTrunc(const OpTy &Op)
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.
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.
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.
BinaryOp_match< LHS, RHS, Instruction::Or, true > m_c_Or(const LHS &L, const RHS &R)
Matches an Or with LHS and RHS in either order.
CastOperator_match< OpTy, Instruction::IntToPtr > m_IntToPtr(const OpTy &Op)
Matches IntToPtr.
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
LogicalOp_match< LHS, RHS, Instruction::Or, true > m_c_LogicalOr(const LHS &L, const RHS &R)
Matches L || R with LHS and RHS in either order.
ThreeOps_match< Val_t, Elt_t, Idx_t, Instruction::InsertElement > m_InsertElt(const Val_t &Val, const Elt_t &Elt, const Idx_t &Idx)
Matches InsertElementInst.
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.
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.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Implement std::hash so that hash_code can be used in STL containers.
AllowReassoc_match(const SubPattern_t &SP)
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)
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)
CastInst_match(const Op_t &OpMatch)
CastOperator_match(const Op_t &OpMatch)
CmpClass_match(PredicateTy &Pred, const LHS_t &LHS, const RHS_t &RHS)
DisjointOr_match(const LHS &L, const RHS &R)
ElementWiseBitCast_match(const Op_t &OpMatch)
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)
NNegZExt_match(const Op_t &OpMatch)
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)
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)
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 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 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)
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)