Skip to content

Commit 9a3cd0e

Browse files
goldsteinngoldsteinn
committed
[PatternMatch] Add matchers for m_{I,F,}Cmp and m_{I,F,}SpecificCmp; NFC
These matchers either take no predicate argument or match a specific predicate respectively. We have a lot of cases where the Pred argument is either unused and requiring the argument reduces code clarity. Likewise we have a lot of cases where we only pass in Pred to test equality which the new `*Specific*` helpers can simplify. Closes #98282
1 parent d7fd8b1 commit 9a3cd0e

File tree

2 files changed

+212
-1
lines changed

2 files changed

+212
-1
lines changed

‎llvm/include/llvm/IR/PatternMatch.h

Lines changed: 69 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1592,6 +1592,67 @@ m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
15921592
return CmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate>(Pred, L, R);
15931593
}
15941594

1595+
template <typename LHS, typename RHS>
1596+
inline CmpClass_match<LHS, RHS, CmpInst, CmpInst::Predicate>
1597+
m_Cmp(const LHS &L, const RHS &R) {
1598+
CmpInst::Predicate Unused;
1599+
return CmpClass_match<LHS, RHS, CmpInst, CmpInst::Predicate>(Unused, L, R);
1600+
}
1601+
1602+
template <typename LHS, typename RHS>
1603+
inline CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate>
1604+
m_ICmp(const LHS &L, const RHS &R) {
1605+
ICmpInst::Predicate Unused;
1606+
return CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate>(Unused, L, R);
1607+
}
1608+
1609+
template <typename LHS, typename RHS>
1610+
inline CmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate>
1611+
m_FCmp(const LHS &L, const RHS &R) {
1612+
FCmpInst::Predicate Unused;
1613+
return CmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate>(Unused, L, R);
1614+
}
1615+
1616+
// Same as CmpClass, but instead of saving Pred as out output variable, match a
1617+
// specific input pred for equality.
1618+
template <typename LHS_t, typename RHS_t, typename Class, typename PredicateTy>
1619+
struct SpecificCmpClass_match {
1620+
const PredicateTy Predicate;
1621+
LHS_t L;
1622+
RHS_t R;
1623+
1624+
SpecificCmpClass_match(PredicateTy Pred, const LHS_t &LHS, const RHS_t &RHS)
1625+
: Predicate(Pred), L(LHS), R(RHS) {}
1626+
1627+
template <typename OpTy> bool match(OpTy *V) {
1628+
if (auto *I = dyn_cast<Class>(V))
1629+
return I->getPredicate() == Predicate && L.match(I->getOperand(0)) &&
1630+
R.match(I->getOperand(1));
1631+
return false;
1632+
}
1633+
};
1634+
1635+
template <typename LHS, typename RHS>
1636+
inline SpecificCmpClass_match<LHS, RHS, CmpInst, CmpInst::Predicate>
1637+
m_SpecificCmp(CmpInst::Predicate MatchPred, const LHS &L, const RHS &R) {
1638+
return SpecificCmpClass_match<LHS, RHS, CmpInst, CmpInst::Predicate>(
1639+
MatchPred, L, R);
1640+
}
1641+
1642+
template <typename LHS, typename RHS>
1643+
inline SpecificCmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate>
1644+
m_SpecificICmp(ICmpInst::Predicate MatchPred, const LHS &L, const RHS &R) {
1645+
return SpecificCmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate>(
1646+
MatchPred, L, R);
1647+
}
1648+
1649+
template <typename LHS, typename RHS>
1650+
inline SpecificCmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate>
1651+
m_SpecificFCmp(FCmpInst::Predicate MatchPred, const LHS &L, const RHS &R) {
1652+
return SpecificCmpClass_match<LHS, RHS, FCmpInst, FCmpInst::Predicate>(
1653+
MatchPred, L, R);
1654+
}
1655+
15951656
//===----------------------------------------------------------------------===//
15961657
// Matchers for instructions with a given opcode and number of operands.
15971658
//
@@ -2617,6 +2678,14 @@ m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
26172678
R);
26182679
}
26192680

2681+
template <typename LHS, typename RHS>
2682+
inline CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate, true>
2683+
m_c_ICmp(const LHS &L, const RHS &R) {
2684+
ICmpInst::Predicate Unused;
2685+
return CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate, true>(Unused,
2686+
L, R);
2687+
}
2688+
26202689
/// Matches a specific opcode with LHS and RHS in either order.
26212690
template <typename LHS, typename RHS>
26222691
inline SpecificBinaryOp_match<LHS, RHS, true>

‎llvm/unittests/IR/PatternMatch.cpp

Lines changed: 143 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2250,9 +2250,151 @@ TYPED_TEST(MutableConstTest, ICmp) {
22502250
ICmpInst::Predicate MatchPred;
22512251

22522252
EXPECT_TRUE(m_ICmp(MatchPred, m_Value(MatchL), m_Value(MatchR))
2253-
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2253+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
22542254
EXPECT_EQ(L, MatchL);
22552255
EXPECT_EQ(R, MatchR);
2256+
2257+
EXPECT_TRUE(m_Cmp(MatchPred, m_Value(MatchL), m_Value(MatchR))
2258+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2259+
EXPECT_EQ(L, MatchL);
2260+
EXPECT_EQ(R, MatchR);
2261+
2262+
EXPECT_TRUE(m_ICmp(m_Specific(L), m_Specific(R))
2263+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2264+
2265+
EXPECT_TRUE(m_Cmp(m_Specific(L), m_Specific(R))
2266+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2267+
2268+
EXPECT_FALSE(m_ICmp(m_Specific(R), m_Specific(L))
2269+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2270+
EXPECT_FALSE(m_Cmp(m_Specific(R), m_Specific(L))
2271+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2272+
2273+
EXPECT_TRUE(m_c_ICmp(m_Specific(R), m_Specific(L))
2274+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2275+
2276+
EXPECT_FALSE(m_c_ICmp(m_Specific(R), m_Specific(R))
2277+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2278+
2279+
EXPECT_TRUE(m_SpecificICmp(Pred, m_Specific(L), m_Specific(R))
2280+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2281+
EXPECT_TRUE(m_SpecificCmp(Pred, m_Specific(L), m_Specific(R))
2282+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2283+
2284+
EXPECT_FALSE(m_SpecificICmp(Pred, m_Specific(R), m_Specific(L))
2285+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2286+
EXPECT_FALSE(m_SpecificCmp(Pred, m_Specific(R), m_Specific(L))
2287+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2288+
2289+
MatchL = nullptr;
2290+
MatchR = nullptr;
2291+
EXPECT_TRUE(m_SpecificICmp(Pred, m_Value(MatchL), m_Value(MatchR))
2292+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2293+
EXPECT_EQ(L, MatchL);
2294+
EXPECT_EQ(R, MatchR);
2295+
MatchL = nullptr;
2296+
MatchR = nullptr;
2297+
EXPECT_TRUE(m_SpecificCmp(Pred, m_Value(MatchL), m_Value(MatchR))
2298+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2299+
EXPECT_EQ(L, MatchL);
2300+
EXPECT_EQ(R, MatchR);
2301+
2302+
EXPECT_FALSE(m_SpecificICmp(Pred, m_Specific(R), m_Specific(L))
2303+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2304+
EXPECT_FALSE(m_SpecificCmp(Pred, m_Specific(R), m_Specific(L))
2305+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2306+
2307+
EXPECT_FALSE(m_SpecificICmp(ICmpInst::getInversePredicate(Pred),
2308+
m_Specific(L), m_Specific(R))
2309+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2310+
EXPECT_FALSE(m_SpecificCmp(ICmpInst::getInversePredicate(Pred), m_Specific(L),
2311+
m_Specific(R))
2312+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2313+
2314+
EXPECT_FALSE(m_SpecificICmp(ICmpInst::getInversePredicate(Pred),
2315+
m_Value(MatchL), m_Value(MatchR))
2316+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2317+
EXPECT_FALSE(m_SpecificCmp(ICmpInst::getInversePredicate(Pred),
2318+
m_Value(MatchL), m_Value(MatchR))
2319+
.match((InstructionType)IRB.CreateICmp(Pred, L, R)));
2320+
}
2321+
2322+
TYPED_TEST(MutableConstTest, FCmp) {
2323+
auto &IRB = PatternMatchTest::IRB;
2324+
2325+
typedef std::tuple_element_t<0, TypeParam> ValueType;
2326+
typedef std::tuple_element_t<1, TypeParam> InstructionType;
2327+
2328+
Value *L = Constant::getNullValue(IRB.getFloatTy());
2329+
Value *R = ConstantFP::getInfinity(IRB.getFloatTy(), true);
2330+
FCmpInst::Predicate Pred = FCmpInst::FCMP_OGT;
2331+
2332+
ValueType MatchL;
2333+
ValueType MatchR;
2334+
FCmpInst::Predicate MatchPred;
2335+
2336+
EXPECT_TRUE(m_FCmp(MatchPred, m_Value(MatchL), m_Value(MatchR))
2337+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2338+
EXPECT_EQ(L, MatchL);
2339+
EXPECT_EQ(R, MatchR);
2340+
2341+
EXPECT_TRUE(m_Cmp(MatchPred, m_Value(MatchL), m_Value(MatchR))
2342+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2343+
EXPECT_EQ(L, MatchL);
2344+
EXPECT_EQ(R, MatchR);
2345+
2346+
EXPECT_TRUE(m_FCmp(m_Specific(L), m_Specific(R))
2347+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2348+
2349+
EXPECT_TRUE(m_Cmp(m_Specific(L), m_Specific(R))
2350+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2351+
2352+
EXPECT_FALSE(m_FCmp(m_Specific(R), m_Specific(L))
2353+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2354+
EXPECT_FALSE(m_Cmp(m_Specific(R), m_Specific(L))
2355+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2356+
2357+
EXPECT_TRUE(m_SpecificFCmp(Pred, m_Specific(L), m_Specific(R))
2358+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2359+
EXPECT_TRUE(m_SpecificCmp(Pred, m_Specific(L), m_Specific(R))
2360+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2361+
2362+
EXPECT_FALSE(m_SpecificFCmp(Pred, m_Specific(R), m_Specific(L))
2363+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2364+
EXPECT_FALSE(m_SpecificCmp(Pred, m_Specific(R), m_Specific(L))
2365+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2366+
2367+
MatchL = nullptr;
2368+
MatchR = nullptr;
2369+
EXPECT_TRUE(m_SpecificFCmp(Pred, m_Value(MatchL), m_Value(MatchR))
2370+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2371+
EXPECT_EQ(L, MatchL);
2372+
EXPECT_EQ(R, MatchR);
2373+
MatchL = nullptr;
2374+
MatchR = nullptr;
2375+
EXPECT_TRUE(m_SpecificCmp(Pred, m_Value(MatchL), m_Value(MatchR))
2376+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2377+
EXPECT_EQ(L, MatchL);
2378+
EXPECT_EQ(R, MatchR);
2379+
2380+
EXPECT_FALSE(m_SpecificFCmp(Pred, m_Specific(R), m_Specific(L))
2381+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2382+
EXPECT_FALSE(m_SpecificCmp(Pred, m_Specific(R), m_Specific(L))
2383+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2384+
2385+
EXPECT_FALSE(m_SpecificFCmp(FCmpInst::getInversePredicate(Pred),
2386+
m_Specific(L), m_Specific(R))
2387+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2388+
EXPECT_FALSE(m_SpecificCmp(FCmpInst::getInversePredicate(Pred), m_Specific(L),
2389+
m_Specific(R))
2390+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2391+
2392+
EXPECT_FALSE(m_SpecificFCmp(FCmpInst::getInversePredicate(Pred),
2393+
m_Value(MatchL), m_Value(MatchR))
2394+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
2395+
EXPECT_FALSE(m_SpecificCmp(FCmpInst::getInversePredicate(Pred),
2396+
m_Value(MatchL), m_Value(MatchR))
2397+
.match((InstructionType)IRB.CreateFCmp(Pred, L, R)));
22562398
}
22572399

22582400
TEST_F(PatternMatchTest, ConstExpr) {

0 commit comments

Comments
 (0)