Index: llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
===================================================================
--- llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
+++ llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
@@ -174,11 +174,10 @@
 
 static void annotateNonNullAndDereferenceable(CallInst *CI, ArrayRef<unsigned> ArgNos,
                                Value *Size, const DataLayout &DL) {
+  annotateNonNullNoUndefBasedOnAccess(CI, ArgNos);
   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)))) {
Index: llvm/test/Transforms/InstCombine/bcmp-1.ll
===================================================================
--- llvm/test/Transforms/InstCombine/bcmp-1.ll
+++ llvm/test/Transforms/InstCombine/bcmp-1.ll
@@ -82,8 +82,8 @@
 
 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
@@ -100,8 +100,8 @@
 
 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
@@ -118,8 +118,8 @@
 
 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
@@ -134,7 +134,7 @@
 
 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 dereferenceable(1) [[MEM1:%.*]], i8* noundef nonnull dereferenceable(1) [[MEM2:%.*]], i32 [[SIZE:%.*]])
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[CALL]], 0
 ; CHECK-NEXT:    ret i1 [[CMP]]
 ;
Index: llvm/test/Transforms/InstCombine/bcopy.ll
===================================================================
--- llvm/test/Transforms/InstCombine/bcopy.ll
+++ llvm/test/Transforms/InstCombine/bcopy.ll
@@ -17,7 +17,7 @@
 
 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 dereferenceable(1) [[B:%.*]], i8* noundef nonnull align 1 dereferenceable(1) [[A:%.*]], i32 [[LEN:%.*]], i1 false)
 ; CHECK-NEXT:    ret void
 ;
   tail call void @bcopy(i8* %a, i8* %b, i32 %len)
Index: llvm/test/Transforms/InstCombine/mem-deref-bytes-addrspaces.ll
===================================================================
--- llvm/test/Transforms/InstCombine/mem-deref-bytes-addrspaces.ll
+++ llvm/test/Transforms/InstCombine/mem-deref-bytes-addrspaces.ll
@@ -14,7 +14,7 @@
 
 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)
Index: llvm/test/Transforms/InstCombine/mem-deref-bytes.ll
===================================================================
--- llvm/test/Transforms/InstCombine/mem-deref-bytes.ll
+++ llvm/test/Transforms/InstCombine/mem-deref-bytes.ll
@@ -93,7 +93,7 @@
 
 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 dereferenceable(1) [[D:%.*]], i8* noundef nonnull dereferenceable(1) [[S:%.*]], i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
   %call = tail call i32 @memcmp(i8* %d, i8* %s, i64 %n)
Index: llvm/test/Transforms/InstCombine/memcmp-1.ll
===================================================================
--- llvm/test/Transforms/InstCombine/memcmp-1.ll
+++ llvm/test/Transforms/InstCombine/memcmp-1.ll
@@ -1,3 +1,4 @@
+; 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
@@ -35,9 +36,9 @@
 
 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]]
@@ -82,8 +83,8 @@
 
 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
@@ -100,8 +101,8 @@
 
 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
@@ -118,8 +119,8 @@
 
 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
@@ -136,13 +137,13 @@
 
 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 dereferenceable(1) [[MEM1:%.*]], i8* noundef nonnull dereferenceable(1) [[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 dereferenceable(1) [[MEM1:%.*]], i8* noundef nonnull dereferenceable(1) [[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)
Index: llvm/test/Transforms/InstCombine/memcpy-1.ll
===================================================================
--- llvm/test/Transforms/InstCombine/memcpy-1.ll
+++ llvm/test/Transforms/InstCombine/memcpy-1.ll
@@ -11,7 +11,7 @@
 
 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 dereferenceable(1) [[MEM1:%.*]], i8* noundef nonnull align 1 dereferenceable(1) [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[MEM1]]
 ;
   %ret = call i8* @memcpy(i8* %mem1, i8* %mem2, i32 %size)
@@ -22,7 +22,7 @@
 
 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 dereferenceable(1) [[MEM1:%.*]], i8* noundef nonnull align 1 dereferenceable(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
@@ -36,7 +36,7 @@
 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 dereferenceable(1) [[DEST]], i8* noundef nonnull align 1 dereferenceable(1) [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[DEST]]
 ;
 
@@ -47,7 +47,7 @@
 
 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 dereferenceable(1) [[MEM1:%.*]], i8* noundef nonnull align 1 dereferenceable(1) [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[MEM1]]
 ;
 
Index: llvm/test/Transforms/InstCombine/memcpy-2.ll
===================================================================
--- llvm/test/Transforms/InstCombine/memcpy-2.ll
+++ llvm/test/Transforms/InstCombine/memcpy-2.ll
@@ -1,3 +1,4 @@
+; 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
@@ -10,7 +11,7 @@
 
 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)
Index: llvm/test/Transforms/InstCombine/memmove-1.ll
===================================================================
--- llvm/test/Transforms/InstCombine/memmove-1.ll
+++ llvm/test/Transforms/InstCombine/memmove-1.ll
@@ -1,3 +1,4 @@
+; 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
@@ -10,32 +11,36 @@
 
 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 dereferenceable(1) [[MEM1:%.*]], i8* noundef nonnull align 1 dereferenceable(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 dereferenceable(1) [[MEM1:%.*]], i8* noundef nonnull align 1 dereferenceable(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 dereferenceable(1) [[MEM1:%.*]], i8* noundef nonnull align 1 dereferenceable(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
 }
Index: llvm/test/Transforms/InstCombine/memmove.ll
===================================================================
--- llvm/test/Transforms/InstCombine/memmove.ll
+++ llvm/test/Transforms/InstCombine/memmove.ll
@@ -19,7 +19,7 @@
 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 dereferenceable(1) [[A:%.*]], i8* noundef nonnull align 16 dereferenceable(1) 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)
Index: llvm/test/Transforms/InstCombine/mempcpy.ll
===================================================================
--- llvm/test/Transforms/InstCombine/mempcpy.ll
+++ llvm/test/Transforms/InstCombine/mempcpy.ll
@@ -3,7 +3,7 @@
 
 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 dereferenceable(1) [[D:%.*]], i8* noundef nonnull align 1 dereferenceable(1) [[S:%.*]], i64 [[N:%.*]], i1 false)
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[D]], i64 [[N]]
 ; CHECK-NEXT:    ret i8* [[TMP1]]
 ;
@@ -13,7 +13,7 @@
 
 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 dereferenceable(1) [[S:%.*]], i64 [[N:%.*]], i1 false)
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i8, i8* [[D]], i64 [[N]]
 ; CHECK-NEXT:    ret i8* [[TMP1]]
 ;
@@ -23,7 +23,7 @@
 
 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 dereferenceable(1) [[D:%.*]], i8* noundef nonnull align 1 dereferenceable(1) [[S:%.*]], i64 [[N:%.*]], i1 false)
 ; CHECK-NEXT:    ret void
 ;
   call i8* @mempcpy(i8* %d, i8* %s, i64 %n)
@@ -45,7 +45,7 @@
 
 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]]
 ;
@@ -57,7 +57,7 @@
 
 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 dereferenceable(1) undef, i8* noundef nonnull align 4294967296 dereferenceable(1) null, i64 undef, i1 false)
 ; CHECK-NEXT:    ret i32 undef
 ;
   %r = call dereferenceable(1) i8* @mempcpy(i8* undef, i8* null, i64 undef)
@@ -66,8 +66,8 @@
 
 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
Index: llvm/test/Transforms/InstCombine/memrchr-3.ll
===================================================================
--- llvm/test/Transforms/InstCombine/memrchr-3.ll
+++ llvm/test/Transforms/InstCombine/memrchr-3.ll
@@ -196,7 +196,7 @@
 
 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 dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @a12345, i64 0, i64 0), i32 3, i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
 
@@ -210,7 +210,7 @@
 
 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 dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @a12345, i64 0, i64 0), i32 5, i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
 
@@ -302,7 +302,7 @@
 
 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 dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @a123123, i64 0, i64 0), i32 3, i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
 
@@ -316,7 +316,7 @@
 
 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 dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @a123123, i64 0, i64 0), i32 2, i64 [[N:%.*]])
 ; CHECK-NEXT:    ret i8* [[RET]]
 ;
 
Index: llvm/test/Transforms/InstCombine/memset-1.ll
===================================================================
--- llvm/test/Transforms/InstCombine/memset-1.ll
+++ llvm/test/Transforms/InstCombine/memset-1.ll
@@ -14,7 +14,7 @@
 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 dereferenceable(1) [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[MEM]]
 ;
   %ret = call i8* @memset(i8* %mem, i32 %val, i32 %size)
@@ -24,7 +24,7 @@
 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 dereferenceable(1) [[MEM:%.*]], i8 [[TMP1]], i32 [[SIZE:%.*]], i1 false)
 ; CHECK-NEXT:    ret i8* [[MEM]]
 ;
   %ret = tail call i8* @memset(i8* %mem, i32 %val, i32 %size)
@@ -33,8 +33,8 @@
 
 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
@@ -44,8 +44,9 @@
 
 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 dereferenceable(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
@@ -58,7 +59,7 @@
 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 dereferenceable(1) [[CALL]], i8 0, i32 [[N]], i1 false)
 ; CHECK-NEXT:    ret i8* [[CALL]]
 ;
   %call = call i8* @malloc(i32 %n)
@@ -71,8 +72,8 @@
 
 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 dereferenceable(1) [[CALL1]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[CALL1]]
 ;
   %call1 = call i8* %notmalloc(i32 %size) #1
@@ -86,12 +87,12 @@
 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:%.*]] ]
@@ -114,9 +115,9 @@
 
 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
@@ -128,7 +129,7 @@
 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
@@ -140,7 +141,7 @@
 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
@@ -151,7 +152,7 @@
 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
@@ -162,7 +163,7 @@
 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
@@ -173,7 +174,7 @@
 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 [[PTR:%.*]], i8 0, i32 [[SIZE]], i1 false) #[[ATTR0]]
 ; CHECK-NEXT:    ret i8* [[PTR]]
 ;
   %size = ashr i32 -2, %v
@@ -183,7 +184,7 @@
 
 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(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
@@ -194,7 +195,7 @@
 ; 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
@@ -204,7 +205,7 @@
 ; 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
@@ -214,7 +215,7 @@
 ; 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
@@ -224,7 +225,7 @@
 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 dereferenceable(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)
Index: llvm/test/Transforms/InstCombine/memset_chk-1.ll
===================================================================
--- llvm/test/Transforms/InstCombine/memset_chk-1.ll
+++ llvm/test/Transforms/InstCombine/memset_chk-1.ll
@@ -83,8 +83,8 @@
 
 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
@@ -106,7 +106,7 @@
 ; 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 dereferenceable(1) [[STRCHR1]], i8 0, i64 [[ADD52_I_I]], i1 false)
 ; CHECK-NEXT:    ret i32 4
 ;
 entry:
@@ -136,13 +136,13 @@
 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:%.*]] ]
Index: llvm/test/Transforms/InstCombine/sprintf-1.ll
===================================================================
--- llvm/test/Transforms/InstCombine/sprintf-1.ll
+++ llvm/test/Transforms/InstCombine/sprintf-1.ll
@@ -109,7 +109,7 @@
 ; 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 dereferenceable(1) [[DST:%.*]], i8* noundef nonnull align 1 dereferenceable(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
@@ -142,7 +142,7 @@
 ; 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 dereferenceable(1) [[DST:%.*]], i8* noundef nonnull align 1 dereferenceable(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
Index: llvm/test/Transforms/PhaseOrdering/ARM/arm_fill_q7.ll
===================================================================
--- llvm/test/Transforms/PhaseOrdering/ARM/arm_fill_q7.ll
+++ llvm/test/Transforms/PhaseOrdering/ARM/arm_fill_q7.ll
@@ -12,20 +12,20 @@
 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 dereferenceable(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 dereferenceable(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
@@ -35,9 +35,9 @@
 ; 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 dereferenceable(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]] ]
@@ -45,7 +45,7 @@
 ; 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 dereferenceable(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