[SimplifyLibCalls] Pointers passed to libcalls must point to valid objects

[xbolva00]

Summary

Discussed some time ago here: https://reviews.llvm.org/D53342 , the conclusion was to stay conservative - assume nothing about pointers if size could be zero - and according to the previous decision, memcpy(nullptr, nullptr, 0) is fine, indeed. But is is not:

c99: 7.21.2.1 "The memcpy function copies n characters from the object pointed to by s2 into the
object pointed to by s1. If copying takes place between objects that overlap, the behavior
is undefined."

null is not a pointer to an object

So even when size is zero, pointer(s) must be valid.

Somebody may say that even if this is UB, it works in practise. Not at all:

urnathan: (For amusement value, I do know MIPS' memcpy routines segfault on memcpy (dst, nullptr, 0))

Maybe we can reevaluate previous decision now?

If this rule is broken, UBSan catches this UB without any problems, as recently shown in: https://reviews.llvm.org/D124524 / https://godbolt.org/z/qx4sK43f6

[nikic]

Looking back over https://reviews.llvm.org/D53342, the current implementation was chosen intentionally, though possibly that stance can be reevaluated now.

[efriedma]

Last time we discussed this, we specifically avoided doing this, yes. I'm still not convinced this is worth changing; the performance improvement is probably negligible. Probably worth adding a comment briefly explaining the discussion, in any case.

We shouldn't be marking dereferenceable(1). The pointer could point to the end of an array.

[xbolva00]

Probably worth adding a comment briefly explaining the discussion, in any case.

Yeah, added link to that patch and some more info about previous decision to the description.

We shouldn't be marking dereferenceable(1). The pointer could point to the end of an array.

Right, I will update it.

[msebor]

The C constraint that a pointer argument to a library function must point to an object extends beyond memcpy etc. to all standard library functions (unless otherwise specified), including for instance memchr or strncmp, regardless of the size argument. (I don't have enough background here to judge if this is something worth exploiting for optimization.)

[xbolva00]

In D124633#3481265, @msebor wrote:

The C constraint that a pointer argument to a library function must point to an object extends beyond memcpy etc. to all standard library functions (unless otherwise specified), including for instance memchr or strncmp, regardless of the size argument. (I don't have enough background here to judge if this is something worth exploiting for optimization.)

Right, libcalls with size argument (many tests are updated), memcpy was just example.
IIRC, gcc has knowledge about this fact already and assumes nonnull as well for the purpose of futher optimizations like elimination of redundant null checks after inlining.

[xbolva00]

But yeah, currently some libcalls are missed.

wip

[xbolva00]

Handle more libcalls

[urnathan]

I don't have anything to add to review, but thanks for picking this up.

[xbolva00]

ping

[msebor]

Just to confirm your understanding of what GCC does: it relies on attribute nonnull on function (and function pointer) declarations to eliminate redundant null pointer tests subsequent to calls to such functions (with -fdelete-null-pointer-checks).

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

155–157

It seems that for a bool the default ought to true rather than 1 (ditto for the actual argument at the call sites); a better name for the argument would also reflect the fact it's a toggle rather than a count.

But I wonder if changing the last argument to something like Value *MinBytes = nullptr and computing the Boolean result from it here would be a way to simplify the code and avoid having to do that at the call site.

[msebor]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

155–157

It occurs to me that since the function is also called when folding wcslen where the annotation refers to the number of wide characters, using the word byte for the argument isn't entirely accurate. It should probably be element instead (ditto in annotateDereferenceableBytes).

[xbolva00]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

155–157

It occurs to me that since the function is also called when folding wcslen

how? I see no annotateNonNullNoUndefBasedOnAccess in optimizeWcslen.

[xbolva00]

Addressed review feedback

[xbolva00]

Updated comments in tests

[msebor]

This revision looks good to me. I suggest reviewing the rest of the folders for missing annotations and adding those in a follow up patch.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

155–157

You're right, I must have been looking at the narrow character version. That seems like an oversight. I'd expect optimizeWcslen to annotate the pointer argument the same way most of the narrow functions do, wouldn't you?

Some narrow character folders like optimizeStrPBrk and optimizeStrSpn among others are also missing a call to annotateNonNullNoUndefBasedOnAccess, so they might all need updating. If so, that could be done in a followup change.

[xbolva00]

In D124633#3501083, @msebor wrote:

This revision looks good to me. I suggest reviewing the rest of the folders for missing annotations and adding those in a follow up patch.

I agree, we should not mix new annotations for new libcalls in this patch and do it as follow up.

[efriedma]

I'd like to see a Discourse thread discussing this, given it was contentious the last time it came up.

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

if (CI->getParamDereferenceableBytes(ArgNo) < DerefBytes) {
         CI->removeParamAttr(ArgNo, Attribute::DereferenceableOrNull);
       CI->addParamAttr(ArgNo, Attribute::getWithDereferenceableBytes(
                                   CI->getContext(), DerefBytes));
     }
   }
 }
 
 static void annotateNonNullNoUndefBasedOnAccess(CallInst *CI,
-                                         ArrayRef<unsigned> ArgNos) {
+                                                ArrayRef<unsigned> ArgNos,
+                                                const DataLayout &DL,
+                                                Value *Size = nullptr) {
   Function *F = CI->getCaller();
   if (!F)
     return;
 
   for (unsigned ArgNo : ArgNos) {
     if (!CI->paramHasAttr(ArgNo, Attribute::NoUndef))
       CI->addParamAttr(ArgNo, Attribute::NoUndef);
 
     if (CI->paramHasAttr(ArgNo, Attribute::NonNull))
       continue;
     unsigned AS = CI->getArgOperand(ArgNo)->getType()->getPointerAddressSpace();
     if (llvm::NullPointerIsDefined(F, AS))
       continue;
 
     CI->addParamAttr(ArgNo, Attribute::NonNull);
+    if (!Size || (Size && isKnownNonZero(Size, DL)))
       annotateDereferenceableBytes(CI, ArgNo, 1);
   }
 }
 
-static void annotateNonNullAndDereferenceable(CallInst *CI, ArrayRef<unsigned> ArgNos,
-                               Value *Size, const DataLayout &DL) {
+static void annotateNonNullAndDereferenceable(CallInst *CI,
+                                              ArrayRef<unsigned> ArgNos,
+                                              Value *Size,
+                                              const DataLayout &DL) {
+  annotateNonNullNoUndefBasedOnAccess(CI, ArgNos, DL, Size);
   if (ConstantInt *LenC = dyn_cast<ConstantInt>(Size)) {
-    annotateNonNullNoUndefBasedOnAccess(CI, ArgNos);
     annotateDereferenceableBytes(CI, ArgNos, LenC->getZExtValue());
   } else if (isKnownNonZero(Size, DL)) {
-    annotateNonNullNoUndefBasedOnAccess(CI, ArgNos);
     const APInt *X, *Y;
-    uint64_t DerefMin = 1;
-    if (match(Size, m_Select(m_Value(), m_APInt(X), m_APInt(Y)))) {
-      DerefMin = std::min(X->getZExtValue(), Y->getZExtValue());
-      annotateDereferenceableBytes(CI, ArgNos, DerefMin);
-    }
+    uint64_t MinDereferenceableBytes = 1;
+    if (match(Size, m_Select(m_Value(), m_APInt(X), m_APInt(Y))))
+      MinDereferenceableBytes = std::min(X->getZExtValue(), Y->getZExtValue());
+    annotateDereferenceableBytes(CI, ArgNos, MinDereferenceableBytes);
   }
 }
 
 // Copy CallInst "flags" like musttail, notail, and tail. Return New param for
 // easier chaining. Calls to emit* and B.createCall should probably be wrapped
 // in this function when New is created to replace Old. Callers should take
 // care to check Old.isMustTailCall() if they aren't replacing Old directly
 // with New.
 static Value *copyFlags(const CallInst &Old, Value *New) {
   assert(!Old.isMustTailCall() && "do not copy musttail call flags");
   assert(!Old.isNoTailCall() && "do not copy notail call flags");
   if (auto *NewCI = dyn_cast_or_null<CallInst>(New))
     NewCI->setTailCallKind(Old.getTailCallKind());
   return New;
 }
 
 //===----------------------------------------------------------------------===//
 // String and Memory Library Call Optimizations
 //===----------------------------------------------------------------------===//
 
 Value *LibCallSimplifier::optimizeStrCat(CallInst *CI, IRBuilderBase &B) {
   // Extract some information from the instruction
   Value *Dst = CI->getArgOperand(0);
   Value *Src = CI->getArgOperand(1);
-  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1});
+  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1}, DL);
 
   // See if we can get the length of the input string.
   uint64_t Len = GetStringLength(Src);
   if (Len)
     annotateDereferenceableBytes(CI, 1, Len);
   else
     return nullptr;
   --Len; // Unbias length.

 }
 
 Value *LibCallSimplifier::optimizeStrNCat(CallInst *CI, IRBuilderBase &B) {
   // Extract some information from the instruction.
   Value *Dst = CI->getArgOperand(0);
   Value *Src = CI->getArgOperand(1);
   Value *Size = CI->getArgOperand(2);
   uint64_t Len;
-  annotateNonNullNoUndefBasedOnAccess(CI, 0);
-  if (isKnownNonZero(Size, DL))
-    annotateNonNullNoUndefBasedOnAccess(CI, 1);
+  annotateNonNullNoUndefBasedOnAccess(CI, 0, DL);
+  annotateNonNullNoUndefBasedOnAccess(CI, 1, DL, Size);
 
   // We don't do anything if length is not constant.
   ConstantInt *LengthArg = dyn_cast<ConstantInt>(Size);
   if (LengthArg) {
     Len = LengthArg->getZExtValue();
     // strncat(x, c, 0) -> x
     if (!Len)
       return Dst;
Value *LibCallSimplifier::optimizeStrNCat(CallInst *CI, IRBuilderBase &B) {
   // s is constant so the strcat can be optimized further.
   return copyFlags(*CI, emitStrLenMemCpy(Src, Dst, SrcLen, B));
 }
 
 Value *LibCallSimplifier::optimizeStrChr(CallInst *CI, IRBuilderBase &B) {
   Function *Callee = CI->getCalledFunction();
   FunctionType *FT = Callee->getFunctionType();
   Value *SrcStr = CI->getArgOperand(0);
-  annotateNonNullNoUndefBasedOnAccess(CI, 0);
+  annotateNonNullNoUndefBasedOnAccess(CI, 0, DL);
 
   // If the second operand is non-constant, see if we can compute the length
   // of the input string and turn this into memchr.
   ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
   if (!CharC) {
     uint64_t Len = GetStringLength(SrcStr);
     if (Len)
       annotateDereferenceableBytes(CI, 0, Len);
Value *LibCallSimplifier::optimizeStrChr(CallInst *CI, IRBuilderBase &B) {
 
   // strchr(s+n,c)  -> gep(s+n+i,c)
   return B.CreateGEP(B.getInt8Ty(), SrcStr, B.getInt64(I), "strchr");
 }
 
 Value *LibCallSimplifier::optimizeStrRChr(CallInst *CI, IRBuilderBase &B) {
   Value *SrcStr = CI->getArgOperand(0);
   ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
-  annotateNonNullNoUndefBasedOnAccess(CI, 0);
+  annotateNonNullNoUndefBasedOnAccess(CI, 0, DL);
 
   // Cannot fold anything if we're not looking for a constant.
   if (!CharC)
     return nullptr;
 
   StringRef Str;
   if (!getConstantStringInfo(SrcStr, Str)) {
     // strrchr(s, 0) -> strchr(s, 0)
if (!HasStr1 && HasStr2) {
     if (canTransformToMemCmp(CI, Str2P, Len1, DL))
       return copyFlags(
           *CI,
           emitMemCmp(Str1P, Str2P,
                      ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len1),
                      B, DL, TLI));
   }
 
-  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1});
+  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1}, DL);
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeStrNCmp(CallInst *CI, IRBuilderBase &B) {
   Value *Str1P = CI->getArgOperand(0);
   Value *Str2P = CI->getArgOperand(1);
   Value *Size = CI->getArgOperand(2);
   if (Str1P == Str2P) // strncmp(x,x,n)  -> 0
     return ConstantInt::get(CI->getType(), 0);
 
-  if (isKnownNonZero(Size, DL))
-    annotateNonNullNoUndefBasedOnAccess(CI, {0, 1});
+  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1}, DL, Size);
   // Get the length argument if it is constant.
   uint64_t Length;
   if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(Size))
     Length = LengthArg->getZExtValue();
   else
     return nullptr;
 
   if (Length == 0) // strncmp(x,y,0)   -> 0
Value *LibCallSimplifier::optimizeStrNDup(CallInst *CI, IRBuilderBase &B) {
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilderBase &B) {
   Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
   if (Dst == Src) // strcpy(x,x)  -> x
     return Src;
 
-  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1});
+  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1}, DL);
   // See if we can get the length of the input string.
   uint64_t Len = GetStringLength(Src);
   if (Len)
     annotateDereferenceableBytes(CI, 1, Len);
   else
     return nullptr;
 
   // We have enough information to now generate the memcpy call to do the
Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilderBase &B) {
   return DstEnd;
 }
 
 Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilderBase &B) {
   Function *Callee = CI->getCalledFunction();
   Value *Dst = CI->getArgOperand(0);
   Value *Src = CI->getArgOperand(1);
   Value *Size = CI->getArgOperand(2);
-  annotateNonNullNoUndefBasedOnAccess(CI, 0);
-  if (isKnownNonZero(Size, DL))
-    annotateNonNullNoUndefBasedOnAccess(CI, 1);
+  annotateNonNullNoUndefBasedOnAccess(CI, 0, DL);
+  annotateNonNullNoUndefBasedOnAccess(CI, 1, DL, Size);
 
   uint64_t Len;
   if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(Size))
     Len = LengthArg->getZExtValue();
   else
     return nullptr;
 
   // strncpy(x, y, 0) -> x
Value *LibCallSimplifier::optimizeStringLength(CallInst *CI, IRBuilderBase &B,
   }
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeStrLen(CallInst *CI, IRBuilderBase &B) {
   if (Value *V = optimizeStringLength(CI, B, 8))
     return V;
-  annotateNonNullNoUndefBasedOnAccess(CI, 0);
+  annotateNonNullNoUndefBasedOnAccess(CI, 0, DL);
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeStrNLen(CallInst *CI, IRBuilderBase &B) {
   Value *Bound = CI->getArgOperand(1);
   if (Value *V = optimizeStringLength(CI, B, 8, Bound))
     return V;
 
-  if (isKnownNonZero(Bound, DL))
-    annotateNonNullNoUndefBasedOnAccess(CI, 0);
+  annotateNonNullNoUndefBasedOnAccess(CI, 0, DL, Bound);
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeWcslen(CallInst *CI, IRBuilderBase &B) {
   Module &M = *CI->getModule();
   unsigned WCharSize = TLI->getWCharSize(M) * 8;
   // We cannot perform this optimization without wchar_size metadata.
   if (WCharSize == 0)
Value *LibCallSimplifier::optimizeStrStr(CallInst *CI, IRBuilderBase &B) {
   }
 
   // fold strstr(x, "y") -> strchr(x, 'y').
   if (HasStr2 && ToFindStr.size() == 1) {
     Value *StrChr = emitStrChr(CI->getArgOperand(0), ToFindStr[0], B, TLI);
     return StrChr ? B.CreateBitCast(StrChr, CI->getType()) : nullptr;
   }
 
-  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1});
+  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1}, DL);
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeMemRChr(CallInst *CI, IRBuilderBase &B) {
   Value *SrcStr = CI->getArgOperand(0);
   Value *Size = CI->getArgOperand(2);
   annotateNonNullAndDereferenceable(CI, 0, Size, DL);
   Value *CharVal = CI->getArgOperand(1);
Value *LibCallSimplifier::optimizeMemRChr(CallInst *CI, IRBuilderBase &B) {
   }
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeMemChr(CallInst *CI, IRBuilderBase &B) {
   Value *SrcStr = CI->getArgOperand(0);
   Value *Size = CI->getArgOperand(2);
-  if (isKnownNonZero(Size, DL))
-    annotateNonNullNoUndefBasedOnAccess(CI, 0);
+  annotateNonNullNoUndefBasedOnAccess(CI, 0, DL, Size);
 
   Value *CharVal = CI->getArgOperand(1);
   ConstantInt *CharC = dyn_cast<ConstantInt>(CharVal);
   ConstantInt *LenC = dyn_cast<ConstantInt>(Size);
 
   // memchr(x, y, 0) -> null
   if (LenC) {
     if (LenC->isZero())
auto SmallPrintFFn =
         M->getOrInsertFunction(TLI->getName(LibFunc_small_printf),
                                FT, Callee->getAttributes());
     CallInst *New = cast<CallInst>(CI->clone());
     New->setCalledFunction(SmallPrintFFn);
     B.Insert(New);
     return New;
   }
 
-  annotateNonNullNoUndefBasedOnAccess(CI, 0);
+  annotateNonNullNoUndefBasedOnAccess(CI, 0, DL);
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeSPrintFString(CallInst *CI,
                                                 IRBuilderBase &B) {
   // Check for a fixed format string.
   StringRef FormatStr;
   if (!getConstantStringInfo(CI->getArgOperand(1), FormatStr))
auto SmallSPrintFFn =
         M->getOrInsertFunction(TLI->getName(LibFunc_small_sprintf),
                                FT, Callee->getAttributes());
     CallInst *New = cast<CallInst>(CI->clone());
     New->setCalledFunction(SmallSPrintFFn);
     B.Insert(New);
     return New;
   }
 
-  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1});
+  annotateNonNullNoUndefBasedOnAccess(CI, {0, 1}, DL);
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeSnPrintFString(CallInst *CI,
                                                  IRBuilderBase &B) {
   // Check for size
   ConstantInt *Size = dyn_cast<ConstantInt>(CI->getArgOperand(1));
   if (!Size)
Value *LibCallSimplifier::optimizeSnPrintFString(CallInst *CI,
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeSnPrintF(CallInst *CI, IRBuilderBase &B) {
   if (Value *V = optimizeSnPrintFString(CI, B)) {
     return V;
   }
 
-  if (isKnownNonZero(CI->getOperand(1), DL))
-    annotateNonNullNoUndefBasedOnAccess(CI, 0);
+  annotateNonNullNoUndefBasedOnAccess(CI, 0, DL, CI->getOperand(1));
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeFPrintFString(CallInst *CI,
                                                 IRBuilderBase &B) {
   optimizeErrorReporting(CI, B, 0);
 
   // All the optimizations depend on the format string.
Value *LibCallSimplifier::optimizeFPuts(CallInst *CI, IRBuilderBase &B) {
   return copyFlags(
       *CI,
       emitFWrite(CI->getArgOperand(0),
                  ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len - 1),
                  CI->getArgOperand(1), B, DL, TLI));
 }
 
 Value *LibCallSimplifier::optimizePuts(CallInst *CI, IRBuilderBase &B) {
-  annotateNonNullNoUndefBasedOnAccess(CI, 0);
+  annotateNonNullNoUndefBasedOnAccess(CI, 0, DL);
   if (!CI->use_empty())
     return nullptr;
 
   // Check for a constant string.
   // puts("") -> putchar('\n')
   StringRef Str;
   if (getConstantStringInfo(CI->getArgOperand(0), Str) && Str.empty())
     return copyFlags(*CI, emitPutChar(B.getInt32('\n'), B, TLI));

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

;
   %ret = call i32 @bcmp(i8* %mem1, i8* %mem2, i32 3)
   ret i32 %ret
 }
 
 ; Check bcmp(mem1, mem2, 8)==0 -> *(int64_t*)mem1 == *(int64_t*)mem2
 
 define i1 @test_simplify7(i64 %x, i64 %y) {
 ; CHECK-LABEL: @test_simplify7(
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i64 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    ret i1 [[TMP1]]
+; CHECK-NEXT:    [[DOTNOT:%.*]] = icmp eq i64 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret i1 [[DOTNOT]]
 ;
   %x.addr = alloca i64, align 8
   %y.addr = alloca i64, align 8
   store i64 %x, i64* %x.addr, align 8
   store i64 %y, i64* %y.addr, align 8
   %xptr = bitcast i64* %x.addr to i8*
   %yptr = bitcast i64* %y.addr to i8*
   %call = call i32 @bcmp(i8* %xptr, i8* %yptr, i32 8)
   %cmp = icmp eq i32 %call, 0
   ret i1 %cmp
 }
 
 ; Check bcmp(mem1, mem2, 4)==0 -> *(int32_t*)mem1 == *(int32_t*)mem2
 
 define i1 @test_simplify8(i32 %x, i32 %y) {
 ; CHECK-LABEL: @test_simplify8(
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    ret i1 [[TMP1]]
+; CHECK-NEXT:    [[DOTNOT:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret i1 [[DOTNOT]]
 ;
   %x.addr = alloca i32, align 4
   %y.addr = alloca i32, align 4
   store i32 %x, i32* %x.addr, align 4
   store i32 %y, i32* %y.addr, align 4
   %xptr = bitcast i32* %x.addr to i8*
   %yptr = bitcast i32* %y.addr to i8*
   %call = call i32 @bcmp(i8* %xptr, i8* %yptr, i32 4)
   %cmp = icmp eq i32 %call, 0
   ret i1 %cmp
 }
 
 ; Check bcmp(mem1, mem2, 2)==0 -> *(int16_t*)mem1 == *(int16_t*)mem2
 
 define i1 @test_simplify9(i16 %x, i16 %y) {
 ; CHECK-LABEL: @test_simplify9(
-; CHECK-NEXT:    [[TMP1:%.*]] = icmp eq i16 [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    ret i1 [[TMP1]]
+; CHECK-NEXT:    [[DOTNOT:%.*]] = icmp eq i16 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret i1 [[DOTNOT]]
 ;
   %x.addr = alloca i16, align 2
   %y.addr = alloca i16, align 2
   store i16 %x, i16* %x.addr, align 2
   store i16 %y, i16* %y.addr, align 2
   %xptr = bitcast i16* %x.addr to i8*
   %yptr = bitcast i16* %y.addr to i8*
   %call = call i32 @bcmp(i8* %xptr, i8* %yptr, i32 2)
   %cmp = icmp eq i32 %call, 0
   ret i1 %cmp
 }
 
 define i1 @test_simplify10(i8* %mem1, i8* %mem2, i32 %size) {
 ; CHECK-LABEL: @test_simplify10(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @bcmp(i8* [[MEM1:%.*]], i8* [[MEM2:%.*]], i32 [[SIZE:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @bcmp(i8* noundef nonnull [[MEM1:%.*]], i8* noundef nonnull [[MEM2:%.*]], i32 [[SIZE:%.*]])
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
   %call = call i32 @bcmp(i8* %mem1, i8* %mem2, i32 %size)
   %cmp = icmp eq i32 %call, 0
   ret i1 %cmp
 }

llvm/test/Transforms/InstCombine/bcopy.ll

 ; CHECK-NEXT:    ret void
 ;
   tail call void @bcopy(i8* %a, i8* %b, i32 8)
   ret void
 }
 
 define void @bcopy_memmove2(i8* nocapture readonly %a, i8* nocapture %b, i32 %len) {
 ; CHECK-LABEL: @bcopy_memmove2(
-; CHECK-NEXT:    call void @llvm.memmove.p0i8.p0i8.i32(i8* align 1 [[B:%.*]], i8* align 1 [[A:%.*]], i32 [[LEN:%.*]], i1 false)
+; CHECK-NEXT:    tail call void @llvm.memmove.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[B:%.*]], i8* noundef nonnull align 1 [[A:%.*]], i32 [[LEN:%.*]], i1 false)
 ; CHECK-NEXT:    ret void
 ;
   tail call void @bcopy(i8* %a, i8* %b, i32 %len)
   ret void
 }

llvm/test/Transforms/InstCombine/mem-deref-bytes-addrspaces.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instcombine  -S < %s | FileCheck %s
 
 declare i32 @memcmp(i8 addrspace(1)* nocapture, i8* nocapture, i64)
 
 define i32 @memcmp_const_size_update_deref(i8 addrspace(1)* nocapture readonly %d, i8* nocapture readonly %s) {
 ; CHECK-LABEL: @memcmp_const_size_update_deref(
 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(i8 addrspace(1)* noundef dereferenceable(16) dereferenceable_or_null(40) [[D:%.*]], i8* noundef nonnull dereferenceable(16) [[S:%.*]], i64 16)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(i8 addrspace(1)* dereferenceable_or_null(40) %d, i8* %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_nonconst_size_nonnnull(i8 addrspace(1)* nocapture readonly %d, i8* nocapture readonly %s, i64 %n) {
 ; CHECK-LABEL: @memcmp_nonconst_size_nonnnull(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(i8 addrspace(1)* nonnull dereferenceable_or_null(40) [[D:%.*]], i8* nonnull [[S:%.*]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(i8 addrspace(1)* noundef nonnull dereferenceable_or_null(40) [[D:%.*]], i8* noundef nonnull [[S:%.*]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(i8 addrspace(1)* nonnull dereferenceable_or_null(40) %d, i8* nonnull %s, i64 %n)
   ret i32 %call
 }

llvm/test/Transforms/InstCombine/mem-deref-bytes.ll

 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(i8* dereferenceable(40) %d, i8* dereferenceable(20) %s, i64 16)
   ret i32 %call
 }
 
 define i32 @memcmp_nonconst_size(i8* nocapture readonly %d, i8* nocapture readonly %s, i64 %n) {
 ; CHECK-LABEL: @memcmp_nonconst_size(
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(i8* [[D:%.*]], i8* [[S:%.*]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i32 @memcmp(i8* noundef nonnull [[D:%.*]], i8* noundef nonnull [[S:%.*]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(i8* %d, i8* %s, i64 %n)
   ret i32 %call
 }
 
 define i8* @memcpy_const_size_set_deref(i8* nocapture readonly %d, i8* nocapture readonly %s) {
 ; CHECK-LABEL: @memcpy_const_size_set_deref(

llvm/test/Transforms/InstCombine/memchr-2.ll

;
   ret i8* %res
 }
 
 
 ; Do no fold memchr(ax, 1, n).
 
 define i8* @call_ax_1_n(i64 %n) {
 ; CHECK-LABEL: @call_ax_1_n(
-; CHECK-NEXT:    [[RES:%.*]] = call i8* @memchr(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i32 1, i64 [[N:%.*]])
+; CHECK-NEXT:    [[RES:%.*]] = call i8* @memchr(i8* noundef nonnull getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i32 1, i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RES]]
 ;
 
   %ptr = getelementptr [0 x i8], [0 x i8]* @ax, i32 0, i32 0
   %res = call i8* @memchr(i8* %ptr, i32 1, i64 %n)
   ret i8* %res
 }

llvm/test/Transforms/InstCombine/memchr.ll

 ; CHECK-NEXT:    ret i8* getelementptr inbounds ([1 x i8], [1 x i8]* @s, i32 0, i32 0)
 ;
   %res = tail call i8* @memchr(i8* getelementptr ([1 x i8], [1 x i8]* @s, i64 0, i64 0), i32 0, i32 1)
   ret i8* %res
 }
 
 define i8* @test16(i8* %str, i32 %c, i32 %n) {
 ; CHECK-LABEL: @test16(
-; CHECK-NEXT:    [[RET:%.*]] = call i8* @memchr(i8* [[STR:%.*]], i32 [[C:%.*]], i32 [[N:%.*]])
+; CHECK-NEXT:    [[RET:%.*]] = call i8* @memchr(i8* noundef nonnull [[STR:%.*]], i32 [[C:%.*]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
 
   %ret = call i8* @memchr(i8* %str, i32 %c, i32 %n)
   ret i8* %ret
 }
 
 define i8* @test17(i8* %str, i32 %c, i32 %n) {
 ; CHECK-LABEL: @test17(
-; CHECK-NEXT:    [[RET:%.*]] = call i8* @memchr(i8* nonnull [[STR:%.*]], i32 [[C:%.*]], i32 [[N:%.*]])
+; CHECK-NEXT:    [[RET:%.*]] = call i8* @memchr(i8* noundef nonnull [[STR:%.*]], i32 [[C:%.*]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
 
   %ret = call i8* @memchr(i8* nonnull %str, i32 %c, i32 %n)
   ret i8* %ret
 }
 
 define i8* @test18(i8* %str, i32 %c) {

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

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; 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
 
 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"
;
   %ret = call i32 @memcmp(i8* %mem1, i8* %mem2, i32 0)
   ret i32 %ret
 }
 
 ;; Check memcmp(mem1, mem2, 1) -> *(unsigned char*)mem1 - *(unsigned char*)mem2.
 
 define i32 @test_simplify3(i8* %mem1, i8* %mem2) {
 ; CHECK-LABEL: @test_simplify3(
-; CHECK-NEXT:    [[LHSC:%.*]] = load i8, i8* %mem1, align 1
+; CHECK-NEXT:    [[LHSC:%.*]] = load i8, i8* [[MEM1:%.*]], align 1
 ; CHECK-NEXT:    [[LHSV:%.*]] = zext i8 [[LHSC]] to i32
-; CHECK-NEXT:    [[RHSC:%.*]] = load i8, i8* %mem2, align 1
+; CHECK-NEXT:    [[RHSC:%.*]] = load i8, i8* [[MEM2:%.*]], align 1
 ; CHECK-NEXT:    [[RHSV:%.*]] = zext i8 [[RHSC]] to i32
 ; CHECK-NEXT:    [[CHARDIFF:%.*]] = sub nsw i32 [[LHSV]], [[RHSV]]
 ; CHECK-NEXT:    ret i32 [[CHARDIFF]]
 ;
   %ret = call i32 @memcmp(i8* %mem1, i8* %mem2, i32 1)
   ret i32 %ret
 }
 
;
   %ret = call i32 @memcmp(i8* %mem1, i8* %mem2, i32 3)
   ret i32 %ret
 }
 
 ; Check memcmp(mem1, mem2, 8)==0 -> *(int64_t*)mem1 == *(int64_t*)mem2
 
 define i1 @test_simplify7(i64 %x, i64 %y) {
 ; CHECK-LABEL: @test_simplify7(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i64 %x, %y
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    [[DOTNOT:%.*]] = icmp eq i64 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret i1 [[DOTNOT]]
 ;
   %x.addr = alloca i64, align 8
   %y.addr = alloca i64, align 8
   store i64 %x, i64* %x.addr, align 8
   store i64 %y, i64* %y.addr, align 8
   %xptr = bitcast i64* %x.addr to i8*
   %yptr = bitcast i64* %y.addr to i8*
   %call = call i32 @memcmp(i8* %xptr, i8* %yptr, i32 8)
   %cmp = icmp eq i32 %call, 0
   ret i1 %cmp
 }
 
 ; Check memcmp(mem1, mem2, 4)==0 -> *(int32_t*)mem1 == *(int32_t*)mem2
 
 define i1 @test_simplify8(i32 %x, i32 %y) {
 ; CHECK-LABEL: @test_simplify8(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 %x, %y
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    [[DOTNOT:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret i1 [[DOTNOT]]
 ;
   %x.addr = alloca i32, align 4
   %y.addr = alloca i32, align 4
   store i32 %x, i32* %x.addr, align 4
   store i32 %y, i32* %y.addr, align 4
   %xptr = bitcast i32* %x.addr to i8*
   %yptr = bitcast i32* %y.addr to i8*
   %call = call i32 @memcmp(i8* %xptr, i8* %yptr, i32 4)
   %cmp = icmp eq i32 %call, 0
   ret i1 %cmp
 }
 
 ; Check memcmp(mem1, mem2, 2)==0 -> *(int16_t*)mem1 == *(int16_t*)mem2
 
 define i1 @test_simplify9(i16 %x, i16 %y) {
 ; CHECK-LABEL: @test_simplify9(
-; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i16 %x, %y
-; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK-NEXT:    [[DOTNOT:%.*]] = icmp eq i16 [[X:%.*]], [[Y:%.*]]
+; CHECK-NEXT:    ret i1 [[DOTNOT]]
 ;
   %x.addr = alloca i16, align 2
   %y.addr = alloca i16, align 2
   store i16 %x, i16* %x.addr, align 2
   store i16 %y, i16* %y.addr, align 2
   %xptr = bitcast i16* %x.addr to i8*
   %yptr = bitcast i16* %y.addr to i8*
   %call = call i32 @memcmp(i8* %xptr, i8* %yptr, i32 2)
   %cmp = icmp eq i32 %call, 0
   ret i1 %cmp
 }
 
 ; Check memcmp(mem1, mem2, size)==0 -> bcmp(mem1, mem2, size)==0
 
 define i1 @test_simplify10(i8* %mem1, i8* %mem2, i32 %size) {
 ; NOBCMP-LABEL: @test_simplify10(
-; NOBCMP-NEXT:    [[CALL:%.*]] = call i32 @memcmp(i8* %mem1, i8* %mem2, i32 %size)
+; NOBCMP-NEXT:    [[CALL:%.*]] = call i32 @memcmp(i8* noundef nonnull [[MEM1:%.*]], i8* noundef nonnull [[MEM2:%.*]], i32 [[SIZE:%.*]])
 ; 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:    [[BCMP:%.*]] = call i32 @bcmp(i8* noundef nonnull [[MEM1:%.*]], i8* noundef nonnull [[MEM2:%.*]], i32 [[SIZE:%.*]])
+; BCMP-NEXT:    [[CMP:%.*]] = icmp eq i32 [[BCMP]], 0
 ; BCMP-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/memcpy-1.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that the memcpy library call simplifier works correctly.
 ;
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %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"
 
 declare i8* @memcpy(i8*, i8*, i32)
 
 ; Check memcpy(mem1, mem2, size) -> llvm.memcpy(mem1, mem2, size, 1).
 
 define i8* @test_simplify1(i8* %mem1, i8* %mem2, i32 %size) {
 ; CHECK-LABEL: @test_simplify1(
-; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[MEM1:%.*]], i8* align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[MEM1:%.*]], i8* noundef nonnull align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[MEM1]]
 ;
   %ret = call i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size)
   ret i8* %ret
 }
 
 ; Verify that the strictfp attr doesn't block this optimization.
 
 define i8* @test_simplify2(i8* %mem1, i8* %mem2, i32 %size) strictfp {
 ; CHECK-LABEL: @test_simplify2(
-; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[MEM1:%.*]], i8* align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false) #[[ATTR0:[0-9]+]]
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[MEM1:%.*]], i8* noundef nonnull align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false) #[[ATTR0:[0-9]+]]
 ; CHECK-NEXT:    ret i8* [[MEM1]]
 ;
   %ret = call i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size) strictfp
   ret i8* %ret
 }
 
 ; Verify that the first parameter to memcpy could itself be a call that's not
 ; tail, while the call to @memcpy could be tail.
 declare i8* @get_dest()
 
 define i8* @test_simplify3(i8* %mem2, i32 %size) {
 ; CHECK-LABEL: @test_simplify3(
 ; CHECK-NEXT:    [[DEST:%.*]] = call i8* @get_dest()
-; CHECK-NEXT:    tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[DEST]], i8* align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
+; CHECK-NEXT:    tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[DEST]], i8* noundef nonnull align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[DEST]]
 ;
 
   %dest = call i8* @get_dest()
   %ret = tail call i8* @memcpy(i8* %dest, i8* %mem2, i32 %size)
   ret i8* %ret
 }
 
 define i8* @test_no_incompatible_attr(i8* %mem1, i8* %mem2, i32 %size) {
 ; CHECK-LABEL: @test_no_incompatible_attr(
-; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[MEM1:%.*]], i8* align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[MEM1:%.*]], i8* noundef nonnull align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[MEM1]]
 ;
 
   %ret = call dereferenceable(1) i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size)
   ret i8* %ret
 }
 
 define i8* @test_no_simplify1(i8* %mem1, i8* %mem2, i32 %size) {
 ; CHECK-LABEL: @test_no_simplify1(
 ; CHECK-NEXT:    [[RET:%.*]] = musttail call i8* @memcpy(i8* [[MEM1:%.*]], i8* [[MEM2:%.*]], i32 [[SIZE:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
   %ret = musttail call i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size)
   ret i8* %ret
 }

llvm/test/Transforms/InstCombine/memcpy-2.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that the memcpy library call simplifier works correctly.
 ;
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %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"
 
 declare i8 @memcpy(i8*, i8*, i32)
 
 ; Check that memcpy functions with the wrong prototype (doesn't return a pointer) aren't simplified.
 
 define i8 @test_no_simplify1(i8* %mem1, i8* %mem2, i32 %size) {
 ; CHECK-LABEL: @test_no_simplify1(
-; CHECK-NEXT:    [[RET:%.*]] = call i8 @memcpy(i8* %mem1, i8* %mem2, i32 %size)
+; CHECK-NEXT:    [[RET:%.*]] = call i8 @memcpy(i8* [[MEM1:%.*]], i8* [[MEM2:%.*]], i32 [[SIZE:%.*]])
 ; CHECK-NEXT:    ret i8 [[RET]]
 ;
   %ret = call i8 @memcpy(i8* %mem1, i8* %mem2, i32 %size)
   ret i8 %ret
 }

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

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that the memmove library call simplifier works correctly.
 ;
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %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"
 
 declare i8* @memmove(i8*, i8*, i32)
 
 ; Check memmove(mem1, mem2, size) -> llvm.memmove(mem1, mem2, size, 1).
 
 define i8* @test_simplify1(i8* %mem1, i8* %mem2, i32 %size) {
 ; CHECK-LABEL: @test_simplify1(
+; CHECK-NEXT:    call void @llvm.memmove.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[MEM1:%.*]], i8* noundef nonnull align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
+; CHECK-NEXT:    ret i8* [[MEM1]]
+;
   %ret = call i8* @memmove(i8* %mem1, i8* %mem2, i32 %size)
-; CHECK: call void @llvm.memmove
   ret i8* %ret
-; CHECK: ret i8* %mem1
 }
 
 define i8* @test_simplify2(i8* %mem1, i8* %mem2, i32 %size) {
 ; CHECK-LABEL: @test_simplify2(
-; CHECK-NEXT:   tail call void @llvm.memmove
-; CHECK-NEXT:   ret i8* %mem1
+; CHECK-NEXT:    tail call void @llvm.memmove.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[MEM1:%.*]], i8* noundef nonnull align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
+; CHECK-NEXT:    ret i8* [[MEM1]]
+;
   %ret = tail call i8* @memmove(i8* %mem1, i8* %mem2, i32 %size)
   ret i8* %ret
 }
 
 define i8* @test_no_simplify1(i8* %mem1, i8* %mem2, i32 %size) {
 ; CHECK-LABEL: @test_no_simplify1(
-; CHECK-NEXT:   %ret = musttail call i8* @memmove(i8* %mem1, i8* %mem2, i32 %size)
-; CHECK-NEXT:   ret i8* %ret
+; CHECK-NEXT:    [[RET:%.*]] = musttail call i8* @memmove(i8* [[MEM1:%.*]], i8* [[MEM2:%.*]], i32 [[SIZE:%.*]])
+; CHECK-NEXT:    ret i8* [[RET]]
+;
   %ret = musttail call i8* @memmove(i8* %mem1, i8* %mem2, i32 %size)
   ret i8* %ret
 }
 
 define i8* @test_no_incompatible_attr(i8* %mem1, i8* %mem2, i32 %size) {
 ; CHECK-LABEL: @test_no_incompatible_attr(
+; CHECK-NEXT:    call void @llvm.memmove.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[MEM1:%.*]], i8* noundef nonnull align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
+; CHECK-NEXT:    ret i8* [[MEM1]]
+;
   %ret = call dereferenceable(1) i8* @memmove(i8* %mem1, i8* %mem2, i32 %size)
-; CHECK: call void @llvm.memmove
   ret i8* %ret
-; CHECK: ret i8* %mem1
 }

llvm/test/Transforms/InstCombine/memmove.ll

 ;
   call void @llvm.memmove.p0i8.p0i8.i32(i8* %A, i8* %B, i32 0, i1 false)
   ret void
 }
 
 define void @test2(i8* %A, i32 %N) {
   ;; dest can't alias source since we can't write to source!
 ; CHECK-LABEL: @test2(
-; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[A:%.*]], i8* align 16 getelementptr inbounds ([33 x i8], [33 x i8]* @S, i64 0, i64 0), i32 [[N:%.*]], i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[A:%.*]], i8* noundef nonnull align 16 getelementptr inbounds ([33 x i8], [33 x i8]* @S, i64 0, i64 0), i32 [[N:%.*]], i1 false)
 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.memmove.p0i8.p0i8.i32(i8* %A, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @S, i32 0, i32 0), i32 %N, i1 false)
   ret void
 }
 
 define i32 @test3([1024 x i8]* %target) { ; arg: [1024 x i8]*> [#uses=1]
 ; CHECK-LABEL: @test3(

llvm/test/Transforms/InstCombine/mempcpy.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=instcombine -S < %s | FileCheck %s
 
 define i8* @memcpy_nonconst_n(i8* %d, i8* nocapture readonly %s, i64 %n) {
 ; CHECK-LABEL: @memcpy_nonconst_n(
-; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 [[D:%.*]], i8* align 1 [[S:%.*]], i64 [[N:%.*]], i1 false)
+; CHECK-NEXT:    tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 1 [[D:%.*]], i8* noundef nonnull align 1 [[S:%.*]], i64 [[N:%.*]], i1 false)
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[D]], i64 [[N]]
 ; CHECK-NEXT:    ret i8* [[TMP1]]
 ;
   %r = tail call i8* @mempcpy(i8* %d, i8* %s, i64 %n)
   ret i8* %r
 }
 
 define i8* @memcpy_nonconst_n_copy_attrs(i8* %d, i8* nocapture readonly %s, i64 %n) {
 ; CHECK-LABEL: @memcpy_nonconst_n_copy_attrs(
-; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(16) [[D:%.*]], i8* align 1 [[S:%.*]], i64 [[N:%.*]], i1 false)
+; CHECK-NEXT:    tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 1 dereferenceable(16) [[D:%.*]], i8* noundef nonnull align 1 [[S:%.*]], i64 [[N:%.*]], i1 false)
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[D]], i64 [[N]]
 ; CHECK-NEXT:    ret i8* [[TMP1]]
 ;
   %r = tail call i8* @mempcpy(i8* dereferenceable(16) %d, i8* %s, i64 %n)
   ret i8* %r
 }
 
 define void @memcpy_nonconst_n_unused_retval(i8* %d, i8* nocapture readonly %s, i64 %n) {
 ; CHECK-LABEL: @memcpy_nonconst_n_unused_retval(
-; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 [[D:%.*]], i8* align 1 [[S:%.*]], i64 [[N:%.*]], i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 1 [[D:%.*]], i8* noundef nonnull align 1 [[S:%.*]], i64 [[N:%.*]], i1 false)
 ; CHECK-NEXT:    ret void
 ;
   call i8* @mempcpy(i8* %d, i8* %s, i64 %n)
   ret void
 }
 
 define i8* @memcpy_small_const_n(i8* %d, i8* nocapture readonly %s) {
 ; CHECK-LABEL: @memcpy_small_const_n(
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[S:%.*]] to i64*
 ; CHECK-NEXT:    [[TMP2:%.*]] = bitcast i8* [[D:%.*]] to i64*
 ; CHECK-NEXT:    [[TMP3:%.*]] = load i64, i64* [[TMP1]], align 1
 ; CHECK-NEXT:    store i64 [[TMP3]], i64* [[TMP2]], align 1
 ; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr inbounds i8, i8* [[D]], i64 8
 ; CHECK-NEXT:    ret i8* [[TMP4]]
 ;
   %r = tail call i8* @mempcpy(i8* %d, i8* %s, i64 8)
   ret i8* %r
 }
 
 define i8* @memcpy_big_const_n(i8* %d, i8* nocapture readonly %s) {
 ; CHECK-LABEL: @memcpy_big_const_n(
-; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 1 dereferenceable(1024) [[D:%.*]], i8* noundef nonnull align 1 dereferenceable(1024) [[S:%.*]], i64 1024, i1 false)
+; CHECK-NEXT:    tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 1 dereferenceable(1024) [[D:%.*]], i8* noundef nonnull align 1 dereferenceable(1024) [[S:%.*]], i64 1024, i1 false)
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[D]], i64 1024
 ; CHECK-NEXT:    ret i8* [[TMP1]]
 ;
   %r = tail call i8* @mempcpy(i8* %d, i8* %s, i64 1024)
   ret i8* %r
 }
 
 ; The original call may have attributes that can not propagate to memcpy.
 
 define i32 @PR48810() {
 ; CHECK-LABEL: @PR48810(
-; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 undef, i8* align 4294967296 null, i64 undef, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 1 undef, i8* noundef nonnull align 4294967296 null, i64 undef, i1 false)
 ; CHECK-NEXT:    ret i32 undef
 ;
   %r = call dereferenceable(1) i8* @mempcpy(i8* undef, i8* null, i64 undef)
   ret i32 undef
 }
 
 define i8* @memcpy_no_simplify1(i8* %d, i8* nocapture readonly %s, i64 %n) {
 ; CHECK-LABEL: @memcpy_no_simplify1(
-; CHECK-NEXT:    %r = musttail call i8* @mempcpy(i8* %d, i8* %s, i64 %n)
-; CHECK-NEXT:    ret i8* %r
+; CHECK-NEXT:    [[R:%.*]] = musttail call i8* @mempcpy(i8* [[D:%.*]], i8* [[S:%.*]], i64 [[N:%.*]])
+; CHECK-NEXT:    ret i8* [[R]]
 ;
   %r = musttail call i8* @mempcpy(i8* %d, i8* %s, i64 %n)
   ret i8* %r
 }
 
 declare i8* @mempcpy(i8*, i8* nocapture readonly, i64)

llvm/test/Transforms/InstCombine/memrchr-3.ll

;
   ret i8* %ret
 }
 
 
 ; Fold memrchr(a12345, 3, n) to n < 3 ? null : s + 2.
 
 define i8* @fold_memrchr_a12345_3_n(i64 %n) {
 ; CHECK-LABEL: @fold_memrchr_a12345_3_n(
-; CHECK-NEXT:    [[RET:%.*]] = call i8* @memrchr(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @a12345, i64 0, i64 0), i32 3, i64 [[N:%.*]])
+; CHECK-NEXT:    [[RET:%.*]] = call i8* @memrchr(i8* noundef nonnull getelementptr inbounds ([5 x i8], [5 x i8]* @a12345, i64 0, i64 0), i32 3, i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
 
   %ptr = getelementptr [5 x i8], [5 x i8]* @a12345, i32 0, i32 0
   %ret = call i8* @memrchr(i8* %ptr, i32 3, i64 %n)
   ret i8* %ret
 }
 
 
 ; Fold memrchr(a12345, 5, n) to n < 5 ? null : s + 4.
 
 define i8* @fold_memrchr_a12345_5_n(i64 %n) {
 ; CHECK-LABEL: @fold_memrchr_a12345_5_n(
-; CHECK-NEXT:    [[RET:%.*]] = call i8* @memrchr(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @a12345, i64 0, i64 0), i32 5, i64 [[N:%.*]])
+; CHECK-NEXT:    [[RET:%.*]] = call i8* @memrchr(i8* noundef nonnull getelementptr inbounds ([5 x i8], [5 x i8]* @a12345, i64 0, i64 0), i32 5, i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
 
   %ptr = getelementptr [5 x i8], [5 x i8]* @a12345, i32 0, i32 0
   %ret = call i8* @memrchr(i8* %ptr, i32 5, i64 %n)
   ret i8* %ret
 }
 

 
 
 ; Don't fold memrchr(a123123, 3, n) (although it's possible to fold the call
 ; for a small number of occurrences of the character greater than one, it's
 ; less and less profitable as the number grows).
 
 define i8* @call_memrchr_a123123_3_n(i64 %n) {
 ; CHECK-LABEL: @call_memrchr_a123123_3_n(
-; CHECK-NEXT:    [[RET:%.*]] = call i8* @memrchr(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @a123123, i64 0, i64 0), i32 3, i64 [[N:%.*]])
+; CHECK-NEXT:    [[RET:%.*]] = call i8* @memrchr(i8* noundef nonnull getelementptr inbounds ([6 x i8], [6 x i8]* @a123123, i64 0, i64 0), i32 3, i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
 
   %ptr = getelementptr [6 x i8], [6 x i8]* @a123123, i32 0, i32 0
   %ret = call i8* @memrchr(i8* %ptr, i32 3, i64 %n)
   ret i8* %ret
 }
 
 
 ; Same as above but for 2.
 
 define i8* @call_memrchr_a123123_2_n(i64 %n) {
 ; CHECK-LABEL: @call_memrchr_a123123_2_n(
-; CHECK-NEXT:    [[RET:%.*]] = call i8* @memrchr(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @a123123, i64 0, i64 0), i32 2, i64 [[N:%.*]])
+; CHECK-NEXT:    [[RET:%.*]] = call i8* @memrchr(i8* noundef nonnull getelementptr inbounds ([6 x i8], [6 x i8]* @a123123, i64 0, i64 0), i32 2, i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
 
   %ptr = getelementptr [6 x i8], [6 x i8]* @a123123, i32 0, i32 0
   %ret = call i8* @memrchr(i8* %ptr, i32 2, i64 %n)
   ret i8* %ret
 }

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Test that the memset library call simplifier works correctly.
 ;
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %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"
 
 declare i8* @memset(i8*, i32, i32)
 declare void @llvm.memset.p0i8.i32(i8* nocapture writeonly, i8, i32, i32, i1)
 declare noalias i8* @malloc(i32) #1
 
 ; Check memset(mem1, val, size) -> llvm.memset(mem1, val, size, 1).
 
 define i8* @test_simplify1(i8* %mem, i32 %val, i32 %size) {
 ; CHECK-LABEL: @test_simplify1(
 ; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[VAL:%.*]] to i8
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[MEM]]
 ;
   %ret = call i8* @memset(i8* %mem, i32 %val, i32 %size)
   ret i8* %ret
 }
 
 define i8* @test_simplify1_tail(i8* %mem, i32 %val, i32 %size) {
 ; CHECK-LABEL: @test_simplify1_tail(
 ; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[VAL:%.*]] to i8
-; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* align 1 [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[MEM]]
 ;
   %ret = tail call i8* @memset(i8* %mem, i32 %val, i32 %size)
   ret i8* %ret
 }
 
 define i8* @test_simplify1_musttail(i8* %mem, i32 %val, i32 %size) {
 ; CHECK-LABEL: @test_simplify1_musttail(
-; CHECK-NEXT:    %ret = musttail call i8* @memset(i8* %mem, i32 %val, i32 %size)
-; CHECK-NEXT:    ret i8* %ret
+; CHECK-NEXT:    [[RET:%.*]] = musttail call i8* @memset(i8* [[MEM:%.*]], i32 [[VAL:%.*]], i32 [[SIZE:%.*]])
+; CHECK-NEXT:    ret i8* [[RET]]
 ;
   %ret = musttail call i8* @memset(i8* %mem, i32 %val, i32 %size)
   ret i8* %ret
 }
 
 ; Malloc + memset pattern is now handled by DSE in a more general way.
 
 define i8* @pr25892_lite(i32 %size) #0 {
 ; CHECK-LABEL: @pr25892_lite(
-; CHECK-NEXT:    [[CALL:%.*]] = call i8* @malloc(i32 [[SIZE:%.*]])
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[CALL]], i8 0, i32 [[SIZE]], i1 false)
+; CHECK-NEXT:    [[CALL1:%.*]] = call i8* @malloc(i32 [[SIZE:%.*]]) #[[ATTR0:[0-9]+]]
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[CALL1]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
+; CHECK-NEXT:    ret i8* [[CALL1]]
 ;
   %call1 = call i8* @malloc(i32 %size) #1
   %call2 = call i8* @memset(i8* %call1, i32 0, i32 %size) #1
   ret i8* %call2
 }
 
 ; A memset intrinsic should be handled similarly to a memset() libcall.
 ; Notice that malloc + memset pattern is now handled by DSE in a more general way.
 
 define i8* @malloc_and_memset_intrinsic(i32 %n) #0 {
 ; CHECK-LABEL: @malloc_and_memset_intrinsic(
 ; CHECK-NEXT:    [[CALL:%.*]] = call i8* @malloc(i32 [[N:%.*]])
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[CALL]], i8 0, i32 [[N]], i1 false)
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[CALL]], i8 0, i32 [[N]], i1 false)
 ; CHECK-NEXT:    ret i8* [[CALL]]
 ;
   %call = call i8* @malloc(i32 %n)
   call void @llvm.memset.p0i8.i32(i8* %call, i8 0, i32 %n, i32 1, i1 false)
   ret i8* %call
 }
 
 ; This should not create a calloc and should not crash the compiler.
 ; Notice that malloc + memset pattern is now handled by DSE in a more general way.
 
 define i8* @notmalloc_memset(i32 %size, i8*(i32)* %notmalloc) {
 ; CHECK-LABEL: @notmalloc_memset(
-; CHECK-NEXT:    [[CALL1:%.*]] = call i8* [[NOTMALLOC:%.*]](i32 [[SIZE:%.*]]) [[ATTR0:#.*]]
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[CALL1]], i8 0, i32 [[SIZE]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    [[CALL1:%.*]] = call i8* [[NOTMALLOC:%.*]](i32 [[SIZE:%.*]]) #[[ATTR0]]
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[CALL1]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[CALL1]]
 ;
   %call1 = call i8* %notmalloc(i32 %size) #1
   %call2 = call i8* @memset(i8* %call1, i32 0, i32 %size) #1
   ret i8* %call2
 }
 
 ; This doesn't fire currently because the malloc has more than one use.
 ; Notice that malloc + memset pattern is now handled by DSE in a more general way.
 
 define float* @pr25892(i32 %size) #0 {
 ; CHECK-LABEL: @pr25892(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @malloc(i32 [[SIZE:%.*]]) [[ATTR0]]
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @malloc(i32 [[SIZE:%.*]]) #[[ATTR0]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8* [[CALL]], null
 ; CHECK-NEXT:    br i1 [[CMP]], label [[CLEANUP:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.end:
 ; CHECK-NEXT:    [[BC:%.*]] = bitcast i8* [[CALL]] to float*
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* nonnull align 1 [[CALL]], i8 0, i32 [[SIZE]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[CALL]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    br label [[CLEANUP]]
 ; CHECK:       cleanup:
 ; CHECK-NEXT:    [[RETVAL_0:%.*]] = phi float* [ [[BC]], [[IF_END]] ], [ null, [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    ret float* [[RETVAL_0]]
 ;
 entry:
   %call = tail call i8* @malloc(i32 %size) #1
   %cmp = icmp eq i8* %call, null
   br i1 %cmp, label %cleanup, label %if.end
 if.end:
   %bc = bitcast i8* %call to float*
   %call2 = tail call i8* @memset(i8* nonnull %call, i32 0, i32 %size) #1
   br label %cleanup
 cleanup:
   %retval.0 = phi float* [ %bc, %if.end ], [ null, %entry ]
   ret float* %retval.0
 }
 
 ; If there's a calloc transform, the store must also be eliminated.
 
 define i8* @buffer_is_modified_then_memset(i32 %size) {
 ; CHECK-LABEL: @buffer_is_modified_then_memset(
-; CHECK-NEXT:    [[PTR:%.*]] = tail call i8* @malloc(i32 [[SIZE:%.*]]) [[ATTR0]]
+; CHECK-NEXT:    [[PTR:%.*]] = tail call i8* @malloc(i32 [[SIZE:%.*]]) #[[ATTR0]]
 ; CHECK-NEXT:    store i8 1, i8* [[PTR]], align 1
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* nonnull align 1 [[PTR]], i8 0, i32 [[SIZE]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[PTR]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %ptr = tail call i8* @malloc(i32 %size) #1
   store i8 1, i8* %ptr           ;; fdata[0] = 1;
   %memset = tail call i8* @memset(i8* nonnull %ptr, i32 0, i32 %size) #1
   ret i8* %memset
 }
 
 define i8* @memset_size_select(i1 %b, i8* %ptr) {
 ; CHECK-LABEL: @memset_size_select(
 ; CHECK-NEXT:    [[SIZE:%.*]] = select i1 [[B:%.*]], i32 10, i32 50
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(10) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(10) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %size = select i1 %b, i32 10, i32 50
   %memset = tail call i8* @memset(i8* nonnull %ptr, i32 0, i32 %size) #1
   ret i8* %memset
 }
 
 
 define i8* @memset_size_select2(i1 %b, i8* %ptr) {
 ; CHECK-LABEL: @memset_size_select2(
 ; CHECK-NEXT:    [[SIZE:%.*]] = select i1 [[B:%.*]], i32 10, i32 50
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(80) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(80) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %size = select i1 %b, i32 10, i32 50
   %memset = tail call i8* @memset(i8* nonnull dereferenceable(80) %ptr, i32 0, i32 %size) #1
   ret i8* %memset
 }
 
 define i8* @memset_size_select3(i1 %b, i8* %ptr) {
 ; CHECK-LABEL: @memset_size_select3(
 ; CHECK-NEXT:    [[SIZE:%.*]] = select i1 [[B:%.*]], i32 10, i32 50
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(40) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false)
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(40) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false)
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %size = select i1 %b, i32 10, i32 50
   %memset = tail call i8* @memset(i8* dereferenceable_or_null(40) %ptr, i32 0, i32 %size)
   ret i8* %memset
 }
 
 define i8* @memset_size_select4(i1 %b, i8* %ptr) {
 ; CHECK-LABEL: @memset_size_select4(
 ; CHECK-NEXT:    [[SIZE:%.*]] = select i1 [[B:%.*]], i32 10, i32 50
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(40) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(40) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %size = select i1 %b, i32 10, i32 50
   %memset = tail call i8* @memset(i8* nonnull dereferenceable_or_null(40) %ptr, i32 0, i32 %size) #1
   ret i8* %memset
 }
 
 define i8* @memset_size_ashr(i1 %b, i8* %ptr, i32 %v) {
 ; CHECK-LABEL: @memset_size_ashr(
 ; CHECK-NEXT:    [[SIZE:%.*]] = ashr i32 -2, [[V:%.*]]
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(1) [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %size = ashr i32 -2, %v
   %memset = tail call i8* @memset(i8* nonnull %ptr, i32 0, i32 %size) #1
   ret i8* %memset
 }
 
 define i8* @memset_attrs1(i1 %b, i8* %ptr, i32 %size) {
 ; CHECK-LABEL: @memset_attrs1(
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 dereferenceable_or_null(40) [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable_or_null(40) [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %memset = tail call i8* @memset(i8* dereferenceable_or_null(40) %ptr, i32 0, i32 %size) #1
   ret i8* %memset
 }
 
-; be sure to drop nonnull since size is unknown and can be 0
 ; do not change dereferenceable attribute
 define i8* @memset_attrs2(i1 %b, i8* %ptr, i32 %size) {
 ; CHECK-LABEL: @memset_attrs2(
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* nonnull align 1 dereferenceable(40) [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(40) [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %memset = tail call i8* @memset(i8* nonnull dereferenceable(40) %ptr, i32 0, i32 %size) #1
   ret i8* %memset
 }
 
-; size is unknown, just copy attrs, no changes in attrs
 define i8* @memset_attrs3(i1 %b, i8* %ptr, i32 %size) {
 ; CHECK-LABEL: @memset_attrs3(
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* nonnull align 1 dereferenceable_or_null(40) [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 dereferenceable_or_null(40) [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %memset = tail call i8* @memset(i8* nonnull dereferenceable_or_null(40) %ptr, i32 0, i32 %size) #1
   ret i8* %memset
 }
 
 ; be sure to drop nonnull since size is unknown and can be 0
 define i8* @memset_attrs4(i1 %b, i8* %ptr, i32 %size) {
 ; CHECK-LABEL: @memset_attrs4(
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* nonnull align 1 [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) [[ATTR0]]
+; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[PTR:%.*]], i8 0, i32 [[SIZE:%.*]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %memset = tail call i8* @memset(i8* nonnull %ptr, i32 0, i32 %size) #1
   ret i8* %memset
 }
 
 define i8* @test_no_incompatible_attr(i8* %mem, i32 %val, i32 %size) {
 ; CHECK-LABEL: @test_no_incompatible_attr(
 ; CHECK-NEXT:    [[TMP1:%.*]] = trunc i32 [[VAL:%.*]] to i8
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[MEM]]
 ;
   %ret = call dereferenceable(1) i8* @memset(i8* %mem, i32 %val, i32 %size)
   ret i8* %ret
 }
 
 attributes #0 = { nounwind ssp uwtable }
 attributes #1 = { nounwind }
 attributes #2 = { nounwind readnone }
 

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

;
   %dst = bitcast %struct.T* @t to i8*
 
   %ret = call i8* @__memset_chk(i8* %dst, i32 0, i64 1824, i64 0)
   ret i8* %ret
 }
 
 define i8* @test_no_simplify3(i8* %dst, i32 %a, i64 %b, i64 %c) {
 ; CHECK-LABEL: @test_no_simplify3(
-; CHECK-NEXT:    %ret = musttail call i8* @__memset_chk(i8* %dst, i32 0, i64 1824, i64 1824)
-; CHECK-NEXT:    ret i8* %ret
+; CHECK-NEXT:    [[RET:%.*]] = musttail call i8* @__memset_chk(i8* [[DST:%.*]], i32 0, i64 1824, i64 1824)
+; CHECK-NEXT:    ret i8* [[RET]]
 ;
   %ret = musttail call i8* @__memset_chk(i8* %dst, i32 0, i64 1824, i64 1824)
   ret i8* %ret
 }
 
 
 ; Test that RAUW in SimplifyLibCalls for __memset_chk generates valid IR
 define i32 @test_rauw(i8* %a, i8* %b, i8** %c) {
 ; CHECK-LABEL: @test_rauw(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CALL49:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) [[A:%.*]])
 ; CHECK-NEXT:    [[ADD180:%.*]] = add i64 [[CALL49]], 1
 ; CHECK-NEXT:    [[YO107:%.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* [[B:%.*]], i1 false, i1 false, i1 false)
 ; CHECK-NEXT:    [[CALL50:%.*]] = call i8* @__memmove_chk(i8* [[B]], i8* [[A]], i64 [[ADD180]], i64 [[YO107]])
 ; CHECK-NEXT:    [[STRLEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) [[B]])
 ; CHECK-NEXT:    [[STRCHR1:%.*]] = getelementptr i8, i8* [[B]], i64 [[STRLEN]]
 ; CHECK-NEXT:    [[D:%.*]] = load i8*, i8** [[C:%.*]], align 8
 ; CHECK-NEXT:    [[SUB182:%.*]] = ptrtoint i8* [[D]] to i64
 ; CHECK-NEXT:    [[SUB183:%.*]] = ptrtoint i8* [[B]] to i64
 ; CHECK-NEXT:    [[SUB184:%.*]] = sub i64 [[SUB182]], [[SUB183]]
 ; CHECK-NEXT:    [[ADD52_I_I:%.*]] = add nsw i64 [[SUB184]], 1
-; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* align 1 [[STRCHR1]], i8 0, i64 [[ADD52_I_I]], i1 false)
+; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* noundef nonnull align 1 [[STRCHR1]], i8 0, i64 [[ADD52_I_I]], i1 false)
 ; CHECK-NEXT:    ret i32 4
 ;
 entry:
   %call49 = call i64 @strlen(i8* %a)
   %add180 = add i64 %call49, 1
   %yo107 = call i64 @llvm.objectsize.i64.p0i8(i8* %b, i1 false, i1 false, i1 false)
   %call50 = call i8* @__memmove_chk(i8* %b, i8* %a, i64 %add180, i64 %yo107)
   %call51i = call i8* @strrchr(i8* %b, i32 0)

 
 declare i8* @__memset_chk(i8*, i32, i64, i64)
 
 ; FIXME: memset(malloc(x), 0, x) -> calloc(1, x)
 
 define float* @pr25892(i64 %size) #0 {
 ; CHECK-LABEL: @pr25892(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @malloc(i64 [[SIZE:%.*]]) [[ATTR3:#.*]]
+; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @malloc(i64 [[SIZE:%.*]]) #[[ATTR3:[0-9]+]]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8* [[CALL]], null
 ; CHECK-NEXT:    br i1 [[CMP]], label [[CLEANUP:%.*]], label [[IF_END:%.*]]
 ; CHECK:       if.end:
 ; CHECK-NEXT:    [[BC:%.*]] = bitcast i8* [[CALL]] to float*
 ; CHECK-NEXT:    [[CALL2:%.*]] = tail call i64 @llvm.objectsize.i64.p0i8(i8* nonnull [[CALL]], i1 false, i1 false, i1 false)
-; CHECK-NEXT:    [[CALL3:%.*]] = tail call i8* @__memset_chk(i8* nonnull [[CALL]], i32 0, i64 [[SIZE]], i64 [[CALL2]]) [[ATTR3]]
+; CHECK-NEXT:    [[CALL3:%.*]] = tail call i8* @__memset_chk(i8* nonnull [[CALL]], i32 0, i64 [[SIZE]], i64 [[CALL2]]) #[[ATTR3]]
 ; CHECK-NEXT:    br label [[CLEANUP]]
 ; CHECK:       cleanup:
 ; CHECK-NEXT:    [[RETVAL_0:%.*]] = phi float* [ [[BC]], [[IF_END]] ], [ null, [[ENTRY:%.*]] ]
 ; CHECK-NEXT:    ret float* [[RETVAL_0]]
 ;
 entry:
   %call = tail call i8* @malloc(i64 %size) #1
   %cmp = icmp eq i8* %call, null

llvm/test/Transforms/InstCombine/snprintf.ll

 ; CHECK-LABEL: @test_not_const_fmt(
 ; CHECK-NEXT:    [[CALL:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* noundef nonnull dereferenceable(1) [[BUF:%.*]], i64 32, i8* [[FMT:%.*]])
 ; CHECK-NEXT:    ret void
 ;
   %call = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %buf, i64 32, i8* %fmt) #2
   ret void
 }
 
-; size is '0', do not add nonnull attribute
+; size is '0', do not add dereferenceable attribute
 define void @test_not_const_fmt_zero_size_return_value(i8* %buf, i8* %fmt) #0 {
 ; CHECK-LABEL: @test_not_const_fmt_zero_size_return_value(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* [[BUF:%.*]], i64 0, i8* [[FMT:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* noundef nonnull [[BUF:%.*]], i64 0, i8* [[FMT:%.*]])
 ; CHECK-NEXT:    ret void
 ;
   %call = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %buf, i64 0, i8* %fmt) #2
   ret void
 }
 
 define void @test_not_const_size(i8* %buf, i64 %size) #0 {
 ; CHECK-LABEL: @test_not_const_size(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* [[BUF:%.*]], i64 [[SIZE:%.*]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* noundef nonnull [[BUF:%.*]], i64 [[SIZE:%.*]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
 ; CHECK-NEXT:    ret void
 ;
   %call = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %buf, i64 %size, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0)) #2
   ret void
 }
 
 
 define i32 @test_return_value(i8* %buf) #0 {

 ; CHECK-NEXT:    ret i32 3
 ;
   %call = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0)) #2
   ret i32 %call
 }
 
 define i32 @test_percentage_return_value() #0 {
 ; CHECK-LABEL: @test_percentage_return_value(
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 (i8*, i64, i8*, ...) @snprintf(i8* noundef nonnull null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0)) #3
   ret i32 %call
 }
 
 
 define void @test_correct_copy(i8* %buf) #0 {

 ;
   %call = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %buf, i64 32, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0)) #2
   ret i32 %call
 }
 
 ; snprintf(buf, 32, "") -> memcpy -> store
 define i32 @test_str_ok_size_tail(i8* %buf) {
 ; CHECK-LABEL: @test_str_ok_size_tail(
-; CHECK-NEXT:    store i8 0, i8* %buf, align 1
+; CHECK-NEXT:    store i8 0, i8* [[BUF:%.*]], align 1
 ; CHECK-NEXT:    ret i32 0
 ;
   %1 = tail call i32 (i8*, i64, i8*, ...) @snprintf(i8* %buf, i64 8, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i64 0, i64 0))
   ret i32 %1
 }
 
 define i32 @test_str_ok_size_musttail(i8* %buf, i64 %x, i8* %y, ...) {
 ; CHECK-LABEL: @test_str_ok_size_musttail(
-; CHECK-NEXT:    %1 = musttail call i32 (i8*, i64, i8*, ...) @snprintf(i8* %buf, i64 8, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i64 0, i64 0), ...)
-; CHECK-NEXT:    ret i32 %1
+; CHECK-NEXT:    [[TMP1:%.*]] = musttail call i32 (i8*, i64, i8*, ...) @snprintf(i8* [[BUF:%.*]], i64 8, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i64 0, i64 0), ...)
+; CHECK-NEXT:    ret i32 [[TMP1]]
 ;
   %1 = musttail call i32 (i8*, i64, i8*, ...) @snprintf(i8* %buf, i64 8, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.4, i64 0, i64 0), ...)
   ret i32 %1
 }
 
 ; snprintf(buf, 32, "%s", "str") -> memcpy -> store
 define i32 @test_str_ok_size_tail2(i8* %buf) {
 ; CHECK-LABEL: @test_str_ok_size_tail2(
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i8* [[BUF:%.*]] to i32*
 ; CHECK-NEXT:    store i32 7500915, i32* [[TMP1]], align 1
 ; CHECK-NEXT:    ret i32 3
 ;
   %1 = tail call i32 (i8*, i64, i8*, ...) @snprintf(i8* %buf, i64 8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
   ret i32 %1
 }
 
 define i32 @test_str_ok_size_musttail2(i8* %buf, i64 %x, i8* %y, ...) {
 ; CHECK-LABEL: @test_str_ok_size_musttail2(
-; CHECK-NEXT:    %1 = musttail call i32 (i8*, i64, i8*, ...) @snprintf(i8* %buf, i64 8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), ...)
-; CHECK-NEXT:    ret i32 %1
+; CHECK-NEXT:    [[TMP1:%.*]] = musttail call i32 (i8*, i64, i8*, ...) @snprintf(i8* [[BUF:%.*]], i64 8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), ...)
+; CHECK-NEXT:    ret i32 [[TMP1]]
 ;
   %1 = musttail call i32 (i8*, i64, i8*, ...) @snprintf(i8* %buf, i64 8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), ...)
   ret i32 %1
 }

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

 ; WITHSTPCPY-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[STPCPY]] to i32
 ; WITHSTPCPY-NEXT:    [[TMP2:%.*]] = ptrtoint i8* [[DST]] to i32
 ; WITHSTPCPY-NEXT:    [[TMP3:%.*]] = sub i32 [[TMP1]], [[TMP2]]
 ; WITHSTPCPY-NEXT:    ret i32 [[TMP3]]
 ;
 ; NOSTPCPY-LABEL: @test_simplify7(
 ; NOSTPCPY-NEXT:    [[STRLEN:%.*]] = call i32 @strlen(i8* noundef nonnull dereferenceable(1) [[STR:%.*]])
 ; NOSTPCPY-NEXT:    [[LENINC:%.*]] = add i32 [[STRLEN]], 1
-; NOSTPCPY-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[DST:%.*]], i8* align 1 [[STR]], i32 [[LENINC]], i1 false)
+; NOSTPCPY-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[DST:%.*]], i8* noundef nonnull align 1 [[STR]], i32 [[LENINC]], i1 false) 
 ; NOSTPCPY-NEXT:    ret i32 [[STRLEN]]
 ;
   %fmt = getelementptr [3 x i8], [3 x i8]* @percent_s, i32 0, i32 0
   %r = call i32 (i8*, i8*, ...) @sprintf(i8* %dst, i8* %fmt, i8* %str)
   ret i32 %r
 }
 
 ; Check sprintf(dst, "%s", str) -> llvm.memcpy(dest, str, strlen(str) + 1, 1).

 ; CHECK-IPRINTF-NEXT:    [[TMP1:%.*]] = ptrtoint i8* [[STPCPY]] to i32
 ; CHECK-IPRINTF-NEXT:    [[TMP2:%.*]] = ptrtoint i8* [[DST]] to i32
 ; CHECK-IPRINTF-NEXT:    [[TMP3:%.*]] = sub i32 [[TMP1]], [[TMP2]]
 ; CHECK-IPRINTF-NEXT:    ret i32 [[TMP3]]
 ;
 ; WIN-LABEL: @test_simplify9(
 ; WIN-NEXT:    [[STRLEN:%.*]] = call i32 @strlen(i8* noundef nonnull dereferenceable(1) [[STR:%.*]])
 ; WIN-NEXT:    [[LENINC:%.*]] = add i32 [[STRLEN]], 1
-; WIN-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[DST:%.*]], i8* align 1 [[STR]], i32 [[LENINC]], i1 false)
+; WIN-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* noundef nonnull align 1 [[DST:%.*]], i8* noundef nonnull align 1 [[STR]], i32 [[LENINC]], i1 false) 
 ; WIN-NEXT:    ret i32 [[STRLEN]]
 ;
   %fmt = getelementptr [3 x i8], [3 x i8]* @percent_s, i32 0, i32 0
   %r = call i32 (i8*, i8*, ...) @sprintf(i8* %dst, i8* %fmt, i8* %str)
   ret i32 %r
 }
 
 define void @test_no_simplify1(i8* %dst) {

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

;
   %cmp = icmp slt i32 %call, 3
   %conv = zext i1 %cmp to i32
   ret i32 %conv
 }
 
 define i32 @strncmp_memcmp_bad2([12 x i8]* dereferenceable (12) %buf, i64 %n) nofree nosync {
 ; CHECK-LABEL: @strncmp_memcmp_bad2(
 ; CHECK-NEXT:    [[STRING:%.*]] = getelementptr inbounds [12 x i8], [12 x i8]* [[BUF:%.*]], i64 0, i64 0
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strncmp(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @key, i64 0, i64 0), i8* nonnull [[STRING]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @strncmp(i8* noundef nonnull getelementptr inbounds ([4 x i8], [4 x i8]* @key, i64 0, i64 0), i8* noundef nonnull [[STRING]], i64 [[N:%.*]])
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32 [[CALL]], 1
 ; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
 ; CHECK-NEXT:    ret i32 [[CONV]]
 ;
   %string = getelementptr inbounds [12 x i8], [12 x i8]* %buf, i64 0, i64 0
   %call = call i32 @strncmp(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @key, i64 0, i64 0), i8* nonnull %string, i64 %n)
   %cmp = icmp slt i32 %call, 1
   %conv = zext i1 %cmp to i32

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

;
   %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
 
   %ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 60)
   ret i8* %ret
 }
 
 define i8* @test_simplify1_tail() {
 ; CHECK-LABEL: @test_simplify1_tail(
-; CHECK-NEXT:    call void @llvm.memcpy.p0i8.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noundef nonnull align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false)
+; CHECK-NEXT:    tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* noundef nonnull align 1 dereferenceable(12) getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i8* noundef nonnull align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i32 0, i32 0), i32 12, i1 false)
 ; CHECK-NEXT:    ret i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0)
 ;
   %dst = getelementptr inbounds [60 x i8], [60 x i8]* @a, i32 0, i32 0
   %src = getelementptr inbounds [12 x i8], [12 x i8]* @.str, i32 0, i32 0
 
   %ret = tail call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 60)
   ret i8* %ret
 }
;
   %src = getelementptr inbounds [60 x i8], [60 x i8]* @b, i32 0, i32 0
 
   %ret = call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 8)
   ret i8* %ret
 }
 
 define i8* @test_no_simplify2(i8* %dst, i8* %src, i32 %a) {
 ; CHECK-LABEL: @test_no_simplify2(
-; CHECK-NEXT:    %ret = musttail call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 60)
-; CHECK-NEXT:    ret i8* %ret
+; CHECK-NEXT:    [[RET:%.*]] = musttail call i8* @__strcpy_chk(i8* [[DST:%.*]], i8* [[SRC:%.*]], i32 60)
+; CHECK-NEXT:    ret i8* [[RET]]
 ;
   %ret = musttail call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 60)
   ret i8* %ret
 }
 
 declare i8* @__strcpy_chk(i8*, i8*, i32) nounwind
 declare i32 @llvm.objectsize.i32.p0i8(i8*, i1, i1, i1) nounwind readonly

llvm/test/Transforms/InstCombine/strncat-2.ll

 ;
 
   %dst = getelementptr [32 x i8], [32 x i8]* @a, i32 0, i32 0
   %src = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0
   call i8* @strncat(i8* %dst, i8* %src, i32 1)
   ret void
 }
 
-; strncat(nonnull x, nonnull y, n)  -> strncat(nonnull x, y, n)
+; strncat(nonnull x, nonnull y, n)  -> strncat(nonnull noundef x, nonnull noundef y, n)
 define i8* @test1(i8* %str1, i8* %str2, i32 %n) {
 ; CHECK-LABEL: @test1(
-; CHECK-NEXT:    [[TEMP1:%.*]] = call i8* @strncat(i8* noundef nonnull [[STR1:%.*]], i8* nonnull [[STR2:%.*]], i32 [[N:%.*]])
+; CHECK-NEXT:    [[TEMP1:%.*]] = call i8* @strncat(i8* noundef nonnull [[STR1:%.*]], i8* noundef nonnull [[STR2:%.*]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[TEMP1]]
 ;
 
   %temp1 = call i8* @strncat(i8* nonnull %str1, i8* nonnull %str2, i32 %n)
   ret i8* %temp1
 }
 
 ; strncat(x, y, 0)  -> x

 ;
 
   %temp1 = call i8* @strncat(i8* %str1, i8* %str2, i32 5)
   ret i8* %temp1
 }
 
 define i8* @test4(i8* %str1, i8* %str2, i32 %n) null_pointer_is_valid {
 ; CHECK-LABEL: @test4(
-; CHECK-NEXT:    [[TEMP1:%.*]] = call i8* @strncat(i8* noundef [[STR1:%.*]], i8* [[STR2:%.*]], i32 [[N:%.*]])
+; CHECK-NEXT:    [[TEMP1:%.*]] = call i8* @strncat(i8* noundef [[STR1:%.*]], i8* noundef [[STR2:%.*]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[TEMP1]]
 ;
 
   %temp1 = call i8* @strncat(i8* %str1, i8* %str2, i32 %n)
   ret i8* %temp1
 }
 
 define i8* @test5(i8* %str, i32 %n) {

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

 ; CHECK-LABEL: @test8(
 ; CHECK-NEXT:    ret i32 0
 ;
 
   %temp1 = call i32 @strncmp(i8* %str, i8* %str, i32 %n)
   ret i32 %temp1
 }
 
-; strncmp(nonnull x, nonnull y, n)  -> strncmp(x, y, n)
+; strncmp(nonnull x, nonnull y, n)  -> strncmp(nonnull noundef x, nonnull noundef y, n)
 define i32 @test9(i8* %str1, i8* %str2, i32 %n) {
 ; CHECK-LABEL: @test9(
-; CHECK-NEXT:    [[TEMP1:%.*]] = call i32 @strncmp(i8* nonnull [[STR1:%.*]], i8* nonnull [[STR2:%.*]], i32 [[N:%.*]])
+; CHECK-NEXT:    [[TEMP1:%.*]] = call i32 @strncmp(i8* noundef nonnull [[STR1:%.*]], i8* noundef nonnull [[STR2:%.*]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret i32 [[TEMP1]]
 ;
 
   %temp1 = call i32 @strncmp(i8* nonnull %str1, i8* nonnull %str2, i32 %n)
   ret i32 %temp1
 }
 
 ; strncmp(nonnull x, nonnull y, 0)  -> 0

 ;
 
   %temp1 = call i32 @strncmp(i8* %str1, i8* %str2, i32 5)
   ret i32 %temp1
 }
 
 define i32 @test12(i8* %str1, i8* %str2, i32 %n) null_pointer_is_valid {
 ; CHECK-LABEL: @test12(
-; CHECK-NEXT:    [[TEMP1:%.*]] = call i32 @strncmp(i8* [[STR1:%.*]], i8* [[STR2:%.*]], i32 [[N:%.*]])
+; CHECK-NEXT:    [[TEMP1:%.*]] = call i32 @strncmp(i8* noundef [[STR1:%.*]], i8* noundef [[STR2:%.*]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret i32 [[TEMP1]]
 ;
 
   %temp1 = call i32 @strncmp(i8* %str1, i8* %str2, i32 %n)
   ret i32 %temp1
 }

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

 ;
   %src = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0
   call i8* @strncpy(i8* dereferenceable(80) %dst, i8* %src, i32 32)
   ret void
 }
 
 define void @test_simplify7(i8* %dst, i32 %n) {
 ; CHECK-LABEL: @test_simplify7(
-; CHECK-NEXT:    [[TMP1:%.*]] = call i8* @strncpy(i8* noundef nonnull dereferenceable(80) [[DST:%.*]], i8* getelementptr inbounds ([1 x i8], [1 x i8]* @null, i32 0, i32 0), i32 [[N:%.*]])
+; CHECK-NEXT:    [[TMP1:%.*]] = call i8* @strncpy(i8* noundef nonnull dereferenceable(80) [[DST:%.*]], i8* noundef nonnull getelementptr inbounds ([1 x i8], [1 x i8]* @null, i32 0, i32 0), i32 [[N:%.*]])
 ; CHECK-NEXT:    ret void
 ;
   %src = getelementptr [1 x i8], [1 x i8]* @null, i32 0, i32 0
   call i8* @strncpy(i8* dereferenceable(80) %dst, i8* %src, i32 %n)
   ret void
 }
 
 define i8* @test1(i8* %dst, i8* %src, i32 %n) {
 ; CHECK-LABEL: @test1(
-; CHECK-NEXT:    [[RET:%.*]] = call i8* @strncpy(i8* noundef nonnull [[DST:%.*]], i8* nonnull [[SRC:%.*]], i32 [[N:%.*]])
+; CHECK-NEXT:    [[RET:%.*]] = call i8* @strncpy(i8* noundef nonnull [[DST:%.*]], i8* noundef nonnull [[SRC:%.*]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
   %ret = call i8* @strncpy(i8* nonnull %dst, i8* nonnull %src, i32 %n)
   ret i8* %ret
 }
 
 define i8* @test2(i8* %dst) {
 ; CHECK-LABEL: @test2(
;
   %src = getelementptr [6 x i8], [6 x i8]* @hello, i32 0, i32 0
 
   call i8* @strncpy(i8* %dst, i8* %src, i32 8)
   ret void
 }
 
 define i8* @test_no_simplify3(i8* %dst, i8* %src, i32 %count) {
 ; CHECK-LABEL: @test_no_simplify3(
-; CHECK-NEXT:    %ret = musttail call i8* @strncpy(i8* %dst, i8* %src, i32 32)
-; CHECK-NEXT:    ret i8* %ret
+; CHECK-NEXT:    [[RET:%.*]] = musttail call i8* @strncpy(i8* [[DST:%.*]], i8* [[SRC:%.*]], i32 32)
+; CHECK-NEXT:    ret i8* [[RET]]
 ;
   %ret = musttail call i8* @strncpy(i8* %dst, i8* %src, i32 32)
   ret i8* %ret
 }
 
 define i8* @test_no_simplify4(i8* %dst, i8* %src, i32 %count) {
 ; CHECK-LABEL: @test_no_simplify4(
-; CHECK-NEXT:    %ret = musttail call i8* @strncpy(i8* %dst, i8* %src, i32 6)
-; CHECK-NEXT:    ret i8* %ret
+; CHECK-NEXT:    [[RET:%.*]] = musttail call i8* @strncpy(i8* [[DST:%.*]], i8* [[SRC:%.*]], i32 6)
+; CHECK-NEXT:    ret i8* [[RET]]
 ;
   %ret = musttail call i8* @strncpy(i8* %dst, i8* %src, i32 6)
   ret i8* %ret
 }
 
 
 define void @test_no_incompatible_attr() {
 ; CHECK-LABEL: @test_no_incompatible_attr(

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

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; Verify that strnlen calls with constant string arguments and offsets
 ; and constant bounds are folded correctly.
 ;
 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s
 
 declare i64 @strnlen(i8*, i64)
 
 @ax = external global [0 x i8]
 @s5 = constant [6 x i8] c"12345\00"
 @s5_3 = constant [9 x i8] c"12345\00xyz"
 
 
-; Verify that the strnlen pointer argument is not annotated nonnull when
+; Verify that the strnlen pointer argument is not annotated dereferenceable when
 ; nothing is known about the bound.
 
 define i64 @no_access_strnlen_p_n(i8* %ptr, i64 %n) {
 ; CHECK-LABEL: @no_access_strnlen_p_n(
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR:%.*]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR:%.*]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
   %len = call i64 @strnlen(i8* %ptr, i64 %n)
   ret i64 %len
 }
 
 
 ; Verify that the strnlen pointer argument is annotated dereferenceable(1)

 }
 
 
 ; Fold strnlen(ax, 1) to *ax ? 1 : 0.
 
 define i64 @fold_strnlen_ax_1() {
 ; CHECK-LABEL: @fold_strnlen_ax_1(
 ; CHECK-NEXT:    [[STRNLEN_CHAR0:%.*]] = load i8, i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), align 1
-; CHECK-NEXT:    [[STRNLEN_CHAR0CMP_NOT:%.*]] = icmp ne i8 [[STRNLEN_CHAR0]], 0
-; CHECK-NEXT:    [[STRNLEN_SEL:%.*]] = zext i1 [[STRNLEN_CHAR0CMP_NOT]] to i64
-; CHECK-NEXT:    ret i64 [[STRNLEN_SEL]]
+; CHECK-NEXT:    [[STRNLEN_CHAR0CMP:%.*]] = icmp ne i8 [[STRNLEN_CHAR0]], 0
+; CHECK-NEXT:    [[TMP1:%.*]] = zext i1 [[STRNLEN_CHAR0CMP]] to i64
+; CHECK-NEXT:    ret i64 [[TMP1]]
 ;
   %ptr = getelementptr [0 x i8], [0 x i8]* @ax, i32 0, i32 0
   %len = call i64 @strnlen(i8* %ptr, i64 1)
   ret i64 %len
 }
 
 
 ; Fold strnlen(s5, 0) to 0.

llvm/test/Transforms/InstCombine/strnlen-3.ll

 }
 
 
 ; Do not fold strnlen(sx + i, n).
 
 define i64 @call_strnlen_sx_pi_n(i64 %i, i64 %n) {
 ; CHECK-LABEL: @call_strnlen_sx_pi_n(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [0 x i8], [0 x i8]* @sx, i64 0, i64 [[I:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 
   %ptr = getelementptr inbounds [0 x i8], [0 x i8]* @sx, i64 0, i64 %i
   %len = call i64 @strnlen(i8* %ptr, i64 %n)
   ret i64 %len
 }
 

 }
 
 
 ; Do not fold strnlen(s5_3 + i, n).
 
 define i64 @call_strnlen_s5_3_pi_n(i64 zeroext %i, i64 %n) {
 ; CHECK-LABEL: @call_strnlen_s5_3_pi_n(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [10 x i8], [10 x i8]* @s5_3, i64 0, i64 [[I:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
   %ptr = getelementptr inbounds [10 x i8], [10 x i8]* @s5_3, i32 0, i64 %i
   %len = call i64 @strnlen(i8* %ptr, i64 %n)
   ret i64 %len
 }
 
 

 }
 
 
 ; Fold strnlen(s3 + i, n) to min(strlen(s3) - i, n)
 
 define i64 @fold_strnlen_s3_pi_n(i64 %i, i64 %n) {
 ; CHECK-LABEL: @fold_strnlen_s3_pi_n(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 [[I:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 
   %ptr = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 %i
   %len = call i64 @strnlen(i8* %ptr, i64 %n)
   ret i64 %len
 }
 

llvm/test/Transforms/InstCombine/strnlen-4.ll

 
 ; Fold strnlen (C ? s3 + i : s5, %n) to min(C ? 3 : 5, i) when
 ; s3 + i is guaranteed to be within the bounds of s3.
 
 define i64 @fold_strnlen_s3_pi_s5_n(i1 %C, i64 %i, i64 %n) {
 ; CHECK-LABEL: @fold_strnlen_s3_pi_s5_n(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 [[I:%.*]]
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[C:%.*]], i8* [[PTR]], i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[SEL]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[SEL]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 
   %ptr = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 %i
   %sel = select i1 %C, i8* %ptr, i8* getelementptr ([6 x i8], [6 x i8]* @s5, i64 0, i64 0)
   %len = call i64 @strnlen(i8* %sel, i64 %n)
   ret i64 %len
 }
 
 
 ; Do not fold the same expression as above when s3 + i is not guaranteed
 ; to be within the bounds of s3.  Also verify that the call is not marked
 ; noundef, nonnull, or dereferenceable because a zero bound implies no
 ; access.
 
 define i64 @call_strnlen_s3_pi_xbounds_s5_n(i1 %C, i64 %i, i64 %n) {
 ; CHECK-LABEL: @call_strnlen_s3_pi_xbounds_s5_n(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr [4 x i8], [4 x i8]* @s3, i64 0, i64 [[I:%.*]]
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[C:%.*]], i8* [[PTR]], i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[SEL]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[SEL]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 
   %ptr = getelementptr [4 x i8], [4 x i8]* @s3, i64 0, i64 %i
   %sel = select i1 %C, i8* %ptr, i8* getelementptr ([6 x i8], [6 x i8]* @s5, i64 0, i64 0)
   %len = call i64 @strnlen(i8* %sel, i64 %n)
   ret i64 %len
 }
 
 
 ; Do not fold strnlen(C ? s3 + i : sx, n) when sx's length and size
 ; are unknown.  This also verifies that the folder cleans up the IR after
 ; successfully folding the first subexpression IR when folding the second
 ; subexpression fails.
 
 define i64 @call_strnlen_s3_pi_sx_n(i1 %C, i64 %i, i64 %n) {
 ; CHECK-LABEL: @call_strnlen_s3_pi_sx_n(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 [[I:%.*]]
 ; CHECK-NEXT:    [[SEL:%.*]] = select i1 [[C:%.*]], i8* [[PTR]], i8* getelementptr inbounds ([0 x i8], [0 x i8]* @sx, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[SEL]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[SEL]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 
   %ptr = getelementptr inbounds [4 x i8], [4 x i8]* @s3, i64 0, i64 %i
   %sel = select i1 %C, i8* %ptr, i8* getelementptr ([0 x i8], [0 x i8]* @sx, i64 0, i64 0)
   %len = call i64 @strnlen(i8* %sel, i64 %n)
   ret i64 %len
 }
 
 
 ; Fold strnlen (C ? s3 : s5 + i, n) to min(C ? 3 : 5, i).
 
 define i64 @fold_strnlen_s3_s5_pi_n(i1 %C, i64 %i, i64 %n) {
 ; CHECK-LABEL: @fold_strnlen_s3_s5_pi_n(
 ; CHECK-NEXT:    [[PTR:%.*]] = select i1 [[C:%.*]], i8* getelementptr inbounds ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @s3, i64 0, i64 0)
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 [[I:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 [[I:%.*]])
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
 
   %ptr = select i1 %C, i8* getelementptr ([6 x i8], [6 x i8]* @s5, i64 0, i64 0), i8* getelementptr ([4 x i8], [4 x i8]* @s3, i64 0, i64 0)
   %len = call i64 @strnlen(i8* %ptr, i64 %i)
   ret i64 %len
 }

llvm/test/Transforms/InstCombine/strnlen-5.ll

;
   ret i1 %eqz
 }
 
 
 ; Do not fold strnlen(ax, n) == 0 for n that might be zero.
 
 define i1 @call_strnlen_ax_n_eqz(i64 %n) {
 ; CHECK-LABEL: @call_strnlen_ax_n_eqz(
-; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strnlen(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i64 [[N:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = tail call i64 @strnlen(i8* noundef nonnull getelementptr inbounds ([0 x i8], [0 x i8]* @ax, i64 0, i64 0), i64 [[N:%.*]])
 ; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i64 [[LEN]], 0
 ; CHECK-NEXT:    ret i1 [[EQZ]]
 ;
 
   %ptr = getelementptr [0 x i8], [0 x i8]* @ax, i64 0, i64 0
   %len = tail call i64 @strnlen(i8* %ptr, i64 %n)
   %eqz = icmp eq i64 %len, 0
   ret i1 %eqz

 }
 
 
 ; Do not fold strnlen(s5 + i, n) for a constant s5 when n might be zero.
 
 define i1 @call_strnlen_s5_pi_n_eqz(i64 %i, i64 %n) {
 ; CHECK-LABEL: @call_strnlen_s5_pi_n_eqz(
 ; CHECK-NEXT:    [[PTR:%.*]] = getelementptr inbounds [6 x i8], [6 x i8]* @s5, i64 0, i64 [[I:%.*]]
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* nonnull [[PTR]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 [[N:%.*]])
 ; CHECK-NEXT:    [[EQZ:%.*]] = icmp eq i64 [[LEN]], 0
 ; CHECK-NEXT:    ret i1 [[EQZ]]
 ;
 
   %ptr = getelementptr inbounds [6 x i8], [6 x i8]* @s5, i64 0, i64 %i
   %len = call i64 @strnlen(i8* %ptr, i64 %n)
   %eqz = icmp eq i64 %len, 0
   ret i1 %eqz
 }

llvm/test/Transforms/InstCombine/strnlen-6.ll

 ; Do not annotate strnlen(ecp, %n) call with nonnull etc. because it need
 ; not access *ecp.  (Strictly, every pointer function argument must be
 ; noundef, so this is overly conservative.)
 
 
 define i64 @noderef_strnlen_ecp_n(i64 %n) {
 ; CHECK-LABEL: @noderef_strnlen_ecp_n(
 ; CHECK-NEXT:    [[PTR:%.*]] = load i8*, i8** @ecp, align 8
-; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* [[PTR]], i64 [[N:%.*]])
+; CHECK-NEXT:    [[LEN:%.*]] = call i64 @strnlen(i8* noundef nonnull [[PTR]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i64 [[LEN]]
 ;
   %ptr = load i8*, i8** @ecp
   %len = call i64 @strnlen(i8* %ptr, i64 %n)
   ret i64 %len
 }

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

;
   ret i8* %ret
 }
 
 ; Check strstr(str, pat) == str -> strncmp(str, pat, strlen(str)) == 0.
 
 define i1 @test_simplify5(i8* %str, i8* %pat) {
 ; CHECK-LABEL: @test_simplify5(
 ; CHECK-NEXT:    [[STRLEN:%.*]] = call i64 @strlen(i8* noundef nonnull dereferenceable(1) [[PAT:%.*]])
-; CHECK-NEXT:    [[STRNCMP:%.*]] = call i32 @strncmp(i8* [[STR:%.*]], i8* [[PAT]], i64 [[STRLEN]])
+; CHECK-NEXT:    [[STRNCMP:%.*]] = call i32 @strncmp(i8* noundef nonnull [[STR:%.*]], i8* noundef nonnull [[PAT]], i64 [[STRLEN]])
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[STRNCMP]], 0
 ; CHECK-NEXT:    ret i1 [[CMP1]]
 ;
   %ret = call i8* @strstr(i8* %str, i8* %pat)
   %cmp = icmp eq i8* %ret, %str
   ret i1 %cmp
 }
 

llvm/test/Transforms/PhaseOrdering/ARM/arm_fill_q7.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -O3 -S                                        | FileCheck --check-prefix=OLDPM %s
 ; RUN: opt < %s -passes='default<O3>' -S | FileCheck --check-prefix=NEWPM %s
 
 target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "thumbv6m-none-none-eabi"
 
 ; Not only should we be able to to form memsets here, the original loops
 ; should be deleted, too.
 
 ; Function Attrs: nounwind
 define dso_local void @arm_fill_q7(i8 signext %value, i8* %pDst, i32 %blockSize) #0 {
 ; OLDPM-LABEL: @arm_fill_q7(
 ; OLDPM-NEXT:  entry:
-; OLDPM-NEXT:    [[CMP_NOT20:%.*]] = icmp ult i32 [[BLOCKSIZE:%.*]], 4
-; OLDPM-NEXT:    br i1 [[CMP_NOT20]], label [[WHILE_END:%.*]], label [[WHILE_BODY_PREHEADER:%.*]]
+; OLDPM-NEXT:    [[CMP_NOT17:%.*]] = icmp ult i32 [[BLOCKSIZE:%.*]], 4
+; OLDPM-NEXT:    br i1 [[CMP_NOT17]], label [[WHILE_END:%.*]], label [[WHILE_BODY_PREHEADER:%.*]]
 ; OLDPM:       while.body.preheader:
-; OLDPM-NEXT:    [[TMP0:%.*]] = and i32 [[BLOCKSIZE]], -4
-; OLDPM-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[PDST:%.*]], i8 [[VALUE:%.*]], i32 [[TMP0]], i1 false)
-; OLDPM-NEXT:    [[SCEVGEP:%.*]] = getelementptr i8, i8* [[PDST]], i32 [[TMP0]]
+; OLDPM-NEXT:    [[SHR:%.*]] = and i32 [[BLOCKSIZE]], -4
+; OLDPM-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[PDST:%.*]], i8 [[VALUE:%.*]], i32 [[SHR]], i1 false), !tbaa [[TBAA3:![0-9]+]]
+; OLDPM-NEXT:    [[SCEVGEP:%.*]] = getelementptr i8, i8* [[PDST]], i32 [[SHR]]
 ; OLDPM-NEXT:    br label [[WHILE_END]]
 ; OLDPM:       while.end:
 ; OLDPM-NEXT:    [[PDST_ADDR_0_LCSSA:%.*]] = phi i8* [ [[PDST]], [[ENTRY:%.*]] ], [ [[SCEVGEP]], [[WHILE_BODY_PREHEADER]] ]
 ; OLDPM-NEXT:    [[REM:%.*]] = and i32 [[BLOCKSIZE]], 3
-; OLDPM-NEXT:    [[CMP14_NOT17:%.*]] = icmp eq i32 [[REM]], 0
-; OLDPM-NEXT:    br i1 [[CMP14_NOT17]], label [[WHILE_END18:%.*]], label [[WHILE_BODY16_PREHEADER:%.*]]
+; OLDPM-NEXT:    [[CMP14_NOT20:%.*]] = icmp eq i32 [[REM]], 0
+; OLDPM-NEXT:    br i1 [[CMP14_NOT20]], label [[WHILE_END18:%.*]], label [[WHILE_BODY16_PREHEADER:%.*]]
 ; OLDPM:       while.body16.preheader:
-; OLDPM-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[PDST_ADDR_0_LCSSA]], i8 [[VALUE]], i32 [[REM]], i1 false)
+; OLDPM-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[PDST_ADDR_0_LCSSA]], i8 [[VALUE]], i32 [[REM]], i1 false), !tbaa [[TBAA3]]
 ; OLDPM-NEXT:    br label [[WHILE_END18]]
 ; OLDPM:       while.end18:
 ; OLDPM-NEXT:    ret void
 ;
 ; NEWPM-LABEL: @arm_fill_q7(
 ; NEWPM-NEXT:  entry:
 ; NEWPM-NEXT:    [[CMP_NOT17:%.*]] = icmp ult i32 [[BLOCKSIZE:%.*]], 4
 ; NEWPM-NEXT:    br i1 [[CMP_NOT17]], label [[WHILE_END:%.*]], label [[WHILE_BODY_PREHEADER:%.*]]
 ; NEWPM:       while.body.preheader:
-; NEWPM-NEXT:    [[TMP0:%.*]] = and i32 [[BLOCKSIZE]], -4
-; NEWPM-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[PDST:%.*]], i8 [[VALUE:%.*]], i32 [[TMP0]], i1 false)
-; NEWPM-NEXT:    [[SCEVGEP:%.*]] = getelementptr i8, i8* [[PDST]], i32 [[TMP0]]
+; NEWPM-NEXT:    [[SHR:%.*]] = and i32 [[BLOCKSIZE]], -4
+; NEWPM-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[PDST:%.*]], i8 [[VALUE:%.*]], i32 [[SHR]], i1 false), !tbaa [[TBAA3:![0-9]+]]
+; NEWPM-NEXT:    [[SCEVGEP:%.*]] = getelementptr i8, i8* [[PDST]], i32 [[SHR]]
 ; NEWPM-NEXT:    br label [[WHILE_END]]
 ; NEWPM:       while.end:
 ; NEWPM-NEXT:    [[PDST_ADDR_0_LCSSA:%.*]] = phi i8* [ [[PDST]], [[ENTRY:%.*]] ], [ [[SCEVGEP]], [[WHILE_BODY_PREHEADER]] ]
 ; NEWPM-NEXT:    [[REM:%.*]] = and i32 [[BLOCKSIZE]], 3
 ; NEWPM-NEXT:    [[CMP14_NOT20:%.*]] = icmp eq i32 [[REM]], 0
 ; NEWPM-NEXT:    br i1 [[CMP14_NOT20]], label [[WHILE_END18:%.*]], label [[WHILE_BODY16_PREHEADER:%.*]]
 ; NEWPM:       while.body16.preheader:
-; NEWPM-NEXT:    call void @llvm.memset.p0i8.i32(i8* align 1 [[PDST_ADDR_0_LCSSA]], i8 [[VALUE]], i32 [[REM]], i1 false)
+; NEWPM-NEXT:    call void @llvm.memset.p0i8.i32(i8* noundef nonnull align 1 [[PDST_ADDR_0_LCSSA]], i8 [[VALUE]], i32 [[REM]], i1 false), !tbaa [[TBAA3]]
 ; NEWPM-NEXT:    br label [[WHILE_END18]]
 ; NEWPM:       while.end18:
 ; NEWPM-NEXT:    ret void
 ;
 entry:
   %value.addr = alloca i8, align 1
   %pDst.addr = alloca i8*, align 4
   %blockSize.addr = alloca i32, align 4