[WIP] [Intrinsics] Introduce memcmp intrinsics.

[dmakogon]

Summary

This is currently WIP and there is no LangRef entry for the intrinsic.
This intrinsic can be used to compare two block of memory and returns whether they are equal or not.
Please review the patch and express your concerns about this.

This patch depends on another one which changes the memory intrinsics class hierarchy.

[mkazantsev]

This comment was removed by mkazantsev.

[apilipenko]

Since this is a change to LangRef, please, post the proposal to llvm-dev.

In general this intrinsic looks reasonable and fits well with other libc intrinsics. One thing to think about is how to handle this intrinsic in the optimizer. Looks like there are plenty of places where the optimizer knows to recognize memcmp as a known libc function. For example, there are quite a few simplifications in LibCallSimplifier::optimizeMemCmp. Grep by "LibFunc_memcmp" to see other places. Do we want to canonicalize memcmp calls to the new intrinsic and teach every place to handle the intrinsic? This would make sense because we would also handle the new element atomic memcmp version this way.

[apilipenko]

I also notice that the new memcmp intrinsic returns i1, which is different from libc memcmp. libc memcmp returns and int indicating which of the sides was greater. Looks like, the new intrinsic matches with bcmp semantic.

[lebedev.ri]

This review seems to be stuck/dead, consider abandoning if no longer relevant.

llvm/include/llvm/IR/IRBuilder.h

#endif
   /// specified, it will be added to the instruction. Likewise with alias.scope
   /// and noalias tags.
   CallInst *CreateElementUnorderedAtomicMemCpy(
       Value *Dst, Align DstAlign, Value *Src, Align SrcAlign, Value *Size,
       uint32_t ElementSize, MDNode *TBAATag = nullptr,
       MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
       MDNode *NoAliasTag = nullptr);
 
+  /// Create and insert a memcmp between the specified pointers.
+  ///
+  /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
+  /// specified, it will be added to the instruction. Likewise with alias.scope
+  /// and noalias tags.
+  CallInst *CreateMemCmp(Value *LHS, MaybeAlign LHSAlign, Value *RHS,
+                         MaybeAlign RHSAlign, uint64_t Size,
+                         bool isVolatile = false, MDNode *TBAATag = nullptr,
+                         MDNode *TBAAStructTag = nullptr,
+                         MDNode *ScopeTag = nullptr,
+                         MDNode *NoAliasTag = nullptr) {
+    return CreateMemCmp(LHS, LHSAlign, RHS, RHSAlign, getInt64(Size),
+                        isVolatile, TBAATag, TBAAStructTag, ScopeTag,
+                        NoAliasTag);
+  }
+
+  CallInst *CreateMemCmp(Value *LHS, MaybeAlign LHSAlign, Value *RHS,
+                         MaybeAlign RHSAlign, Value *Size,
+                         bool isVolatile = false, MDNode *TBAATag = nullptr,
+                         MDNode *TBAAStructTag = nullptr,
+                         MDNode *ScopeTag = nullptr,
+                         MDNode *NoAliasTag = nullptr);
+
+  /// Create and insert an element unordered-atomic memcmp between the
+  /// specified pointers.
+  ///
+  /// LHSAlign/RHSAlign are the alignments of the LHS/RHS pointers, respectively.
+  ///
+  /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
+  /// specified, it will be added to the instruction. Likewise with alias.scope
+  /// and noalias tags.
+  CallInst *CreateElementUnorderedAtomicMemCmp(
+      Value *LHS, Align LHSAlign, Value *RHS, Align RHSAlign, Value *Size,
+      uint32_t ElementSize, MDNode *TBAATag = nullptr,
+      MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
+      MDNode *NoAliasTag = nullptr);
+
   CallInst *CreateMemMove(Value *Dst, MaybeAlign DstAlign, Value *Src,
                           MaybeAlign SrcAlign, uint64_t Size,
                           bool isVolatile = false, MDNode *TBAATag = nullptr,
                           MDNode *ScopeTag = nullptr,
                           MDNode *NoAliasTag = nullptr) {
     return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
                          isVolatile, TBAATag, ScopeTag, NoAliasTag);
   }

llvm/include/llvm/IR/IntrinsicInst.h

public:
 
   const Use &getValueUse() const { return BaseCL::getArgUse(ARG_VALUE); }
 
   Use &getValueUse() { return BaseCL::getArgUse(ARG_VALUE); }
 
   void setValue(Value *Val) { BaseCL::setArg(ARG_VALUE, Val); }
 };
 
+/// Common base class for all binary mem intrinsics (i.e. memcmp). Simply
+/// provides common methods.
+template <class BaseCL> class BinaryMemIntrinsicBase : public BaseCL {
+private:
+  enum { ARG_LHS = 0, ARG_RHS = 1 };
+
+public:
+  /// Return the arguments to the instruction.
+  Value *getRawLHS() const { return BaseCL::getRawArg(ARG_LHS); }
+
+  const Use &getRawLHSUse() const {
+    return BaseCL::getRawArgUse(ARG_LHS);
+  }
+
+  Use &getRawLHSUse() { return BaseCL::getRawArgUse(ARG_LHS); }
+
+  /// This is just like getRawLHS, but it strips off any cast
+  /// instructions that feed it, giving the original input.  The returned
+  /// value is guaranteed to be a pointer.
+  Value *getLHS() const { return BaseCL::getArg(ARG_LHS); }
+
+  unsigned getLHSAddressSpace() const {
+    return BaseCL::getArgAddressSpace(ARG_LHS);
+  }
+
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use getLHSAlign() instead.
+  unsigned getLHSAlignment() const {
+    return BaseCL::getArgAlignment(ARG_LHS);
+  }
+
+  MaybeAlign getLHSAlign() const { return BaseCL::getArgAlign(ARG_LHS); }
+
+  void setLHS(Value *Ptr) { BaseCL::setArg(ARG_LHS, Ptr); }
+
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use the version that takes MaybeAlign instead of this one.
+  void setLHSAlignment(unsigned Alignment) {
+    BaseCL::setArgAlignment(ARG_LHS, Alignment);
+  }
+
+  void setLHSAlignment(MaybeAlign Alignment) {
+    BaseCL::setArgAlignment(ARG_LHS, Alignment);
+  }
+
+  void setLHSAlignment(Align Alignment) {
+    BaseCL::setArgAlignment(ARG_LHS, Alignment);
+  }
+
+  /// Return the arguments to the instruction.
+  Value *getRawRHS() const { return BaseCL::getRawArg(ARG_RHS); }
+
+  const Use &getRawRHSUse() const {
+    return BaseCL::getRawArgUse(ARG_RHS);
+  }
+
+  Use &getRawRHSUse() { return BaseCL::getRawArgUse(ARG_RHS); }
+
+  /// This is just like getRawRHS, but it strips off any cast
+  /// instructions that feed it, giving the original input.  The returned
+  /// value is guaranteed to be a pointer.
+  Value *getRHS() const { return BaseCL::getArg(ARG_RHS); }
+
+  unsigned getRHSAddressSpace() const {
+    return BaseCL::getArgAddressSpace(ARG_RHS);
+  }
+
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use getRHSAlign() instead.
+  unsigned getRHSAlignment() const {
+    return BaseCL::getArgAlignment(ARG_RHS);
+  }
+
+  MaybeAlign getRHSAlign() const { return BaseCL::getArgAlign(ARG_RHS); }
+
+  void setRHS(Value *Ptr) { BaseCL::setArg(ARG_RHS, Ptr); }
+
+  /// FIXME: Remove this function once transition to Align is over.
+  /// Use the version that takes MaybeAlign instead of this one.
+  void setRHSAlignment(unsigned Alignment) {
+    BaseCL::setArgAlignment(ARG_RHS, Alignment);
+  }
+
+  void setRHSAlignment(MaybeAlign Alignment) {
+    BaseCL::setArgAlignment(ARG_RHS, Alignment);
+  }
+
+  void setRHSAlignment(Align Alignment) {
+    BaseCL::setArgAlignment(ARG_RHS, Alignment);
+  }
+};
+
 // The common base class for the atomic memset/memmove/memcpy intrinsics
 // i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
 class AtomicMemIntrinsic : public MemIntrinsicBase<AtomicMemIntrinsic> {
 private:
   enum { ARG_ELEMENTSIZE = 3 };
 
 public:
   Value *getRawElementSizeInBytes() const { return getRawArg(ARG_ELEMENTSIZE); }
 
   ConstantInt *getElementSizeInBytesCst() const {
     return cast<ConstantInt>(getRawElementSizeInBytes());
   }
 
   uint32_t getElementSizeInBytes() const {
     return getElementSizeInBytesCst()->getZExtValue();
   }
 
   void setElementSizeInBytes(Constant *V) { setArg(ARG_ELEMENTSIZE, V); }
 
   static bool classof(const IntrinsicInst *I) {
     switch (I->getIntrinsicID()) {
     case Intrinsic::memcpy_element_unordered_atomic:
     case Intrinsic::memmove_element_unordered_atomic:
     case Intrinsic::memset_element_unordered_atomic:
+    case Intrinsic::memcmp_element_unordered_atomic:
       return true;
     default:
       return false;
     }
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 };
 
+class AtomicBinaryMemIntrinsic
+    : public BinaryMemIntrinsicBase<AtomicMemIntrinsic> {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memcmp_element_unordered_atomic;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
 // The common base class for all memory write intrinsics (memcpy/memset/memmove)
 template <class BaseCL> class MemWriteIntrinsicBase : public BaseCL {
 private:
   enum { ARG_DEST = 0 };
 
 public:
   /// This is just like getRawDest, but it strips off any cast
   /// instructions (including addrspacecast) that feed it, giving the
public:
   static bool classof(const IntrinsicInst *I) {
     return I->getIntrinsicID() == Intrinsic::memmove_element_unordered_atomic;
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 };
 
+class AtomicMemCmpInst : public AtomicBinaryMemIntrinsic {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memcmp_element_unordered_atomic;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
 /// This is the common base class for memset/memcpy/memmove.
 class MemIntrinsic : public MemIntrinsicBase<MemIntrinsic> {
 private:
   enum { ARG_VOLATILE = 3 };
 
 public:
   ConstantInt *getVolatileCst() const {
     return cast<ConstantInt>(const_cast<Value *>(getArgOperand(ARG_VOLATILE)));
   }
 
   bool isVolatile() const { return !getVolatileCst()->isZero(); }
 
   void setVolatile(Constant *V) { setArgOperand(ARG_VOLATILE, V); }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const IntrinsicInst *I) {
     switch (I->getIntrinsicID()) {
     case Intrinsic::memcpy:
     case Intrinsic::memmove:
     case Intrinsic::memset:
     case Intrinsic::memcpy_inline:
+    case Intrinsic::memcmp:
       return true;
     default:
       return false;
     }
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 };
 
+class BinaryMemIntrinsic : public BinaryMemIntrinsicBase<MemIntrinsic> {
+public:
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memcmp;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
 class MemWriteIntrinsic : public MemWriteIntrinsicBase<MemIntrinsic> {
 public:
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const IntrinsicInst *I) {
     switch (I->getIntrinsicID()) {
     case Intrinsic::memcpy:
     case Intrinsic::memmove:
     case Intrinsic::memset:
public:
   static bool classof(const IntrinsicInst *I) {
     return I->getIntrinsicID() == Intrinsic::memmove;
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 };
 
+/// This class wraps the llvm.memcmp intrinsic.
+class MemCmpInst : public BinaryMemIntrinsic {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    return I->getIntrinsicID() == Intrinsic::memcmp;
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
 /// This class wraps the llvm.memcpy.inline intrinsic.
 class MemCpyInlineInst : public MemCpyInst {
 public:
   ConstantInt *getLength() const {
     return cast<ConstantInt>(MemCpyInst::getLength());
   }
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const IntrinsicInst *I) {
     return I->getIntrinsicID() == Intrinsic::memcpy_inline;
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 };
 
-// The common base class for any memset/memmove/memcpy intrinsics;
+// The common base class for any memset/memmove/memcpy/memcmp intrinsics;
 // whether they be atomic or non-atomic.
-// i.e. llvm.element.unordered.atomic.memset/memcpy/memmove
-//  and llvm.memset/memcpy/memmove
+// i.e. llvm.element.unordered.atomic.memset/memcpy/memmove/memcmp
+//  and llvm.memset/memcpy/memmove/memcmp
 class AnyMemIntrinsic : public MemIntrinsicBase<AnyMemIntrinsic> {
 public:
   bool isVolatile() const {
     // Only the non-atomic intrinsics can be volatile
     if (auto *MI = dyn_cast<MemIntrinsic>(this))
       return MI->isVolatile();
     return false;
   }
 
   static bool classof(const IntrinsicInst *I) {
     switch (I->getIntrinsicID()) {
     case Intrinsic::memcpy:
     case Intrinsic::memcpy_inline:
     case Intrinsic::memmove:
     case Intrinsic::memset:
     case Intrinsic::memcpy_element_unordered_atomic:
     case Intrinsic::memmove_element_unordered_atomic:
     case Intrinsic::memset_element_unordered_atomic:
+    case Intrinsic::memcmp:
+    case Intrinsic::memcmp_element_unordered_atomic:
+      return true;
+    default:
+      return false;
+    }
+  }
+  static bool classof(const Value *V) {
+    return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+  }
+};
+
+class AnyBinaryMemIntrinsic : public BinaryMemIntrinsicBase<AnyMemIntrinsic> {
+public:
+  static bool classof(const IntrinsicInst *I) {
+    switch (I->getIntrinsicID()) {
+    case Intrinsic::memcmp:
+    case Intrinsic::memcmp_element_unordered_atomic:
       return true;
     default:
       return false;
     }
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }

llvm/include/llvm/IR/Intrinsics.td

 def int_memset  : Intrinsic<[],
                             [llvm_anyptr_ty, llvm_i8_ty, llvm_anyint_ty,
                              llvm_i1_ty],
                             [IntrWriteMem, IntrArgMemOnly, IntrWillReturn,
                              IntrNoFree,
                              NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>,
                              ImmArg<ArgIndex<3>>]>;
 
+def int_memcmp : Intrinsic<[llvm_i1_ty],
+                 [llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty, llvm_i1_ty],
+                 [IntrReadMem, IntrArgMemOnly, IntrWillReturn, IntrNoFree,
+                  NoCapture<ArgIndex<0>>, NoCapture<ArgIndex<1>>,
+                  ReadOnly<ArgIndex<0>>, ReadOnly<ArgIndex<1>>,
+                  ImmArg<ArgIndex<3>>]>;
+
 // FIXME: Add version of these floating point intrinsics which allow non-default
 // rounding modes and FP exception handling.
 
 let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
   def int_fma  : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],
                            [LLVMMatchType<0>, LLVMMatchType<0>,
                             LLVMMatchType<0>]>;
   def int_fmuladd : DefaultAttrsIntrinsic<[llvm_anyfloat_ty],

 
 // @llvm.memset.element.unordered.atomic.*(dest, value, length, elementsize)
 def int_memset_element_unordered_atomic
     : Intrinsic<[], [llvm_anyptr_ty, llvm_i8_ty, llvm_anyint_ty, llvm_i32_ty],
                 [IntrWriteMem, IntrArgMemOnly, IntrWillReturn, IntrNoSync,
                  NoCapture<ArgIndex<0>>, WriteOnly<ArgIndex<0>>,
                  ImmArg<ArgIndex<3>>]>;
 
+// @llvm.memcmp.element.unordered.atomic.*(lhs, rhs, length, elementsize)
+def int_memcmp_element_unordered_atomic : Intrinsic<[llvm_i1_ty],
+                [llvm_anyptr_ty, llvm_anyptr_ty, llvm_anyint_ty, llvm_i32_ty],
+                [IntrReadMem, IntrArgMemOnly, IntrWillReturn, IntrNoSync,
+                 NoCapture<ArgIndex<0>>, NoCapture<ArgIndex<1>>,
+                 ReadOnly<ArgIndex<0>>, ReadOnly<ArgIndex<1>>,
+                 ImmArg<ArgIndex<3>>]>;
+
 //===------------------------ Reduction Intrinsics ------------------------===//
 //
 let IntrProperties = [IntrNoMem] in {
 
   def int_vector_reduce_fadd : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],
                                          [LLVMVectorElementType<0>,
                                           llvm_anyvector_ty]>;
   def int_vector_reduce_fmul : DefaultAttrsIntrinsic<[LLVMVectorElementType<0>],

llvm/lib/IR/IRBuilder.cpp

if (ScopeTag)
     CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
 
   if (NoAliasTag)
     CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
 
   return CI;
 }
 
+CallInst *IRBuilderBase::CreateMemCmp(Value *LHS, MaybeAlign LHSAlign,
+                                      Value *RHS, MaybeAlign RHSAlign,
+                                      Value *Size, bool isVolatile,
+                                      MDNode *TBAATag, MDNode *TBAAStructTag,
+                                      MDNode *ScopeTag, MDNode *NoAliasTag) {
+  LHS = getCastedInt8PtrValue(LHS);
+  RHS = getCastedInt8PtrValue(RHS);
+
+  Value *Ops[] = {LHS, RHS, Size, getInt1(isVolatile)};
+  Type *Tys[] = {LHS->getType(), RHS->getType(), Size->getType()};
+  Module *M = BB->getParent()->getParent();
+  Function *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memcmp, Tys);
+
+  CallInst *CI = createCallHelper(TheFn, Ops, this);
+
+  auto *MWI = cast<MemCmpInst>(CI);
+  if (LHSAlign)
+    MWI->setLHSAlignment(*LHSAlign);
+  if (RHSAlign)
+    MWI->setRHSAlignment(*RHSAlign);
+
+  // Set the TBAA info if present.
+  if (TBAATag)
+    CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
+
+  // Set the TBAA Struct info if present.
+  if (TBAAStructTag)
+    CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
+
+  if (ScopeTag)
+    CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
+
+  if (NoAliasTag)
+    CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
+
+  return CI;
+}
+
 CallInst *IRBuilderBase::CreateMemCpyInline(
     Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign,
     Value *Size, bool IsVolatile, MDNode *TBAATag, MDNode *TBAAStructTag,
     MDNode *ScopeTag, MDNode *NoAliasTag) {
   Dst = getCastedInt8PtrValue(Dst);
   Src = getCastedInt8PtrValue(Src);
 
   Value *Ops[] = {Dst, Src, Size, getInt1(IsVolatile)};
if (ScopeTag)
     CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
 
   if (NoAliasTag)
     CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
 
   return CI;
 }
 
+CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemCmp(
+    Value *LHS, Align LHSAlign, Value *RHS, Align RHSAlign, Value *Size,
+    uint32_t ElementSize, MDNode *TBAATag, MDNode *TBAAStructTag,
+    MDNode *ScopeTag, MDNode *NoAliasTag) {
+  assert(LHSAlign >= ElementSize &&
+         "Pointer alignment must be at least element size");
+  assert(RHSAlign >= ElementSize &&
+         "Pointer alignment must be at least element size");
+  LHS = getCastedInt8PtrValue(LHS);
+  RHS = getCastedInt8PtrValue(RHS);
+
+  Value *Ops[] = {LHS, RHS, Size, getInt32(ElementSize)};
+  Type *Tys[] = {LHS->getType(), RHS->getType(), Size->getType()};
+  Module *M = BB->getParent()->getParent();
+  Function *TheFn = Intrinsic::getDeclaration(
+      M, Intrinsic::memcmp_element_unordered_atomic, Tys);
+
+  dbgs() << "TheFn = " << *TheFn;
+
+  CallInst *CI = createCallHelper(TheFn, Ops, this);
+
+  // Set the alignment of the pointer args.
+  auto *AMCI = cast<AtomicMemCmpInst>(CI);
+  AMCI->setLHSAlignment(LHSAlign);
+  AMCI->setRHSAlignment(RHSAlign);
+
+  // Set the TBAA info if present.
+  if (TBAATag)
+    CI->setMetadata(LLVMContext::MD_tbaa, TBAATag);
+
+  // Set the TBAA Struct info if present.
+  if (TBAAStructTag)
+    CI->setMetadata(LLVMContext::MD_tbaa_struct, TBAAStructTag);
+
+  if (ScopeTag)
+    CI->setMetadata(LLVMContext::MD_alias_scope, ScopeTag);
+
+  if (NoAliasTag)
+    CI->setMetadata(LLVMContext::MD_noalias, NoAliasTag);
+
+  return CI;
+}
+
 CallInst *IRBuilderBase::CreateMemMove(Value *Dst, MaybeAlign DstAlign,
                                        Value *Src, MaybeAlign SrcAlign,
                                        Value *Size, bool isVolatile,
                                        MDNode *TBAATag, MDNode *ScopeTag,
                                        MDNode *NoAliasTag) {
   Dst = getCastedInt8PtrValue(Dst);
   Src = getCastedInt8PtrValue(Src);
 

llvm/lib/IR/Verifier.cpp

case Intrinsic::dbg_value: // llvm.dbg.value
     visitDbgIntrinsic("value", cast<DbgVariableIntrinsic>(Call));
     break;
   case Intrinsic::dbg_label: // llvm.dbg.label
     visitDbgLabelIntrinsic("label", cast<DbgLabelInst>(Call));
     break;
   case Intrinsic::memcpy:
   case Intrinsic::memcpy_inline:
   case Intrinsic::memmove:
+  case Intrinsic::memcmp:
   case Intrinsic::memset: {
-    const auto *MWI = cast<MemWriteIntrinsic>(&Call);
     auto IsValidAlignment = [&](unsigned Alignment) -> bool {
       return Alignment == 0 || isPowerOf2_32(Alignment);
     };
+    if (const auto *MWI = dyn_cast<MemWriteIntrinsic>(&Call)) {
       Assert(IsValidAlignment(MWI->getDestAlignment()),
              "alignment of arg 0 of memory intrinsic must be 0 or a power of 2",
              Call);
       if (const auto *MTI = dyn_cast<MemTransferInst>(MWI)) {
-      Assert(IsValidAlignment(MTI->getSourceAlignment()),
+        Assert(
+            IsValidAlignment(MTI->getSourceAlignment()),
+            "alignment of arg 1 of memory intrinsic must be 0 or a power of 2",
+            Call);
+      }
+    } else if (const auto *BMI = dyn_cast<BinaryMemIntrinsic>(&Call)) {
+      Assert(IsValidAlignment(BMI->getLHSAlignment()),
+             "alignment of arg 0 of memory intrinsic must be 0 or a power of 2",
+             Call);
+      Assert(IsValidAlignment(BMI->getRHSAlignment()),
              "alignment of arg 1 of memory intrinsic must be 0 or a power of 2",
              Call);
     }
     break;
   }
   case Intrinsic::memcpy_element_unordered_atomic:
   case Intrinsic::memmove_element_unordered_atomic:
+  case Intrinsic::memcmp_element_unordered_atomic:
   case Intrinsic::memset_element_unordered_atomic: {
-    const auto *AMWI = cast<AtomicMemWriteIntrinsic>(&Call);
+    const auto *AMI = cast<AtomicMemIntrinsic>(&Call);
 
     ConstantInt *ElementSizeCI =
-        cast<ConstantInt>(AMWI->getRawElementSizeInBytes());
+        cast<ConstantInt>(AMI->getRawElementSizeInBytes());
     const APInt &ElementSizeVal = ElementSizeCI->getValue();
     Assert(ElementSizeVal.isPowerOf2(),
            "element size of the element-wise atomic memory intrinsic "
            "must be a power of 2",
            Call);
 
     auto IsValidAlignment = [&](uint64_t Alignment) {
       return isPowerOf2_64(Alignment) && ElementSizeVal.ule(Alignment);
     };
+
+    if (const auto *AMWI = dyn_cast<AtomicMemWriteIntrinsic>(AMI)) {
       uint64_t DstAlignment = AMWI->getDestAlignment();
       Assert(IsValidAlignment(DstAlignment),
              "incorrect alignment of the destination argument", Call);
       if (const auto *AMT = dyn_cast<AtomicMemTransferInst>(AMWI)) {
         uint64_t SrcAlignment = AMT->getSourceAlignment();
         Assert(IsValidAlignment(SrcAlignment),
                "incorrect alignment of the source argument", Call);
       }
+    } else if (const auto *ABMI = dyn_cast<AtomicBinaryMemIntrinsic>(AMI)) {
+      uint64_t LHSAlignment = ABMI->getLHSAlignment();
+      Assert(IsValidAlignment(LHSAlignment),
+             "incorrect alignment of the LHS argument", Call);
+      uint64_t RHSAlignment = ABMI->getRHSAlignment();
+      Assert(IsValidAlignment(RHSAlignment),
+             "incorrect alignment of the RHS argument", Call);
+    }
     break;
   }
   case Intrinsic::call_preallocated_setup: {
     auto *NumArgs = dyn_cast<ConstantInt>(Call.getArgOperand(0));
     Assert(NumArgs != nullptr,
            "llvm.call.preallocated.setup argument must be a constant");
     bool FoundCall = false;
     for (User *U : Call.users()) {

llvm/test/Verifier/element-wise-atomic-memory-intrinsics.ll

define void @test_memset(i8* %P, i8 %V, i32 %A, i32 %E) {
   call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* %P, i8 %V, i32 1, i32 1)
   ; CHECK: incorrect alignment of the destination argument
   call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %P, i8 %V, i32 4, i32 4)
 
   ret void
 }
 declare void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* nocapture, i8, i32, i32) nounwind
 
+define void @test_memcmp(i8* %P, i8* %Q, i32 %A, i32 %E) {
+  ; CHECK: immarg operand has non-immediate parameter
+  ; CHECK: i32 %E
+  ; CHECK-NEXT: call i1 @llvm.memcmp.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 %E)
+  call i1 @llvm.memcmp.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 %E)
+
+  ; CHECK: element size of the element-wise atomic memory intrinsic must be a power of 2
+  call i1 @llvm.memcmp.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 3)
+
+  call i1 @llvm.memcmp.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 7, i32 4)
+
+  ; CHECK: incorrect alignment of the LHS argument
+  call i1 @llvm.memcmp.element.unordered.atomic.p0i8.p0i8.i32(i8* %P, i8* align 4 %Q, i32 1, i32 1)
+  ; CHECK: incorrect alignment of the LHS argument
+  call i1 @llvm.memcmp.element.unordered.atomic.p0i8.p0i8.i32(i8* align 1 %P, i8* align 4 %Q, i32 4, i32 4)
+
+  ; CHECK: incorrect alignment of the RHS argument
+  call i1 @llvm.memcmp.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* %Q, i32 1, i32 1)
+  ; CHECK: incorrect alignment of the RHS argument
+  call i1 @llvm.memcmp.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 1 %Q, i32 4, i32 4)
+
+  ret void
+}
+declare i1 @llvm.memcmp.element.unordered.atomic.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32) nounwind
+
 ; CHECK: input module is broken!