[SelectionDAG] Use __memcmpeq to replace bcmp and bool usage memcmp

[goldstein.w.n]

Summary

Add __memcmpeq as a LibCall enabled by cl::opt option:
'--with-builtin-memcmpeq'.

If enabled calls to bcmp will be replaced with memcmpeq and calls to
memcmp that only use the result as a boolean will be replaced
with memcmpeq.

If not enabled this patch has no effect.

This is essentially a follow up to: https://reviews.llvm.org/D56593

In glibc we decided against adding an optimized bcmp:
https://marc.info/?t=163157542200002&r=1&w=3
because its not in a reserved namespace.

To get the functionality (and make the bool usage memcmp optimization
meaningful on GNU systems) we added __memcmpeq:
https://sourceware.org/git/?p=glibc.git;a=commit;h=44829b3ddb64e99e37343a0f25b2c082387d31a5

Which was release with GLIBC 2.35.

Unlike bcmp which is an alias to memcmp on all targets in GLIBC,
__memcmpeq is actually better optimized on some targets (x86 as
of writing this patch).

[goldstein.w.n]

NB: Also have patch to add __memcmpeq as bonafide builtin in clang. Figure that's a bigger change but if people are interested LMK.

ps.
I posted this on monday to the mailing list but the moderators never approved. Is the only way to submit patches to llvm via phabricator?

[xbolva00]

Clang side should match gcc’s https://gcc.gnu.org/pipermail/gcc-patches/2022-June/596335.html

[goldstein.w.n]

In D127461#3585676, @xbolva00 wrote:

Clang side should match gcc’s https://gcc.gnu.org/pipermail/gcc-patches/2022-June/596335.html

It seems GCC may not end up sticking with -fextra-libc-function=. They seem to want to do this
just with just a check for if __memcmpeq is declared: https://gcc.gnu.org/pipermail/gcc-patches/2022-June/596595.html

Assuming GCC does stick with -fextra-libc-function= do you think llvm's side should keep the
--with-builtin-memcmpeq and clang should enable that if it sees '__memcmpeq' in
-fextra-libc-function=* or it should redirect all extra functions to llvm and let llvm handle them?

[xbolva00]

Ideally LLVM should just "enable" memcmpeq if glibc version is > XYZ. Not sure if there is a realiable way to do it. @efriedma ?

[goldstein.w.n]

In D127461#3586033, @xbolva00 wrote:

Ideally LLVM should just "enable" memcmpeq if glibc version is > XYZ. Not sure if there is a realiable way to do it. @efriedma ?

Wouldn't that almost definitionally only work if the file was being compiled statically? Otherwise you would
run into the issue that compiling on a system with glibc >= 2.35 produce an executable that wouldn't work
on a system with glibc < 2.35

[xbolva00]

Maybe new flag like -fglibc-version=ver ?

It could nicely fit as we already have -fbinutils-version and -fgnuc-version.

[jyknight]

In D127461#3586121, @goldstein.w.n wrote:

Wouldn't that almost definitionally only work if the file was being compiled statically? Otherwise you would
run into the issue that compiling on a system with glibc >= 2.35 produce an executable that wouldn't work
on a system with glibc < 2.35

There is absolutely no expectation of compatibility in that direction. A binary compiled against version X of glibc can run against any glibc version Y, where Y >= X -- but NOT the other way around.

[goldstein.w.n]

In D127461#3586144, @jyknight wrote:

In D127461#3586121, @goldstein.w.n wrote:

Wouldn't that almost definitionally only work if the file was being compiled statically? Otherwise you would
run into the issue that compiling on a system with glibc >= 2.35 produce an executable that wouldn't work
on a system with glibc < 2.35

There is absolutely no expectation of compatibility in that direction. A binary compiled against version X of glibc can run against any glibc version Y, where Y >= X -- but NOT the other way around.

Okay, so how about the same system header check approach as GCC is planning to go with?

Or do you want to limit this to just GLIBC?

[goldstein.w.n]

In D127461#3586127, @xbolva00 wrote:

Maybe new flag like -fglibc-version=ver ?

It could nicely fit as we already have -fbinutils-version and -fgnuc-version.

That would work here. Although if other libc implementations implement
something similar it wouldn't scale too-well.

[efriedma]

We already effectively have a platform version number on Mac/iOS/Android; adding a version number for another platform isn't a big deal. (Yes, it doesn't really scale in the sense that every libc needs to have some entries in TargetLibraryInfo.cpp, but we basically end up doing that anyway, in practice.)

The tricky thing is that there isn't any easy way to tell the glibc version number. The clang driver would have to dig through either system headers or the glibc library itself.

The alternative is that clang IR generation could check if __memcmpeq is declared somewhere in the file, and add some metadata to the module. That's also sort of ugly, but maybe easier to implement.

[goldstein.w.n]

In D127461#3586945, @efriedma wrote:

We already effectively have a platform version number on Mac/iOS/Android; adding a version number for another platform isn't a big deal. (Yes, it doesn't really scale in the sense that every libc needs to have some entries in TargetLibraryInfo.cpp, but we basically end up doing that anyway, in practice.)

The tricky thing is that there isn't any easy way to tell the glibc version number. The clang driver would have to dig through either system headers or the glibc library itself.

Parsing "libc.so.6" for ".gnu.version_d" wouldn't be an insane way to do it.

The alternative is that clang IR generation could check if __memcmpeq is declared somewhere in the file, and add some metadata to the module. That's also sort of ugly, but maybe easier to implement.

I like the idea of doing this at IR generation time.

What do you think about just using the clang AST and checking if there is a valid definition for __memcmpeq + isGNUEnvironment?
It's in the reserved namespace so as long as its not another libc re-purposing the symbol that should be safe.

That also seems to the direction GCC is going so it would be maximum compatibility.

[MaskRay]

[SelectionDAG]

I feel that [SimplifyLibCalls] is more appropriate. The main change is there.

-fglibc-version=ver

This seems fine to me. Agree with efriedma that every platform adding someway looks bad, but that is the current state.
I can see that a generic glibc version option can be useful. E.g. we had a workaround for exp10* in f5689f830414bdb60ce56ff37c182b6cebcedd0b.
Some Triple.isOSLinux() uses be better reword using a glibc version.
I think the hard thing is to decide a default value, which isn't clear in llvm-project's build and target requirement.

(From https://reviews.llvm.org/D56593#3586673)

-fbuiltin-__memcmpeq

https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html says "There is no corresponding -fbuiltin-function option".

If Clang decides to add this, it looks good and I am happy to implement it :)

[xbolva00]

What do you think about just using the clang AST and checking if there is a valid definition for __memcmpeq + isGNUEnvironment?

And if there is no declaration and somebody wrote “__builtin_memcmp(…) == 0” ? We sadly cannot use memcmpeq then, no?

[goldstein.w.n]

In D127461#3587063, @xbolva00 wrote:

What do you think about just using the clang AST and checking if there is a valid definition for __memcmpeq + isGNUEnvironment?

And if there is no declaration and somebody wrote “__builtin_memcmp(…) == 0” ? We sadly cannot use memcmpeq then, no?

No because the function may not exist.

But it will catch all the cases the function does exist w.o a commandline option. The reason I'm a bit partial to this is
if the optimization is guarded by a commandline option it see very little usage.

The only case the AST would miss is a build where memcmp was called w.o <string.h> being included. This seems
edge case enough to me its worth accepting.

In a few years time once GLIBC2.35 becomes the norm the replacement can become default like bcmp.

[craig.topper]

Is this still being looked at?

[goldstein.w.n]

In D127461#4259596, @craig.topper wrote:

Is this still being looked at?

Sorry, its been a while.

This stalled when discussing the method of enabling this. I think the goal was to match GCC but AFAICT GCC never ended up implementing this.

But im not actively working on this at the moment.

llvm/include/llvm/Analysis/TargetLibraryInfo.def

 TLI_DEFINE_STRING_INTERNAL("__logf_finite")
 /// long double __logl_finite(long double x);
 TLI_DEFINE_ENUM_INTERNAL(logl_finite)
 TLI_DEFINE_STRING_INTERNAL("__logl_finite")
 /// void *__memccpy_chk(void *dst, const void *src, int c, size_t n,
 ///                     size_t dstsize)
 TLI_DEFINE_ENUM_INTERNAL(memccpy_chk)
 TLI_DEFINE_STRING_INTERNAL("__memccpy_chk")
+/// int __memcmpeq(const void *s1, const void *s2, size_t n);
+TLI_DEFINE_ENUM_INTERNAL(memcmpeq)
+TLI_DEFINE_STRING_INTERNAL("__memcmpeq")
 /// void *__memcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
 TLI_DEFINE_ENUM_INTERNAL(memcpy_chk)
 TLI_DEFINE_STRING_INTERNAL("__memcpy_chk")
 /// void *__memmove_chk(void *s1, const void *s2, size_t n, size_t s1size);
 TLI_DEFINE_ENUM_INTERNAL(memmove_chk)
 TLI_DEFINE_STRING_INTERNAL("__memmove_chk")
 /// void *__mempcpy_chk(void *s1, const void *s2, size_t n, size_t s1size);
 TLI_DEFINE_ENUM_INTERNAL(mempcpy_chk)

llvm/include/llvm/CodeGen/SelectionDAGTargetInfo.h

public:
   virtual SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, const SDLoc &dl,
                                           SDValue Chain, SDValue Op1,
                                           SDValue Op2, SDValue Op3,
                                           Align Alignment, bool isVolatile,
                                           MachinePointerInfo DstPtrInfo) const {
     return SDValue();
   }
 
-  /// Emit target-specific code that performs a memcmp/bcmp, in cases where that is
-  /// faster than a libcall. The first returned SDValue is the result of the
-  /// memcmp and the second is the chain. Both SDValues can be null if a normal
-  /// libcall should be used.
+  /// Emit target-specific code that performs a memcmp/bcmp/__memcmpeq, in cases
+  /// where that is faster than a libcall. The first returned SDValue is the
+  /// result of the memcmp and the second is the chain. Both SDValues can be
+  /// null if a normal libcall should be used.
   virtual std::pair<SDValue, SDValue>
   EmitTargetCodeForMemcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
                           SDValue Op1, SDValue Op2, SDValue Op3,
                           MachinePointerInfo Op1PtrInfo,
                           MachinePointerInfo Op2PtrInfo) const {
     return std::make_pair(SDValue(), SDValue());
   }
 

llvm/include/llvm/Transforms/Utils/BuildLibCalls.h

namespace llvm {
   /// Emit a call to the memcmp function.
   Value *emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
                     const DataLayout &DL, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the bcmp function.
   Value *emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
                   const DataLayout &DL, const TargetLibraryInfo *TLI);
 
+  /// Emit a call to the __memcmpeq function.
+  Value *emitMemCmpEq(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
+                      const DataLayout &DL, const TargetLibraryInfo *TLI);
+
   /// Emit a call to the memccpy function.
   Value *emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
                      IRBuilderBase &B, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the snprintf function.
   Value *emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
                       ArrayRef<Value *> Args, IRBuilderBase &B,
                       const TargetLibraryInfo *TLI);

llvm/include/llvm/Transforms/Utils/SimplifyLibCalls.h

private:
   Value *optimizeStrTo(CallInst *CI, IRBuilderBase &B);
   Value *optimizeStrSpn(CallInst *CI, IRBuilderBase &B);
   Value *optimizeStrCSpn(CallInst *CI, IRBuilderBase &B);
   Value *optimizeStrStr(CallInst *CI, IRBuilderBase &B);
   Value *optimizeMemChr(CallInst *CI, IRBuilderBase &B);
   Value *optimizeMemRChr(CallInst *CI, IRBuilderBase &B);
   Value *optimizeMemCmp(CallInst *CI, IRBuilderBase &B);
   Value *optimizeBCmp(CallInst *CI, IRBuilderBase &B);
+  Value *optimizeMemCmpEq(CallInst *CI, IRBuilderBase &B);
   Value *optimizeMemCmpBCmpCommon(CallInst *CI, IRBuilderBase &B);
   Value *optimizeMemCCpy(CallInst *CI, IRBuilderBase &B);
   Value *optimizeMemPCpy(CallInst *CI, IRBuilderBase &B);
   Value *optimizeMemCpy(CallInst *CI, IRBuilderBase &B);
   Value *optimizeMemMove(CallInst *CI, IRBuilderBase &B);
   Value *optimizeMemSet(CallInst *CI, IRBuilderBase &B);
   Value *optimizeRealloc(CallInst *CI, IRBuilderBase &B);
   Value *optimizeWcslen(CallInst *CI, IRBuilderBase &B);

llvm/lib/Analysis/TargetLibraryInfo.cpp

cl::values(clEnumValN(TargetLibraryInfoImpl::NoLibrary, "none",
                           "Darwin_libsystem_m", "Darwin libsystem_m"),
                clEnumValN(TargetLibraryInfoImpl::LIBMVEC_X86, "LIBMVEC-X86",
                           "GLIBC Vector Math library"),
                clEnumValN(TargetLibraryInfoImpl::MASSV, "MASSV",
                           "IBM MASS vector library"),
                clEnumValN(TargetLibraryInfoImpl::SVML, "SVML",
                           "Intel SVML library")));
 
+static cl::opt<bool> WithBuiltinMemcmpeq(
+    "with-builtin-memcmpeq", cl::Hidden, cl::init(false),
+    cl::desc("Enable emitting __memcmpeq (as replacement for "
+             "boolean usage of memcmp/bcmp)"));
+
 StringLiteral const TargetLibraryInfoImpl::StandardNames[LibFunc::NumLibFuncs] =
     {
 #define TLI_DEFINE_STRING
 #include "llvm/Analysis/TargetLibraryInfo.def"
 };
 
 static bool hasSinCosPiStret(const Triple &T) {
   // Only Darwin variants have _stret versions of combined trig functions.
static bool hasBcmp(const Triple &TT) {
   // implementations of the libc still have it.
   if (TT.isOSLinux())
     return TT.isGNUEnvironment() || TT.isMusl();
   // Both NetBSD and OpenBSD are planning to remove the function. Windows does
   // not have it.
   return TT.isOSFreeBSD() || TT.isOSSolaris();
 }
 
+static bool hasMemcmpeq(const Triple &TT) {
+  if (WithBuiltinMemcmpeq) {
+    return true;
+  }
+  return false;
+}
+
 static bool isCallingConvCCompatible(CallingConv::ID CC, StringRef TT,
                                      FunctionType *FuncTy) {
   switch (CC) {
   default:
     return false;
   case llvm::CallingConv::C:
     return true;
   case llvm::CallingConv::ARM_APCS:
if (!hasSinCosPiStret(T)) {
     TLI.setUnavailable(LibFunc_cospif);
     TLI.setUnavailable(LibFunc_sincospi_stret);
     TLI.setUnavailable(LibFunc_sincospif_stret);
   }
 
   if (!hasBcmp(T))
     TLI.setUnavailable(LibFunc_bcmp);
 
+  if (!hasMemcmpeq(T)) {
+    //    TLI.setAvailable(LibFunc_memcmpeq);
+    //  else
+    TLI.setUnavailable(LibFunc_memcmpeq);
+  }
+
   if (T.isMacOSX() && T.getArch() == Triple::x86 &&
       !T.isMacOSXVersionLT(10, 7)) {
     // x86-32 OSX has a scheme where fwrite and fputs (and some other functions
     // we don't care about) have two versions; on recent OSX, the one we want
     // has a $UNIX2003 suffix. The two implementations are identical except
     // for the return value in some edge cases.  However, we don't want to
     // generate code that depends on the old symbols.
     TLI.setAvailableWithName(LibFunc_fwrite, "fwrite$UNIX2003");
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
   // Linux variants without glibc (eg: bionic, musl) may have some subset.
   if (!T.isOSLinux() || !T.isGNUEnvironment()) {
     TLI.setUnavailable(LibFunc_dunder_strdup);
     TLI.setUnavailable(LibFunc_dunder_strtok_r);
     TLI.setUnavailable(LibFunc_dunder_isoc99_scanf);
     TLI.setUnavailable(LibFunc_dunder_isoc99_sscanf);
     TLI.setUnavailable(LibFunc_under_IO_getc);
     TLI.setUnavailable(LibFunc_under_IO_putc);
+    TLI.setUnavailable(LibFunc_memcmpeq);
     // But, Android and musl have memalign.
     if (!T.isAndroid() && !T.isMusl())
       TLI.setUnavailable(LibFunc_memalign);
     TLI.setUnavailable(LibFunc_fopen64);
     TLI.setUnavailable(LibFunc_fseeko64);
     TLI.setUnavailable(LibFunc_fstat64);
     TLI.setUnavailable(LibFunc_fstatvfs64);
     TLI.setUnavailable(LibFunc_ftello64);
bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
   case LibFunc_readlink:
     return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_write:
     return (NumParams == 3 && FTy.getParamType(1)->isPointerTy());
   case LibFunc_aligned_alloc:
     return (NumParams == 2 && FTy.getReturnType()->isPointerTy());
   case LibFunc_bcopy:
+  case LibFunc_memcmpeq:
   case LibFunc_bcmp:
     return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_bzero:
     return (NumParams == 2 && FTy.getParamType(0)->isPointerTy());
   case LibFunc_calloc:
   case LibFunc_vec_calloc:
     return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

FunctionCallee llvm::getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI,
   case LibFunc_memccpy:
     setArgExtAttr(*F, 2, TLI);
     break;
 
     // These are functions that are known to not need any argument extension
     // on any target: A size_t argument (which may be an i32 on some targets)
     // should not trigger the assert below.
   case LibFunc_bcmp:
+  case LibFunc_memcmpeq:
   case LibFunc_calloc:
   case LibFunc_fwrite:
   case LibFunc_malloc:
   case LibFunc_memcmp:
   case LibFunc_memcpy_chk:
   case LibFunc_mempcpy:
   case LibFunc_memset_pattern16:
   case LibFunc_snprintf:
Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
                       const DataLayout &DL, const TargetLibraryInfo *TLI) {
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   return emitLibCall(
       LibFunc_bcmp, B.getInt32Ty(),
       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
 }
 
+Value *llvm::emitMemCmpEq(Value *Ptr1, Value *Ptr2, Value *Len,
+                          IRBuilderBase &B, const DataLayout &DL,
+                          const TargetLibraryInfo *TLI) {
+  LLVMContext &Context = B.GetInsertBlock()->getContext();
+  return emitLibCall(
+      LibFunc_memcmpeq, B.getInt32Ty(),
+      {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
+      {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
+}
+
 Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
                          IRBuilderBase &B, const TargetLibraryInfo *TLI) {
   return emitLibCall(
       LibFunc_memccpy, B.getInt8PtrTy(),
       {B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt32Ty(), Len->getType()},
       {Ptr1, Ptr2, Val, Len}, B, TLI);
 }
 

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

if (getConstantStringInfo(LHS, LHSStr) &&
     else if (Cmp > 0)
       Ret = 1;
     return ConstantInt::get(CI->getType(), Ret);
   }
 
   return nullptr;
 }
 
-// Most simplifications for memcmp also apply to bcmp.
+// Most simplifications for memcmp also apply to memcmpeq functions
+// including bcmp, __memcmpeq, or any other derivation function of
+// memcmp.
 Value *LibCallSimplifier::optimizeMemCmpBCmpCommon(CallInst *CI,
                                                    IRBuilderBase &B) {
   Value *LHS = CI->getArgOperand(0), *RHS = CI->getArgOperand(1);
   Value *Size = CI->getArgOperand(2);
 
   if (LHS == RHS) // memcmp(s,s,x) -> 0
     return Constant::getNullValue(CI->getType());
 

 }
 
 Value *LibCallSimplifier::optimizeMemCmp(CallInst *CI, IRBuilderBase &B) {
   Module *M = CI->getModule();
   if (Value *V = optimizeMemCmpBCmpCommon(CI, B))
     return V;
 
   // memcmp(x, y, Len) == 0 -> bcmp(x, y, Len) == 0
-  // bcmp can be more efficient than memcmp because it only has to know that
-  // there is a difference, not how different one is to the other.
-  if (isLibFuncEmittable(M, TLI, LibFunc_bcmp) &&
+  // bcmp and __memcmpeq can be more efficient than memcmp because it only has
+  // to know that there is a difference, not how different one is to the other.
+
+  // Note: We check both __memcmpeq and bcmp here (rather than having one
+  // forward to the other) because only one of them may be available.
+  if (((isLibFuncEmittable(M, TLI, LibFunc_bcmp) && TLI->has(LibFunc_bcmp)) ||
+       (isLibFuncEmittable(M, TLI, LibFunc_memcmpeq) &&
+        TLI->has(LibFunc_memcmpeq))) &&
       isOnlyUsedInZeroEqualityComparison(CI)) {
     Value *LHS = CI->getArgOperand(0);
     Value *RHS = CI->getArgOperand(1);
     Value *Size = CI->getArgOperand(2);
+    // Prefer __memcmpeq if its available.
+    if (isLibFuncEmittable(M, TLI, LibFunc_memcmpeq) &&
+        TLI->has(LibFunc_memcmpeq)) {
+      return copyFlags(*CI, emitMemCmpEq(LHS, RHS, Size, B, DL, TLI));
+    } else {
       return copyFlags(*CI, emitBCmp(LHS, RHS, Size, B, DL, TLI));
     }
+  }
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeBCmp(CallInst *CI, IRBuilderBase &B) {
+  Module *M = CI->getModule();
+  if (Value *V = optimizeMemCmpBCmpCommon(CI, B))
+    return V;
+
+  // Replace calls to bcmp with __memcmpeq is available.
+  if (isLibFuncEmittable(M, TLI, LibFunc_bcmp) && TLI->has(LibFunc_memcmpeq)) {
+    Value *LHS = CI->getArgOperand(0);
+    Value *RHS = CI->getArgOperand(1);
+    Value *Size = CI->getArgOperand(2);
+    return copyFlags(*CI, emitMemCmpEq(LHS, RHS, Size, B, DL, TLI));
+  }
+  return nullptr;
+}
+
+Value *LibCallSimplifier::optimizeMemCmpEq(CallInst *CI, IRBuilderBase &B) {
   return optimizeMemCmpBCmpCommon(CI, B);
 }
 
 Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilderBase &B) {
   Value *Size = CI->getArgOperand(2);
   annotateNonNullAndDereferenceable(CI, {0, 1}, Size, DL);
   if (isa<IntrinsicInst>(CI))
     return nullptr;
if (TLI->getLibFunc(*Callee, Func) && isLibFuncEmittable(M, TLI, Func)) {
     case LibFunc_strstr:
       return optimizeStrStr(CI, Builder);
     case LibFunc_memchr:
       return optimizeMemChr(CI, Builder);
     case LibFunc_memrchr:
       return optimizeMemRChr(CI, Builder);
     case LibFunc_bcmp:
       return optimizeBCmp(CI, Builder);
+    case LibFunc_memcmpeq:
+      return optimizeMemCmpEq(CI, Builder);
     case LibFunc_memcmp:
       return optimizeMemCmp(CI, Builder);
     case LibFunc_memcpy:
       return optimizeMemCpy(CI, Builder);
     case LibFunc_memccpy:
       return optimizeMemCCpy(CI, Builder);
     case LibFunc_mempcpy:
       return optimizeMemPCpy(CI, Builder);

llvm/test/Transforms/InstCombine/memcmp-1.ll

 ; Test that the memcmp library call simplifier works correctly.
 ;
 ; RUN: opt < %s -passes=instcombine -S | FileCheck --check-prefix=CHECK --check-prefix=NOBCMP %s
 ; RUN: opt < %s -passes=instcombine -mtriple=x86_64-unknown-linux-gnu -S | FileCheck --check-prefix=CHECK --check-prefix=BCMP %s
+; RUN: opt < %s -passes=instcombine --with-builtin-memcmpeq -mtriple=x86_64-unknown-linux-gnu -S | FileCheck --check-prefix=CHECK --check-prefix=MEMCMPEQ %s
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32:64"
 
 @foo = constant [4 x i8] c"foo\00"
 @hel = constant [4 x i8] c"hel\00"
 @hello_u = constant [8 x i8] c"hello_u\00"
 
 declare i32 @memcmp(i8*, i8*, i32)

 ; NOBCMP-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
 ; NOBCMP-NEXT:    ret i1 [[CMP]]
 ;
 ; BCMP-LABEL: @test_simplify10(
 ; BCMP-NEXT:    [[CALL:%.*]] = call i32 @bcmp(i8* %mem1, i8* %mem2, i32 %size)
 ; BCMP-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
 ; BCMP-NEXT:    ret i1 [[CMP]]
 ;
+; MEMCMPEQ-LABEL: @test_simplify10(
+; MEMCMPEQ-NEXT:    [[CALL:%.*]] = call i32 @__memcmpeq(i8* %mem1, i8* %mem2, i32 %size)
+; MEMCMPEQ-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
+; MEMCMPEQ-NEXT:    ret i1 [[CMP]]
+;
   %call = call i32 @memcmp(i8* %mem1, i8* %mem2, i32 %size)
   %cmp = icmp eq i32 %call, 0
   ret i1 %cmp
 }

llvm/test/Transforms/InstCombine/strcmp-1.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that the strcmp library call simplifier works correctly.
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s --check-prefix=NOBCMP
 ; RUN: opt < %s -passes=instcombine -mtriple=unknown-unknown-linux-gnu -S | FileCheck %s --check-prefix=BCMP
+; RUN: opt < %s -passes=instcombine --with-builtin-memcmpeq -mtriple=unknown-unknown-linux-gnu -S | FileCheck %s --check-prefix=MEMCMPEQ
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 
 @hello = constant [6 x i8] c"hello\00"
 @hell = constant [5 x i8] c"hell\00"
 @bell = constant [5 x i8] c"bell\00"
 @null = constant [1 x i8] zeroinitializer
 

 ; NOBCMP-NEXT:    ret i1 [[RES]]
 ;
 ; BCMP-LABEL: @test7(
 ; BCMP-NEXT:    [[STR2:%.*]] = select i1 [[B:%.*]], i8* getelementptr inbounds ([5 x i8], [5 x i8]* @hell, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @bell, i32 0, i32 0)
 ; BCMP-NEXT:    [[BCMP:%.*]] = call i32 @bcmp(i8* noundef nonnull dereferenceable(5) getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i8* noundef nonnull dereferenceable(5) [[STR2]], i32 5)
 ; BCMP-NEXT:    [[RES:%.*]] = icmp eq i32 [[BCMP]], 0
 ; BCMP-NEXT:    ret i1 [[RES]]
 ;
+; MEMCMPEQ-LABEL: @test7(
+; MEMCMPEQ-NEXT:    [[STR2:%.*]] = select i1 [[B:%.*]], i8* getelementptr inbounds ([5 x i8], [5 x i8]* @hell, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @bell, i32 0, i32 0)
+; MEMCMPEQ-NEXT:    [[MEMCMPEQ:%.*]] = call i32 @__memcmpeq(i8* noundef nonnull dereferenceable(5) getelementptr inbounds ([6 x i8], [6 x i8]* @hello, i32 0, i32 0), i8* noundef nonnull dereferenceable(5) [[STR2]], i32 5)
+; MEMCMPEQ-NEXT:    [[RES:%.*]] = icmp eq i32 [[MEMCMPEQ]], 0
+; MEMCMPEQ-NEXT:    ret i1 [[RES]]
+;
 
 
   %str1 = getelementptr inbounds [6 x i8], [6 x i8]* @hello, i32 0, i32 0
   %temp1 = getelementptr inbounds [5 x i8], [5 x i8]* @hell, i32 0, i32 0
   %temp2 = getelementptr inbounds [5 x i8], [5 x i8]* @bell, i32 0, i32 0
   %str2 = select i1 %b, i8* %temp1, i8* %temp2
   %temp3 = call i32 @strcmp(i8* %str1, i8* %str2)
   %res = icmp eq i32 %temp3, 0
   ret i1 %res
 }

llvm/unittests/Analysis/TargetLibraryInfoTest.cpp

parseAssembly(
       "declare x86_fp80 @log2l(x86_fp80)\n"
       "declare double @logb(double)\n"
       "declare float @logbf(float)\n"
       "declare x86_fp80 @logbl(x86_fp80)\n"
       "declare float @logf(float)\n"
       "declare x86_fp80 @logl(x86_fp80)\n"
       "declare i8* @malloc(i64)\n"
       "declare i8* @memccpy(i8*, i8*, i32, i64)\n"
+      "declare i8* @__memcmpeq(i8*, i8*, i64)\n"
       "declare i8* @memchr(i8*, i32, i64)\n"
       "declare i32 @memcmp(i8*, i8*, i64)\n"
       "declare i8* @memcpy(i8*, i8*, i64)\n"
       "declare i8* @memmove(i8*, i8*, i64)\n"
       "declare i8* @memset(i8*, i32, i64)\n"
       "declare void @memset_pattern16(i8*, i8*, i64)\n"
       "declare void @memset_pattern4(i8*, i8*, i64)\n"
       "declare void @memset_pattern8(i8*, i8*, i64)\n"