[PatternMatch] Implement matching code for LibFunc

[Quolyk]

Summary

Provides m_LibFunc pattern that can be used to match LibFuncs.

[Quolyk]

Up. I guess it still needs to be merged as it introduces pattern matching for LibFuncs that would be quite usefull.

[Quolyk]

Ping

[efriedma]

Do you need to check whether the call is marked nobuiltin?

[Quolyk]

Check if call isNoBuiltin

[lebedev.ri]

Is it possible to add some unit test for this?

[Quolyk]

In D42047#1164762, @lebedev.ri wrote:

Is it possible to add some unit test for this?

I have not seen that this header is explicitly tested, but it can be tested througn some libFunc pattern matches, as I hope to introduce some using this

[lebedev.ri]

In D42047#1164770, @Quolyk wrote:

In D42047#1164762, @lebedev.ri wrote:

Is it possible to add some unit test for this?

I have not seen that this header is explicitly tested, but it can be tested througn some libFunc pattern matches, as I hope to introduce some using this

unittests/IR/PatternMatch.cpp

[efriedma]

include/llvm/IR/PatternMatch.h

1655

Please use TargetLibraryInfo::getLibFunc(ImmutableCallSite CS, LibFunc &F) when possible, so we can avoid scattering validity checks all over the code. (This formulation misses the call to isValidProtoForLibFunc.)

[Quolyk]

Use TargetLibraryInfo::getLibFunc.

[Quolyk]

In D42047#1164773, @lebedev.ri wrote:

In D42047#1164770, @Quolyk wrote:

In D42047#1164762, @lebedev.ri wrote:

Is it possible to add some unit test for this?

I have not seen that this header is explicitly tested, but it can be tested througn some libFunc pattern matches, as I hope to introduce some using this

unittests/IR/PatternMatch.cpp

I don't see that all patterns are tested in that file. Instead, patterns are tested implicitly in optimization transforms.

[Quolyk]

Add unit tests

[lebedev.ri]

Almost there i think..

unittests/IR/PatternMatch.cpp

658–666

Nice.
I feel like the template logic in PatternMatch.h looks fragile, so this could use a new negative tests, too.

[lebedev.ri]

(no new comments - still looks ok other than lack of at least one negative test - just marking as reviewed)

[Quolyk]

Add negative tests

[lebedev.ri]

include/llvm/IR/PatternMatch.h

1802

Does TLI.getLibFunc() check NoBuiltin internally?
I see that check got dropped.

[Quolyk]

Use NoBuiltin

[lebedev.ri]

In D42047#1579987, @Quolyk wrote:

Use NoBuiltin

Okay, should be fine i guess.
Should that be tested?

[Quolyk]

Add NoBuiltin tests.

[Quolyk]

Minor update

include/llvm/IR/PatternMatch.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_PATTERNMATCH_H
 #define LLVM_IR_PATTERNMATCH_H
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Value.h"

 /// Matches a BinaryOperator with LHS and RHS in either order.
 template <typename LHS, typename RHS>
 inline AnyBinaryOp_match<LHS, RHS, true> m_c_BinOp(const LHS &L, const RHS &R) {
   return AnyBinaryOp_match<LHS, RHS, true>(L, R);
 }
 
 /// Matches an ICmp with a predicate over LHS and RHS in either order.
 /// Does not swap the predicate.
 template <typename LHS, typename RHS>
 inline CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate, true>
 m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
   return CmpClass_match<LHS, RHS, ICmpInst, ICmpInst::Predicate, true>(Pred, L,
                                                                        R);
 }
 
 /// Matches a Add with LHS and RHS in either order.
 template <typename LHS, typename RHS>

 /// signum(x) =
 ///      x >  0  ->  1
 ///      x == 0  ->  0
 ///      x <  0  -> -1
 template <typename Val_t> inline Signum_match<Val_t> m_Signum(const Val_t &V) {
   return Signum_match<Val_t>(V);
 }
 
+/// \brief LibFunc matchers.
+struct LibFunc_match {
+  LibFunc F;
+  TargetLibraryInfo TLI;
+  
+  LibFunc_match(LibFunc Func, TargetLibraryInfo TargetLI)
+  : F(Func), TLI(TargetLI) {}
+  
+  template <typename OpTy> bool match(OpTy *V) {
+    LibFunc LF;
+    if (const auto *CI = dyn_cast<CallInst>(V))
+      if (!CI->isNoBuiltin() && CI->getCalledFunction() &&
+          TLI.getLibFunc(*CI->getCalledFunction(), LF) &&
+          LF == F && TLI.has(LF))
+        return true;
+    return false;
+  }
+};
+
+/// LibFunc matches are combinations of Name matchers, and argument
+/// matchers.
+template <typename T0 = void, typename T1 = void, typename T2 = void>
+struct m_LibFunc_Ty;
+template <typename T0> struct m_LibFunc_Ty<T0> {
+  using Ty = match_combine_and<LibFunc_match, Argument_match<T0>>;
+};
+template <typename T0, typename T1> struct m_LibFunc_Ty<T0, T1> {
+  using Ty =
+  match_combine_and<typename m_LibFunc_Ty<T0>::Ty,
+  Argument_match<T1>>;
+};
+
+/// \brief Match LibFunc calls like this:
+/// m_LibFunc<LibFunc_tan>(m_Value(X))
+template <LibFunc F>
+inline LibFunc_match m_LibFunc(TargetLibraryInfo TLI) {
+  return LibFunc_match(F, TLI);
+}
+
+template <LibFunc F, typename T0>
+inline typename m_LibFunc_Ty<T0>::Ty
+m_LibFunc(const TargetLibraryInfo TLI, const T0 &Op0) {
+  return m_CombineAnd(m_LibFunc<F>(TLI), m_Argument<0>(Op0));
+}
+
+template <LibFunc F, typename T0, typename T1>
+inline typename m_LibFunc_Ty<T0, T1>::Ty
+m_LibFunc(const TargetLibraryInfo TLI, const T0 &Op0, const T1 &Op1) {
+  return m_CombineAnd(m_LibFunc<F>(TLI, Op0), m_Argument<1>(Op1));
+}
+
 } // end namespace PatternMatch
 } // end namespace llvm
 
 #endif // LLVM_IR_PATTERNMATCH_H

unittests/IR/PatternMatch.cpp

 namespace {
 
 struct PatternMatchTest : ::testing::Test {
   LLVMContext Ctx;
   std::unique_ptr<Module> M;
   Function *F;
   BasicBlock *BB;
   IRBuilder<NoFolder> IRB;
+  TargetLibraryInfoImpl TLII;
+  TargetLibraryInfo TLI;
 
   PatternMatchTest()
       : M(new Module("PatternMatchTestModule", Ctx)),
         F(Function::Create(
             FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
             Function::ExternalLinkage, "f", M.get())),
-        BB(BasicBlock::Create(Ctx, "entry", F)), IRB(BB) {}
+        BB(BasicBlock::Create(Ctx, "entry", F)), IRB(BB), TLI(TLII) {}
 };
 
 TEST_F(PatternMatchTest, OneUse) {
   // Build up a little tree of values:
   //
   //   One  = (1 + 2) + 42
   //   Two  = One + 42
   //   Leaf = (Two + 8) + (Two + 13)
TEST_F(PatternMatchTest, FloatingPointFNeg) {
   cast<Instruction>(V2)->setHasNoSignedZeros(true);
   EXPECT_TRUE(match(V2, m_FNeg(m_Value(Match))));
   EXPECT_EQ(One, Match);
 
   // Test FAdd(-0.0, 1.0)
   EXPECT_FALSE(match(V3, m_FNeg(m_Value(Match))));
 }
 
+TEST_F(PatternMatchTest, LibFunc) {
+  Type *FltTy = IRB.getFloatTy();
+  Value *One = ConstantFP::get(FltTy, 1.0);
+  Value *Two = ConstantFP::get(FltTy, 2.0);
+  Value *MatchOne, *MatchTwo;
+
+  StringRef TanName = TLI.getName(LibFunc_tan);
+  FunctionCallee TanCallee = M->getOrInsertFunction(TanName, FltTy, FltTy);
+  CallInst *Tan = IRB.CreateCall(TanCallee, One, TanName);
+
+  StringRef PowName = TLI.getName(LibFunc_pow);
+  FunctionCallee PowCallee = M->getOrInsertFunction(PowName, FltTy, FltTy, FltTy);
+  CallInst *Pow = IRB.CreateCall(PowCallee, {One, Two}, PowName);
+
+  EXPECT_TRUE(match(Tan, m_LibFunc<LibFunc_tan>(TLI)));
+  EXPECT_FALSE(match(Tan, m_LibFunc<LibFunc_pow>(TLI)));
+  EXPECT_FALSE(match(Pow, m_LibFunc<LibFunc_tan>(TLI)));
+
+  EXPECT_TRUE(match(Tan, m_LibFunc<LibFunc_tan>(TLI, m_Value(MatchOne))));
+  EXPECT_EQ(One, MatchOne);
+  EXPECT_FALSE(match(Tan, m_LibFunc<LibFunc_sin>(TLI, m_Value())));
+
+  EXPECT_TRUE(match(Pow, m_LibFunc<LibFunc_pow>(TLI, m_Value(MatchOne),
+                                                m_Value(MatchTwo))));
+  EXPECT_EQ(One, MatchOne);
+  EXPECT_EQ(Two, MatchTwo);
+  EXPECT_FALSE(match(Pow, m_LibFunc<LibFunc_fminf>(TLI, m_Value(), m_Value())));
+  
+  TLII.disableAllFunctions();
+  EXPECT_FALSE(match(Tan, m_LibFunc<LibFunc_tan>(TLI)));
+  EXPECT_FALSE(match(Tan, m_LibFunc<LibFunc_tan>(TLI, m_Value())));
+  EXPECT_FALSE(match(Pow, m_LibFunc<LibFunc_pow>(TLI, m_Value(), m_Value())));
+}
+
 template <typename T> struct MutableConstTest : PatternMatchTest { };
 
 typedef ::testing::Types<std::tuple<Value*, Instruction*>,
                          std::tuple<const Value*, const Instruction *>>
     MutableConstTestTypes;
 TYPED_TEST_CASE(MutableConstTest, MutableConstTestTypes);
 
 TYPED_TEST(MutableConstTest, ICmp) {