Index: include/llvm/IR/PatternMatch.h
===================================================================
--- include/llvm/IR/PatternMatch.h
+++ include/llvm/IR/PatternMatch.h
@@ -31,6 +31,7 @@
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
@@ -1436,6 +1437,89 @@
   return m_Intrinsic<Intrinsic::maxnum>(Op0, Op1);
 }
 
+/// \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) {
+        if (const auto *CI = dyn_cast<CallInst>(V))
+            if (const auto *CalledF = CI->getCalledFunction())
+                if (TLI.has(F))
+                    return TLI.getName(F) == CalledF->getName();
+        return false;
+    }
+};
+
+/// LibFunc matches are combinations of Name matchers, and argument
+/// matchers.
+template <typename T0 = void, typename T1 = void, typename T2 = void,
+typename T3 = void, typename T4 = void, typename T5 = void,
+typename T6 = void, typename T7 = void, typename T8 = void,
+typename T9 = void, typename T10 = 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>>;
+};
+template <typename T0, typename T1, typename T2>
+struct m_LibFunc_Ty<T0, T1, T2> {
+    using Ty =
+    match_combine_and<typename m_LibFunc_Ty<T0, T1>::Ty,
+    Argument_match<T2>>;
+};
+template <typename T0, typename T1, typename T2, typename T3>
+struct m_LibFunc_Ty<T0, T1, T2, T3> {
+    using Ty =
+    match_combine_and<typename m_LibFunc_Ty<T0, T1, T2>::Ty,
+    Argument_match<T3>>;
+};
+
+/// \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 T0 &Op1) {
+    return m_CombineAnd(m_LibFunc<F>(TLI, Op0), m_Argument<1>(Op1));
+}
+
+template <LibFunc F, typename T0, typename T1, typename T2>
+inline typename m_LibFunc_Ty<T0, T1, T2>::Ty
+m_LibFunc(const TargetLibraryInfo TLI,
+          const T0 &Op0,
+          const T0 &Op1,
+          const T0 &Op2) {
+    return m_CombineAnd(m_LibFunc<F>(TLI, Op0, Op1), m_Argument<2>(Op2));
+}
+
+template <LibFunc F, typename T0, typename T1, typename T2, typename T3>
+inline typename m_LibFunc_Ty<T0, T1, T2, T3>::Ty
+m_LibFunc(const TargetLibraryInfo TLI,
+          const T0 &Op0,
+          const T0 &Op1,
+          const T0 &Op2,
+          const T0 &Op3) {
+    return m_CombineAnd(m_LibFunc<F>(TLI, Op0, Op1, Op2), m_Argument<3>(Op3));
+}
+
 template <typename Opnd_t> struct Signum_match {
   Opnd_t Val;
   Signum_match(const Opnd_t &V) : Val(V) {}