diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 375385aca7a39..d890ae83d1949 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -3098,6 +3098,13 @@ bool isKnownNonZero(const Value *V, const APInt &DemandedElts,
   // Check for pointer simplifications.
 
   if (PointerType *PtrTy = dyn_cast<PointerType>(Ty)) {
+    const DataLayout &DL = Q.DL;
+    if (DL.isSentinelValueDefined()) {
+      unsigned AddrSpace = PtrTy->getPointerAddressSpace();
+
+      return (DL.getSentinelPointerValue(AddrSpace) != 0);
+    }
+
     // A byval, inalloca may not be null in a non-default addres space. A
     // nonnull argument is assumed never 0.
     if (const Argument *A = dyn_cast<Argument>(V)) {
diff --git a/llvm/test/Transforms/Attributor/IPConstantProp/pthreads-dl-sentinel.ll b/llvm/test/Transforms/Attributor/IPConstantProp/pthreads-dl-sentinel.ll
new file mode 100755
index 0000000000000..da05e40e09f5d
--- /dev/null
+++ b/llvm/test/Transforms/Attributor/IPConstantProp/pthreads-dl-sentinel.ll
@@ -0,0 +1,151 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL,CGSCC-DL
+;
+;    #include <pthread.h>
+;
+;    ptr GlobalVPtr;
+;
+;    static ptr foo(ptr arg) { return arg; }
+;    static ptr bar(ptr arg) { return arg; }
+;
+;    int main() {
+;      pthread_t thread;
+;      pthread_create(&thread, NULL, foo, NULL);
+;      pthread_create(&thread, NULL, bar, &GlobalVPtr);
+;      return 0;
+;    }
+;
+; Verify the constant values NULL and &GlobalVPtr are propagated into foo and
+; bar, respectively.
+;
+
+%union.pthread_attr_t = type { i64, [48 x i8] }
+
+@GlobalVPtr = common dso_local global ptr null, align 8
+
+; FIXME: nocapture & noalias for @GlobalVPtr in %call1
+; FIXME: nocapture & noalias for %alloc2 in %call3
+
+;.
+; CHECK: @GlobalVPtr = common dso_local global ptr null, align 8
+;.
+; CHECK-DL: @GlobalVPtr = common dso_local global ptr null, align 8
+;.
+define dso_local i32 @main() {
+; CHECK-LABEL: define {{[^@]+}}@main() {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[ALLOC1:%.*]] = alloca i8, align 8
+; CHECK-NEXT:    [[ALLOC2:%.*]] = alloca i8, align 8
+; CHECK-NEXT:    [[THREAD:%.*]] = alloca i64, align 8
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noundef align 4294967296 null, ptr noundef nonnull @foo, ptr nofree noundef readnone align 4294967296 null)
+; CHECK-NEXT:    [[CALL1:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noundef align 4294967296 null, ptr noundef nonnull @bar, ptr noalias nocapture nofree noundef nonnull readnone align 8 dereferenceable(8) @GlobalVPtr)
+; CHECK-NEXT:    [[CALL2:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noundef align 4294967296 null, ptr noundef nonnull @baz, ptr noalias nocapture nofree noundef nonnull readnone align 8 dereferenceable(1) [[ALLOC1]])
+; CHECK-NEXT:    [[CALL3:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noundef align 4294967296 null, ptr noundef nonnull @buz, ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(1) [[ALLOC2]])
+; CHECK-NEXT:    ret i32 0
+;
+; CHECK-DL-LABEL: define {{[^@]+}}@main() {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    [[ALLOC1:%.*]] = alloca i8, align 8
+; CHECK-DL-NEXT:    [[ALLOC2:%.*]] = alloca i8, align 8
+; CHECK-DL-NEXT:    [[THREAD:%.*]] = alloca i64, align 8
+; CHECK-DL-NEXT:    unreachable
+;
+entry:
+  %alloc1 = alloca i8, align 8
+  %alloc2 = alloca i8, align 8
+  %thread = alloca i64, align 8
+  %call = call i32 @pthread_create(ptr nonnull %thread, ptr null, ptr nonnull @foo, ptr null)
+  %call1 = call i32 @pthread_create(ptr nonnull %thread, ptr null, ptr nonnull @bar, ptr @GlobalVPtr)
+  %call2 = call i32 @pthread_create(ptr nonnull %thread, ptr null, ptr nonnull @baz, ptr nocapture %alloc1)
+  %call3 = call i32 @pthread_create(ptr nonnull %thread, ptr null, ptr nonnull @buz, ptr %alloc2)
+  ret i32 0
+}
+
+declare !callback !0 dso_local i32 @pthread_create(ptr, ptr, ptr, ptr)
+
+define internal ptr @foo(ptr %arg) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define {{[^@]+}}@foo
+; CHECK-SAME: (ptr noalias nocapture nofree readnone align 4294967296 [[ARG:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret ptr null
+;
+; CHECK-DL: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-DL-LABEL: define {{[^@]+}}@foo
+; CHECK-DL-SAME: (ptr noalias nocapture nofree nonnull readnone align 4294967296 [[ARG:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    unreachable
+;
+entry:
+  ret ptr %arg
+}
+
+
+define internal ptr @bar(ptr %arg) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define {{[^@]+}}@bar
+; CHECK-SAME: (ptr noalias nocapture nofree nonnull readnone align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret ptr @GlobalVPtr
+;
+; CHECK-DL: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-DL-LABEL: define {{[^@]+}}@bar
+; CHECK-DL-SAME: (ptr noalias nocapture nofree nonnull readnone align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret ptr @GlobalVPtr
+;
+entry:
+  ret ptr %arg
+}
+
+define internal ptr @baz(ptr %arg) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define {{[^@]+}}@baz
+; CHECK-SAME: (ptr noalias nofree noundef nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[ARG:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret ptr [[ARG]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-DL-LABEL: define {{[^@]+}}@baz
+; CHECK-DL-SAME: (ptr noalias nofree noundef nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[ARG:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret ptr [[ARG]]
+;
+entry:
+  ret ptr %arg
+}
+
+define internal ptr @buz(ptr %arg) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-LABEL: define {{[^@]+}}@buz
+; CHECK-SAME: (ptr noalias nofree noundef nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[ARG:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret ptr [[ARG]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CHECK-DL-LABEL: define {{[^@]+}}@buz
+; CHECK-DL-SAME: (ptr noalias nofree noundef nonnull readnone returned align 8 dereferenceable(1) "no-capture-maybe-returned" [[ARG:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret ptr [[ARG]]
+;
+entry:
+  ret ptr %arg
+}
+
+!1 = !{i64 2, i64 3, i1 false}
+!0 = !{!1}
+;.
+; CHECK: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
+;.
+; CHECK-DL: attributes #[[ATTR0]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
+;.
+; CHECK: [[META0:![0-9]+]] = !{[[META1:![0-9]+]]}
+; CHECK: [[META1]] = !{i64 2, i64 3, i1 false}
+;.
+; CHECK-DL: [[META0:![0-9]+]] = !{[[META1:![0-9]+]]}
+; CHECK-DL: [[META1]] = !{i64 2, i64 3, i1 false}
+;.
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; CGSCC: {{.*}}
+; CGSCC-DL: {{.*}}
diff --git a/llvm/test/Transforms/Attributor/nocapture-2-dl-sentinel.ll b/llvm/test/Transforms/Attributor/nocapture-2-dl-sentinel.ll
new file mode 100755
index 0000000000000..1775681ec5f48
--- /dev/null
+++ b/llvm/test/Transforms/Attributor/nocapture-2-dl-sentinel.ll
@@ -0,0 +1,376 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes --check-globals --version 2
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-annotate-decl-cs  -S < %s | FileCheck %s --check-prefixes=CHECK
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-annotate-decl-cs -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL
+;
+; Test cases specifically designed for the "no-capture" argument attribute.
+; We use FIXME's to indicate problems and missing attributes.
+;
+
+declare ptr @unknown()
+
+; TEST comparison against NULL
+;
+; int is_null_return(int *p) {
+;   return p == 0;
+; }
+;
+; no-capture is missing on %p because it is not dereferenceable
+define i32 @is_null_return(ptr %p) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-LABEL: define i32 @is_null_return
+; CHECK-SAME: (ptr nofree readnone [[P:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[P]], null
+; CHECK-NEXT:    [[CONV:%.*]] = zext i1 [[CMP]] to i32
+; CHECK-NEXT:    ret i32 [[CONV]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define noundef i32 @is_null_return
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone [[P:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret i32 0
+;
+entry:
+  %cmp = icmp eq ptr %p, null
+  %conv = zext i1 %cmp to i32
+  ret i32 %conv
+}
+
+; TEST comparison against NULL in control flow
+;
+; int is_null_control(int *p) {
+;   if (p == 0)
+;     return 1;
+;   if (0 == p)
+;     return 1;
+;   return 0;
+; }
+;
+; no-capture is missing on %p because it is not dereferenceable
+define i32 @is_null_control(ptr %p) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-LABEL: define i32 @is_null_control
+; CHECK-SAME: (ptr nofree [[P:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[P]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CHECK:       if.then:
+; CHECK-NEXT:    store i32 1, ptr [[RETVAL]], align 4
+; CHECK-NEXT:    br label [[RETURN:%.*]]
+; CHECK:       if.end:
+; CHECK-NEXT:    br label [[IF_END3:%.*]]
+; CHECK:       if.then2:
+; CHECK-NEXT:    unreachable
+; CHECK:       if.end3:
+; CHECK-NEXT:    store i32 0, ptr [[RETVAL]], align 4
+; CHECK-NEXT:    br label [[RETURN]]
+; CHECK:       return:
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[RETVAL]], align 4
+; CHECK-NEXT:    ret i32 [[TMP0]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define i32 @is_null_control
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone [[P:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    [[RETVAL:%.*]] = alloca i32, align 4
+; CHECK-DL-NEXT:    br label [[IF_END:%.*]]
+; CHECK-DL:       if.then:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       if.end:
+; CHECK-DL-NEXT:    br label [[IF_END3:%.*]]
+; CHECK-DL:       if.then2:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       if.end3:
+; CHECK-DL-NEXT:    br label [[RETURN:%.*]]
+; CHECK-DL:       return:
+; CHECK-DL-NEXT:    ret i32 0
+;
+entry:
+  %retval = alloca i32, align 4
+  %cmp = icmp eq ptr %p, null
+  br i1 %cmp, label %if.then, label %if.end
+
+if.then:                                          ; preds = %entry
+  store i32 1, ptr %retval, align 4
+  br label %return
+
+if.end:                                           ; preds = %entry
+  %cmp1 = icmp eq ptr null, %p
+  br i1 %cmp1, label %if.then2, label %if.end3
+
+if.then2:                                         ; preds = %if.end
+  store i32 1, ptr %retval, align 4
+  br label %return
+
+if.end3:                                          ; preds = %if.end
+  store i32 0, ptr %retval, align 4
+  br label %return
+
+return:                                           ; preds = %if.end3, %if.then2, %if.then
+  %0 = load i32, ptr %retval, align 4
+  ret i32 %0
+}
+
+; TEST SCC with various calls, casts, and comparisons agains NULL
+;
+; float *scc_A(int *a) {
+;   return (float*)(a ? (int*)scc_A((int*)scc_B((double*)scc_C((short*)a))) : a);
+; }
+;
+; long *scc_B(double *a) {
+;   return (long*)(a ? scc_C((short*)scc_B((double*)scc_A((int*)a))) : a);
+; }
+;
+; void *scc_C(short *a) {
+;   return scc_A((int*)(scc_A(a) ? scc_B((double*)a) : scc_C(a)));
+; }
+define ptr @scc_A(ptr dereferenceable_or_null(4) %a) {
+; CHECK: Function Attrs: nofree nosync nounwind memory(none)
+; CHECK-LABEL: define noundef dereferenceable_or_null(4) ptr @scc_A
+; CHECK-SAME: (ptr nofree noundef readnone returned dereferenceable_or_null(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne ptr [[A]], null
+; CHECK-NEXT:    br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+; CHECK:       cond.true:
+; CHECK-NEXT:    [[CALL:%.*]] = call dereferenceable_or_null(4) ptr @scc_C(ptr noalias nofree noundef nonnull readnone dereferenceable(4) "no-capture-maybe-returned" [[A]]) #[[ATTR1]]
+; CHECK-NEXT:    [[CALL1:%.*]] = call dereferenceable_or_null(8) ptr @scc_B(ptr noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[A]]) #[[ATTR1]]
+; CHECK-NEXT:    [[CALL2:%.*]] = call ptr @scc_A(ptr noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[A]]) #[[ATTR1]]
+; CHECK-NEXT:    br label [[COND_END:%.*]]
+; CHECK:       cond.false:
+; CHECK-NEXT:    br label [[COND_END]]
+; CHECK:       cond.end:
+; CHECK-NEXT:    [[COND:%.*]] = phi ptr [ [[A]], [[COND_TRUE]] ], [ [[A]], [[COND_FALSE]] ]
+; CHECK-NEXT:    ret ptr [[A]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noreturn nosync nounwind willreturn memory(none)
+; CHECK-DL-LABEL: define noalias nonnull align 4294967296 dereferenceable(4294967295) ptr @scc_A
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(4) [[A:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[COND_TRUE:%.*]]
+; CHECK-DL:       cond.true:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       cond.false:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       cond.end:
+; CHECK-DL-NEXT:    unreachable
+;
+entry:
+  %tobool = icmp ne ptr %a, null
+  br i1 %tobool, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %entry
+  %call = call ptr @scc_C(ptr %a)
+  %call1 = call ptr @scc_B(ptr %call)
+  %call2 = call ptr @scc_A(ptr %call1)
+  br label %cond.end
+
+cond.false:                                       ; preds = %entry
+  br label %cond.end
+
+cond.end:                                         ; preds = %cond.false, %cond.true
+  %cond = phi ptr [ %call2, %cond.true ], [ %a, %cond.false ]
+  ret ptr %cond
+}
+
+; FIXME: the call1 below to scc_B should return dereferenceable_or_null(8) (as the callee does). Something prevented that deduction and needs to be investigated.
+define ptr @scc_B(ptr dereferenceable_or_null(8) %a) {
+; CHECK: Function Attrs: nofree nosync nounwind memory(none)
+; CHECK-LABEL: define noundef dereferenceable_or_null(8) ptr @scc_B
+; CHECK-SAME: (ptr nofree noundef readnone returned dereferenceable_or_null(8) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne ptr [[A]], null
+; CHECK-NEXT:    br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+; CHECK:       cond.true:
+; CHECK-NEXT:    [[CALL:%.*]] = call dereferenceable_or_null(4) ptr @scc_A(ptr noalias nofree noundef nonnull readnone dereferenceable(8) "no-capture-maybe-returned" [[A]]) #[[ATTR1]]
+; CHECK-NEXT:    [[CALL1:%.*]] = call dereferenceable_or_null(8) ptr @scc_B(ptr noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[A]]) #[[ATTR1]]
+; CHECK-NEXT:    [[CALL2:%.*]] = call ptr @scc_C(ptr noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[A]]) #[[ATTR1]]
+; CHECK-NEXT:    br label [[COND_END:%.*]]
+; CHECK:       cond.false:
+; CHECK-NEXT:    br label [[COND_END]]
+; CHECK:       cond.end:
+; CHECK-NEXT:    [[COND:%.*]] = phi ptr [ [[A]], [[COND_TRUE]] ], [ [[A]], [[COND_FALSE]] ]
+; CHECK-NEXT:    ret ptr [[A]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noreturn nosync nounwind willreturn memory(none)
+; CHECK-DL-LABEL: define noalias nonnull align 4294967296 dereferenceable(4294967295) ptr @scc_B
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(8) [[A:%.*]]) #[[ATTR1]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[COND_TRUE:%.*]]
+; CHECK-DL:       cond.true:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       cond.false:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       cond.end:
+; CHECK-DL-NEXT:    unreachable
+;
+entry:
+  %tobool = icmp ne ptr %a, null
+  br i1 %tobool, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %entry
+  %call = call ptr @scc_A(ptr %a)
+  %call1 = call ptr @scc_B(ptr %call)
+  %call2 = call ptr @scc_C(ptr %call1)
+  br label %cond.end
+
+cond.false:                                       ; preds = %entry
+  br label %cond.end
+
+cond.end:                                         ; preds = %cond.false, %cond.true
+  %cond = phi ptr [ %call2, %cond.true ], [ %a, %cond.false ]
+  ret ptr %cond
+}
+
+define ptr @scc_C(ptr dereferenceable_or_null(2) %a) {
+; CHECK: Function Attrs: nofree nosync nounwind memory(none)
+; CHECK-LABEL: define noundef dereferenceable_or_null(4) ptr @scc_C
+; CHECK-SAME: (ptr nofree noundef readnone returned dereferenceable_or_null(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CALL:%.*]] = call dereferenceable_or_null(4) ptr @scc_A(ptr noalias nofree noundef readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[A]]) #[[ATTR1]]
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne ptr [[A]], null
+; CHECK-NEXT:    br i1 [[TOBOOL]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+; CHECK:       cond.true:
+; CHECK-NEXT:    [[CALL1:%.*]] = call ptr @scc_B(ptr noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[A]]) #[[ATTR1]]
+; CHECK-NEXT:    br label [[COND_END:%.*]]
+; CHECK:       cond.false:
+; CHECK-NEXT:    [[CALL2:%.*]] = call ptr @scc_C(ptr noalias nofree noundef readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[A]]) #[[ATTR1]]
+; CHECK-NEXT:    br label [[COND_END]]
+; CHECK:       cond.end:
+; CHECK-NEXT:    [[COND:%.*]] = phi ptr [ [[A]], [[COND_TRUE]] ], [ [[A]], [[COND_FALSE]] ]
+; CHECK-NEXT:    [[CALL3:%.*]] = call ptr @scc_A(ptr noalias nofree noundef readnone dereferenceable_or_null(4) "no-capture-maybe-returned" [[A]]) #[[ATTR1]]
+; CHECK-NEXT:    ret ptr [[A]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noreturn nosync nounwind willreturn memory(none)
+; CHECK-DL-LABEL: define noalias nonnull align 4294967296 dereferenceable(4294967295) ptr @scc_C
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone dereferenceable(4) [[A:%.*]]) #[[ATTR1]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       cond.true:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       cond.false:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       cond.end:
+; CHECK-DL-NEXT:    unreachable
+;
+entry:
+  %call = call ptr @scc_A(ptr %a)
+  %tobool = icmp ne ptr %call, null
+  br i1 %tobool, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %entry
+  %call1 = call ptr @scc_B(ptr %a)
+  br label %cond.end
+
+cond.false:                                       ; preds = %entry
+  %call2 = call ptr @scc_C(ptr %a)
+  br label %cond.end
+
+cond.end:                                         ; preds = %cond.false, %cond.true
+  %cond = phi ptr [ %call1, %cond.true ], [ %call2, %cond.false ]
+  %call3 = call ptr @scc_A(ptr %cond)
+  ret ptr %call3
+}
+
+; TEST return argument or unknown call result
+;
+; int* ret_arg_or_unknown(int* b) {
+;   if (b == 0)
+;     return b;
+;   return unknown();
+; }
+;
+; Verify we do *not* assume b is returned or not captured.
+;
+
+define ptr @ret_arg_or_unknown(ptr %b) #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define ptr @ret_arg_or_unknown
+; CHECK-SAME: (ptr [[B:%.*]]) #[[ATTR2:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[B]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[RET_ARG:%.*]], label [[RET_UNKNOWN:%.*]]
+; CHECK:       ret_arg:
+; CHECK-NEXT:    ret ptr [[B]]
+; CHECK:       ret_unknown:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @unknown()
+; CHECK-NEXT:    ret ptr [[CALL]]
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define nonnull ptr @ret_arg_or_unknown
+; CHECK-DL-SAME: (ptr nofree nonnull readnone "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR2:[0-9]+]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[RET_UNKNOWN:%.*]]
+; CHECK-DL:       ret_arg:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       ret_unknown:
+; CHECK-DL-NEXT:    [[CALL:%.*]] = call nonnull ptr @unknown()
+; CHECK-DL-NEXT:    ret ptr [[CALL]]
+;
+entry:
+  %cmp = icmp eq ptr %b, null
+  br i1 %cmp, label %ret_arg, label %ret_unknown
+
+ret_arg:
+  ret ptr %b
+
+ret_unknown:
+  %call = call ptr @unknown()
+  ret ptr %call
+}
+
+define ptr @ret_arg_or_unknown_through_phi(ptr %b) #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define ptr @ret_arg_or_unknown_through_phi
+; CHECK-SAME: (ptr [[B:%.*]]) #[[ATTR2]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[B]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[RET_ARG:%.*]], label [[RET_UNKNOWN:%.*]]
+; CHECK:       ret_arg:
+; CHECK-NEXT:    br label [[R:%.*]]
+; CHECK:       ret_unknown:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @unknown()
+; CHECK-NEXT:    br label [[R]]
+; CHECK:       r:
+; CHECK-NEXT:    [[PHI:%.*]] = phi ptr [ [[B]], [[RET_ARG]] ], [ [[CALL]], [[RET_UNKNOWN]] ]
+; CHECK-NEXT:    ret ptr [[PHI]]
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define nonnull ptr @ret_arg_or_unknown_through_phi
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone [[B:%.*]]) #[[ATTR2]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[RET_UNKNOWN:%.*]]
+; CHECK-DL:       ret_arg:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       ret_unknown:
+; CHECK-DL-NEXT:    [[CALL:%.*]] = call nonnull ptr @unknown()
+; CHECK-DL-NEXT:    br label [[R:%.*]]
+; CHECK-DL:       r:
+; CHECK-DL-NEXT:    ret ptr [[CALL]]
+;
+entry:
+  %cmp = icmp eq ptr %b, null
+  br i1 %cmp, label %ret_arg, label %ret_unknown
+
+ret_arg:
+  br label %r
+
+ret_unknown:
+  %call = call ptr @unknown()
+  br label %r
+
+r:
+  %phi = phi ptr [ %b, %ret_arg ], [ %call, %ret_unknown ]
+  ret ptr %phi
+}
+
+attributes #0 = { noinline nounwind uwtable }
+;.
+; CHECK: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
+; CHECK: attributes #[[ATTR1]] = { nofree nosync nounwind memory(none) }
+; CHECK: attributes #[[ATTR2]] = { noinline nounwind uwtable }
+;.
+; CHECK-DL: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
+; CHECK-DL: attributes #[[ATTR1]] = { mustprogress nofree noreturn nosync nounwind willreturn memory(none) }
+; CHECK-DL: attributes #[[ATTR2]] = { noinline nounwind uwtable }
+;.
diff --git a/llvm/test/Transforms/Attributor/nofree-dl-sentinel.ll b/llvm/test/Transforms/Attributor/nofree-dl-sentinel.ll
new file mode 100755
index 0000000000000..d26b64cb9cfcc
--- /dev/null
+++ b/llvm/test/Transforms/Attributor/nofree-dl-sentinel.ll
@@ -0,0 +1,140 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-annotate-decl-cs  -S < %s | FileCheck %s --check-prefixes=CHECK
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-annotate-decl-cs -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL
+
+; Test cases specifically designed for the "nofree" function attribute.
+; We use FIXME's to indicate problems and missing attributes.
+
+; Free functions
+declare void @free(ptr nocapture) local_unnamed_addr #1
+declare noalias ptr @realloc(ptr nocapture, i64) local_unnamed_addr #0
+declare void @_ZdaPv(ptr) local_unnamed_addr #2
+
+; TEST 3 (negative case)
+; Free occurs in same scc.
+; void free_in_scc1(char*p){
+;    free_in_scc2(p);
+; }
+; void free_in_scc2(char*p){
+;    free_in_scc1(p);
+;    free(p);
+; }
+
+
+define void @free_in_scc1(ptr nocapture %0) local_unnamed_addr #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@free_in_scc1
+; CHECK-SAME: (ptr nocapture [[TMP0:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] {
+; CHECK-NEXT:    tail call void @free_in_scc2(ptr nocapture [[TMP0]]) #[[ATTR0:[0-9]+]]
+; CHECK-NEXT:    ret void
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@free_in_scc1
+; CHECK-DL-SAME: (ptr nocapture nonnull [[TMP0:%.*]]) local_unnamed_addr #[[ATTR1:[0-9]+]] {
+; CHECK-DL-NEXT:    tail call void @free_in_scc2(ptr nocapture nonnull [[TMP0]]) #[[ATTR0:[0-9]+]]
+; CHECK-DL-NEXT:    ret void
+;
+  tail call void @free_in_scc2(ptr %0) #1
+  ret void
+}
+define void @free_in_scc2(ptr nocapture %0) local_unnamed_addr #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@free_in_scc2
+; CHECK-SAME: (ptr nocapture [[TMP0:%.*]]) local_unnamed_addr #[[ATTR1]] {
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[TMP0]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[REC:%.*]], label [[CALL:%.*]]
+; CHECK:       call:
+; CHECK-NEXT:    tail call void @free(ptr nocapture nonnull [[TMP0]]) #[[ATTR0]]
+; CHECK-NEXT:    br label [[END:%.*]]
+; CHECK:       rec:
+; CHECK-NEXT:    tail call void @free_in_scc1(ptr nocapture [[TMP0]]) #[[ATTR0]]
+; CHECK-NEXT:    br label [[END]]
+; CHECK:       end:
+; CHECK-NEXT:    ret void
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@free_in_scc2
+; CHECK-DL-SAME: (ptr nocapture nonnull [[TMP0:%.*]]) local_unnamed_addr #[[ATTR1]] {
+; CHECK-DL-NEXT:    br label [[CALL:%.*]]
+; CHECK-DL:       call:
+; CHECK-DL-NEXT:    tail call void @free(ptr nocapture nonnull [[TMP0]]) #[[ATTR0]]
+; CHECK-DL-NEXT:    br label [[END:%.*]]
+; CHECK-DL:       rec:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       end:
+; CHECK-DL-NEXT:    ret void
+;
+  %cmp = icmp eq ptr %0, null
+  br i1 %cmp, label %rec, label %call
+call:
+  tail call void @free(ptr %0) #1
+  br label %end
+rec:
+  tail call void @free_in_scc1(ptr %0)
+  br label %end
+end:
+  ret void
+}
+
+; TEST 5
+; C++ delete operation (negative case)
+; void delete_op (char p[]){
+;     delete [] p;
+; }
+
+define void @_Z9delete_opPc(ptr %0) local_unnamed_addr #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@_Z9delete_opPc
+; CHECK-SAME: (ptr [[TMP0:%.*]]) local_unnamed_addr #[[ATTR1]] {
+; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq ptr [[TMP0]], null
+; CHECK-NEXT:    br i1 [[TMP2]], label [[TMP4:%.*]], label [[TMP3:%.*]]
+; CHECK:       3:
+; CHECK-NEXT:    tail call void @_ZdaPv(ptr nonnull [[TMP0]]) #[[ATTR2:[0-9]+]]
+; CHECK-NEXT:    br label [[TMP4]]
+; CHECK:       4:
+; CHECK-NEXT:    ret void
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@_Z9delete_opPc
+; CHECK-DL-SAME: (ptr nonnull [[TMP0:%.*]]) local_unnamed_addr #[[ATTR1]] {
+; CHECK-DL-NEXT:    br label [[TMP2:%.*]]
+; CHECK-DL:       2:
+; CHECK-DL-NEXT:    tail call void @_ZdaPv(ptr nonnull [[TMP0]]) #[[ATTR2:[0-9]+]]
+; CHECK-DL-NEXT:    br label [[TMP3:%.*]]
+; CHECK-DL:       3:
+; CHECK-DL-NEXT:    ret void
+;
+  %2 = icmp eq ptr %0, null
+  br i1 %2, label %4, label %3
+
+; <label>:3:                                      ; preds = %1
+  tail call void @_ZdaPv(ptr nonnull %0) #2
+  br label %4
+
+; <label>:4:                                      ; preds = %3, %1
+  ret void
+}
+
+declare void @llvm.assume(i1)
+declare void @unknown(ptr, ptr, ptr, ptr)
+declare void @use_i8_ptr(ptr nocapture readnone) nounwind
+declare void @use_i8_ptr_ret(ptr nocapture readnone) nounwind willreturn
+
+declare noalias ptr @malloc(i64)
+
+attributes #0 = { nounwind uwtable noinline }
+attributes #1 = { nounwind }
+attributes #2 = { nobuiltin nounwind }
+;.
+; CHECK: attributes #[[ATTR0]] = { nounwind }
+; CHECK: attributes #[[ATTR1]] = { noinline nounwind uwtable }
+; CHECK: attributes #[[ATTR2]] = { nobuiltin nounwind }
+; CHECK: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) }
+; CHECK: attributes #[[ATTR4:[0-9]+]] = { nounwind willreturn }
+;.
+; CHECK-DL: attributes #[[ATTR0]] = { nounwind }
+; CHECK-DL: attributes #[[ATTR1]] = { noinline nounwind uwtable }
+; CHECK-DL: attributes #[[ATTR2]] = { nobuiltin nounwind }
+; CHECK-DL: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) }
+; CHECK-DL: attributes #[[ATTR4:[0-9]+]] = { nounwind willreturn }
+;.
diff --git a/llvm/test/Transforms/Attributor/read_write_returned_arguments_scc-dl-sentinel.ll b/llvm/test/Transforms/Attributor/read_write_returned_arguments_scc-dl-sentinel.ll
new file mode 100755
index 0000000000000..16792716e8d63
--- /dev/null
+++ b/llvm/test/Transforms/Attributor/read_write_returned_arguments_scc-dl-sentinel.ll
@@ -0,0 +1,550 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-annotate-decl-cs  -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-annotate-decl-cs  -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL,TUNIT-DL
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs  -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL,CGSCC-DL
+;
+; This is an evolved example to stress test SCC parameter attribute propagation.
+; The SCC in this test is made up of the following six function, three of which
+; are internal and three externally visible:
+;
+; static int *internal_ret0_nw(int *n0, int *w0);
+; static int *internal_ret1_rw(int *r0, int *w0);
+; static int *internal_ret1_rrw(int *r0, int *r1, int *w0);
+;        int *external_ret2_nrw(int *n0, int *r0, int *w0);
+;        int *external_sink_ret2_nrw(int *n0, int *r0, int *w0);
+;        int *external_source_ret2_nrw(int *n0, int *r0, int *w0);
+;
+; The top four functions call each other while the "sink" function will not
+; call anything and the "source" function will not be called in this module.
+; The names of the functions define the returned parameter (X for "_retX_"),
+; as well as how the parameters are (transitively) used (n = readnone,
+; r = readonly, w = writeonly).
+;
+; What we should see is something along the lines of:
+;   1 - Number of functions marked as norecurse
+;   6 - Number of functions marked argmemonly
+;   6 - Number of functions marked as nounwind
+;  16 - Number of arguments marked nocapture
+;   4 - Number of arguments marked readnone
+;   6 - Number of arguments marked writeonly
+;   6 - Number of arguments marked readonly
+;   6 - Number of arguments marked returned
+;
+
+define ptr @external_ret2_nrw(ptr %n0, ptr %r0, ptr %w0) {
+; TUNIT: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; TUNIT-LABEL: define {{[^@]+}}@external_ret2_nrw
+; TUNIT-SAME: (ptr nofree [[N0:%.*]], ptr nofree [[R0:%.*]], ptr nofree returned [[W0:%.*]]) #[[ATTR0:[0-9]+]] {
+; TUNIT-NEXT:  entry:
+; TUNIT-NEXT:    [[CALL:%.*]] = call ptr @internal_ret0_nw(ptr nofree [[N0]], ptr nofree [[W0]]) #[[ATTR3:[0-9]+]]
+; TUNIT-NEXT:    [[CALL1:%.*]] = call ptr @internal_ret1_rrw(ptr nofree noundef align 4 [[R0]], ptr nofree align 4 [[R0]], ptr nofree [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL2:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree [[N0]], ptr nocapture nofree readonly align 4 [[R0]], ptr nofree writeonly "no-capture-maybe-returned" [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL3:%.*]] = call ptr @internal_ret1_rw(ptr nofree noundef align 4 [[R0]], ptr nofree [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    ret ptr [[W0]]
+;
+; TUNIT-DL: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; TUNIT-DL-LABEL: define {{[^@]+}}@external_ret2_nrw
+; TUNIT-DL-SAME: (ptr nocapture nofree nonnull readnone [[N0:%.*]], ptr nocapture nofree nonnull readonly [[R0:%.*]], ptr nofree nonnull returned writeonly "no-capture-maybe-returned" [[W0:%.*]]) #[[ATTR0:[0-9]+]] {
+; TUNIT-DL-NEXT:  entry:
+; TUNIT-DL-NEXT:    [[CALL:%.*]] = call ptr @internal_ret0_nw(ptr nocapture nofree nonnull writeonly [[W0]]) #[[ATTR4:[0-9]+]]
+; TUNIT-DL-NEXT:    unreachable
+;
+; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; CGSCC-LABEL: define {{[^@]+}}@external_ret2_nrw
+; CGSCC-SAME: (ptr nofree [[N0:%.*]], ptr nofree [[R0:%.*]], ptr nofree returned [[W0:%.*]]) #[[ATTR0:[0-9]+]] {
+; CGSCC-NEXT:  entry:
+; CGSCC-NEXT:    [[CALL:%.*]] = call ptr @internal_ret0_nw(ptr nofree [[N0]], ptr nofree [[W0]]) #[[ATTR2:[0-9]+]]
+; CGSCC-NEXT:    [[CALL1:%.*]] = call ptr @internal_ret1_rrw(ptr nofree noundef align 4 [[R0]], ptr nofree align 4 [[R0]], ptr nofree [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL2:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree [[N0]], ptr nocapture nofree readonly align 4 [[R0]], ptr nofree writeonly [[W0]]) #[[ATTR3:[0-9]+]]
+; CGSCC-NEXT:    [[CALL3:%.*]] = call ptr @internal_ret1_rw(ptr nofree noundef align 4 [[R0]], ptr nofree [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    ret ptr [[W0]]
+;
+; CGSCC-DL: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; CGSCC-DL-LABEL: define {{[^@]+}}@external_ret2_nrw
+; CGSCC-DL-SAME: (ptr nocapture nofree nonnull readnone [[N0:%.*]], ptr nocapture nofree nonnull readonly [[R0:%.*]], ptr nofree nonnull returned [[W0:%.*]]) #[[ATTR0:[0-9]+]] {
+; CGSCC-DL-NEXT:  entry:
+; CGSCC-DL-NEXT:    [[CALL:%.*]] = call ptr @internal_ret0_nw(ptr noalias nocapture nofree nonnull readnone [[N0]], ptr nofree nonnull [[W0]]) #[[ATTR3:[0-9]+]]
+; CGSCC-DL-NEXT:    unreachable
+;
+entry:
+  %call = call ptr @internal_ret0_nw(ptr %n0, ptr %w0)
+  %call1 = call ptr @internal_ret1_rrw(ptr %r0, ptr %r0, ptr %w0)
+  %call2 = call ptr @external_sink_ret2_nrw(ptr %n0, ptr %r0, ptr %w0)
+  %call3 = call ptr @internal_ret1_rw(ptr %r0, ptr %w0)
+  ret ptr %call3
+}
+
+define internal ptr @internal_ret0_nw(ptr %n0, ptr %w0) {
+; TUNIT: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; TUNIT-LABEL: define {{[^@]+}}@internal_ret0_nw
+; TUNIT-SAME: (ptr nofree [[N0:%.*]], ptr nofree [[W0:%.*]]) #[[ATTR0]] {
+; TUNIT-NEXT:  entry:
+; TUNIT-NEXT:    [[R0:%.*]] = alloca i32, align 4
+; TUNIT-NEXT:    [[R1:%.*]] = alloca i32, align 4
+; TUNIT-NEXT:    [[TOBOOL:%.*]] = icmp ne ptr [[N0]], null
+; TUNIT-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; TUNIT:       if.then:
+; TUNIT-NEXT:    br label [[RETURN:%.*]]
+; TUNIT:       if.end:
+; TUNIT-NEXT:    store i32 3, ptr [[R0]], align 4
+; TUNIT-NEXT:    store i32 5, ptr [[R1]], align 4
+; TUNIT-NEXT:    store i32 1, ptr [[W0]], align 4
+; TUNIT-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL1:%.*]] = call ptr @external_ret2_nrw(ptr nofree nonnull [[N0]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL2:%.*]] = call ptr @external_ret2_nrw(ptr nofree nonnull [[N0]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL3:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree nonnull [[N0]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL4:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree nonnull [[N0]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL5:%.*]] = call ptr @internal_ret0_nw(ptr nofree nonnull [[N0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    br label [[RETURN]]
+; TUNIT:       return:
+; TUNIT-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[CALL5]], [[IF_END]] ], [ [[N0]], [[IF_THEN]] ]
+; TUNIT-NEXT:    ret ptr [[RETVAL_0]]
+;
+; TUNIT-DL: Function Attrs: nofree noreturn nosync nounwind memory(argmem: readwrite)
+; TUNIT-DL-LABEL: define {{[^@]+}}@internal_ret0_nw
+; TUNIT-DL-SAME: (ptr nocapture nofree nonnull writeonly [[W0:%.*]]) #[[ATTR1:[0-9]+]] {
+; TUNIT-DL-NEXT:  entry:
+; TUNIT-DL-NEXT:    [[R0:%.*]] = alloca i32, align 4
+; TUNIT-DL-NEXT:    [[R1:%.*]] = alloca i32, align 4
+; TUNIT-DL-NEXT:    br label [[IF_END:%.*]]
+; TUNIT-DL:       if.then:
+; TUNIT-DL-NEXT:    unreachable
+; TUNIT-DL:       if.end:
+; TUNIT-DL-NEXT:    store i32 3, ptr [[R0]], align 4
+; TUNIT-DL-NEXT:    store i32 5, ptr [[R1]], align 4
+; TUNIT-DL-NEXT:    store i32 1, ptr [[W0]], align 4
+; TUNIT-DL-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rrw(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR5:[0-9]+]]
+; TUNIT-DL-NEXT:    [[CALL1:%.*]] = call ptr @external_ret2_nrw(ptr noalias nocapture nofree nonnull readnone undef, ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[W0]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[CALL2:%.*]] = call ptr @external_ret2_nrw(ptr noalias nocapture nofree nonnull readnone undef, ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[W0]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[CALL3:%.*]] = call ptr @external_sink_ret2_nrw(ptr noalias nocapture nofree nonnull readnone undef, ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[W0]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[CALL4:%.*]] = call ptr @external_sink_ret2_nrw(ptr noalias nocapture nofree nonnull readnone undef, ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[W0]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[CALL5:%.*]] = call ptr @internal_ret0_nw(ptr nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR4]]
+; TUNIT-DL-NEXT:    unreachable
+; TUNIT-DL:       return:
+; TUNIT-DL-NEXT:    unreachable
+;
+; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; CGSCC-LABEL: define {{[^@]+}}@internal_ret0_nw
+; CGSCC-SAME: (ptr nofree [[N0:%.*]], ptr nofree [[W0:%.*]]) #[[ATTR0]] {
+; CGSCC-NEXT:  entry:
+; CGSCC-NEXT:    [[R0:%.*]] = alloca i32, align 4
+; CGSCC-NEXT:    [[R1:%.*]] = alloca i32, align 4
+; CGSCC-NEXT:    [[TOBOOL:%.*]] = icmp ne ptr [[N0]], null
+; CGSCC-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; CGSCC:       if.then:
+; CGSCC-NEXT:    br label [[RETURN:%.*]]
+; CGSCC:       if.end:
+; CGSCC-NEXT:    store i32 3, ptr [[R0]], align 4
+; CGSCC-NEXT:    store i32 5, ptr [[R1]], align 4
+; CGSCC-NEXT:    store i32 1, ptr [[W0]], align 4
+; CGSCC-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL1:%.*]] = call ptr @external_ret2_nrw(ptr nofree nonnull [[N0]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL2:%.*]] = call ptr @external_ret2_nrw(ptr nofree nonnull [[N0]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL3:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree nonnull [[N0]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR4:[0-9]+]]
+; CGSCC-NEXT:    [[CALL4:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree nonnull [[N0]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR4]]
+; CGSCC-NEXT:    [[CALL5:%.*]] = call ptr @internal_ret0_nw(ptr nofree nonnull [[N0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    br label [[RETURN]]
+; CGSCC:       return:
+; CGSCC-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[CALL5]], [[IF_END]] ], [ [[N0]], [[IF_THEN]] ]
+; CGSCC-NEXT:    ret ptr [[RETVAL_0]]
+;
+; CGSCC-DL: Function Attrs: nofree noreturn nosync nounwind memory(argmem: readwrite)
+; CGSCC-DL-LABEL: define {{[^@]+}}@internal_ret0_nw
+; CGSCC-DL-SAME: (ptr noalias nocapture nofree nonnull readnone [[N0:%.*]], ptr nofree nonnull [[W0:%.*]]) #[[ATTR1:[0-9]+]] {
+; CGSCC-DL-NEXT:  entry:
+; CGSCC-DL-NEXT:    [[R0:%.*]] = alloca i32, align 4
+; CGSCC-DL-NEXT:    [[R1:%.*]] = alloca i32, align 4
+; CGSCC-DL-NEXT:    br label [[IF_END:%.*]]
+; CGSCC-DL:       if.then:
+; CGSCC-DL-NEXT:    unreachable
+; CGSCC-DL:       if.end:
+; CGSCC-DL-NEXT:    store i32 3, ptr [[R0]], align 4
+; CGSCC-DL-NEXT:    store i32 5, ptr [[R1]], align 4
+; CGSCC-DL-NEXT:    store i32 1, ptr [[W0]], align 4
+; CGSCC-DL-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rrw(ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR4:[0-9]+]]
+; CGSCC-DL-NEXT:    [[CALL1:%.*]] = call ptr @external_ret2_nrw(ptr noalias nocapture nofree nonnull readnone [[N0]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR4]]
+; CGSCC-DL-NEXT:    [[CALL2:%.*]] = call ptr @external_ret2_nrw(ptr noalias nocapture nofree nonnull readnone [[N0]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR4]]
+; CGSCC-DL-NEXT:    [[CALL3:%.*]] = call ptr @external_sink_ret2_nrw(ptr noalias nocapture nofree nonnull readnone [[N0]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR5:[0-9]+]]
+; CGSCC-DL-NEXT:    [[CALL4:%.*]] = call ptr @external_sink_ret2_nrw(ptr noalias nocapture nofree nonnull readnone [[N0]], ptr noalias nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR5]]
+; CGSCC-DL-NEXT:    [[CALL5:%.*]] = call ptr @internal_ret0_nw(ptr noalias nocapture nofree nonnull readnone [[N0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; CGSCC-DL-NEXT:    unreachable
+; CGSCC-DL:       return:
+; CGSCC-DL-NEXT:    unreachable
+;
+entry:
+  %r0 = alloca i32, align 4
+  %r1 = alloca i32, align 4
+  %tobool = icmp ne ptr %n0, null
+  br i1 %tobool, label %if.end, label %if.then
+
+if.then:                                          ; preds = %entry
+  br label %return
+
+if.end:                                           ; preds = %entry
+  store i32 3, ptr %r0, align 4
+  store i32 5, ptr %r1, align 4
+  store i32 1, ptr %w0, align 4
+  %call = call ptr @internal_ret1_rrw(ptr %r0, ptr %r1, ptr %w0)
+  %call1 = call ptr @external_ret2_nrw(ptr %n0, ptr %r0, ptr %w0)
+  %call2 = call ptr @external_ret2_nrw(ptr %n0, ptr %r1, ptr %w0)
+  %call3 = call ptr @external_sink_ret2_nrw(ptr %n0, ptr %r0, ptr %w0)
+  %call4 = call ptr @external_sink_ret2_nrw(ptr %n0, ptr %r1, ptr %w0)
+  %call5 = call ptr @internal_ret0_nw(ptr %n0, ptr %w0)
+  br label %return
+
+return:                                           ; preds = %if.end, %if.then
+  %retval.0 = phi ptr [ %call5, %if.end ], [ %n0, %if.then ]
+  ret ptr %retval.0
+}
+
+define internal ptr @internal_ret1_rrw(ptr %r0, ptr %r1, ptr %w0) {
+; TUNIT: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; TUNIT-LABEL: define {{[^@]+}}@internal_ret1_rrw
+; TUNIT-SAME: (ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0:%.*]], ptr nofree align 4 [[R1:%.*]], ptr nofree [[W0:%.*]]) #[[ATTR0]] {
+; TUNIT-NEXT:  entry:
+; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr [[R0]], align 4
+; TUNIT-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
+; TUNIT-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; TUNIT:       if.then:
+; TUNIT-NEXT:    br label [[RETURN:%.*]]
+; TUNIT:       if.end:
+; TUNIT-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[TMP1:%.*]] = load i32, ptr [[R0]], align 4
+; TUNIT-NEXT:    [[TMP2:%.*]] = load i32, ptr [[R1]], align 4
+; TUNIT-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP1]], [[TMP2]]
+; TUNIT-NEXT:    store i32 [[ADD]], ptr [[W0]], align 4
+; TUNIT-NEXT:    [[CALL1:%.*]] = call ptr @internal_ret1_rw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL2:%.*]] = call ptr @internal_ret0_nw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL3:%.*]] = call ptr @internal_ret0_nw(ptr nofree nonnull align 4 dereferenceable(4) [[W0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL4:%.*]] = call ptr @external_ret2_nrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL5:%.*]] = call ptr @external_ret2_nrw(ptr nofree nonnull align 4 dereferenceable(4) [[R1]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL6:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nocapture nofree nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL7:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree nonnull align 4 dereferenceable(4) [[R1]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL8:%.*]] = call ptr @internal_ret0_nw(ptr nofree nonnull align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    br label [[RETURN]]
+; TUNIT:       return:
+; TUNIT-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[CALL8]], [[IF_END]] ], [ [[R1]], [[IF_THEN]] ]
+; TUNIT-NEXT:    ret ptr undef
+;
+; TUNIT-DL: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; TUNIT-DL-LABEL: define {{[^@]+}}@internal_ret1_rrw
+; TUNIT-DL-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0:%.*]], ptr nocapture nofree nonnull readonly align 4 [[R1:%.*]], ptr nocapture nofree nonnull writeonly [[W0:%.*]]) #[[ATTR0]] {
+; TUNIT-DL-NEXT:  entry:
+; TUNIT-DL-NEXT:    [[TMP0:%.*]] = load i32, ptr [[R0]], align 4
+; TUNIT-DL-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
+; TUNIT-DL-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; TUNIT-DL:       if.then:
+; TUNIT-DL-NEXT:    br label [[RETURN:%.*]]
+; TUNIT-DL:       if.end:
+; TUNIT-DL-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rw(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull writeonly "no-capture-maybe-returned" [[W0]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[TMP1:%.*]] = load i32, ptr [[R0]], align 4
+; TUNIT-DL-NEXT:    [[TMP2:%.*]] = load i32, ptr [[R1]], align 4
+; TUNIT-DL-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP1]], [[TMP2]]
+; TUNIT-DL-NEXT:    store i32 [[ADD]], ptr [[W0]], align 4
+; TUNIT-DL-NEXT:    [[CALL1:%.*]] = call ptr @internal_ret1_rw(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[W0]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[CALL2:%.*]] = call ptr @internal_ret0_nw(ptr nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR4]]
+; TUNIT-DL-NEXT:    unreachable
+; TUNIT-DL:       return:
+; TUNIT-DL-NEXT:    ret ptr undef
+;
+; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; CGSCC-LABEL: define {{[^@]+}}@internal_ret1_rrw
+; CGSCC-SAME: (ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0:%.*]], ptr nofree align 4 [[R1:%.*]], ptr nofree [[W0:%.*]]) #[[ATTR0]] {
+; CGSCC-NEXT:  entry:
+; CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr [[R0]], align 4
+; CGSCC-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
+; CGSCC-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; CGSCC:       if.then:
+; CGSCC-NEXT:    br label [[RETURN:%.*]]
+; CGSCC:       if.end:
+; CGSCC-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[TMP1:%.*]] = load i32, ptr [[R0]], align 4
+; CGSCC-NEXT:    [[TMP2:%.*]] = load i32, ptr [[R1]], align 4
+; CGSCC-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP1]], [[TMP2]]
+; CGSCC-NEXT:    store i32 [[ADD]], ptr [[W0]], align 4
+; CGSCC-NEXT:    [[CALL1:%.*]] = call ptr @internal_ret1_rw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL2:%.*]] = call ptr @internal_ret0_nw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL3:%.*]] = call ptr @internal_ret0_nw(ptr nofree nonnull align 4 dereferenceable(4) [[W0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL4:%.*]] = call ptr @external_ret2_nrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL5:%.*]] = call ptr @external_ret2_nrw(ptr nofree nonnull align 4 dereferenceable(4) [[R1]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL6:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nocapture nofree nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR4]]
+; CGSCC-NEXT:    [[CALL7:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree nonnull align 4 dereferenceable(4) [[R1]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR4]]
+; CGSCC-NEXT:    [[CALL8:%.*]] = call ptr @internal_ret0_nw(ptr nofree nonnull align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    br label [[RETURN]]
+; CGSCC:       return:
+; CGSCC-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[CALL8]], [[IF_END]] ], [ [[R1]], [[IF_THEN]] ]
+; CGSCC-NEXT:    ret ptr undef
+;
+; CGSCC-DL: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; CGSCC-DL-LABEL: define {{[^@]+}}@internal_ret1_rrw
+; CGSCC-DL-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0:%.*]], ptr nocapture nofree nonnull readonly align 4 [[R1:%.*]], ptr nofree nonnull [[W0:%.*]]) #[[ATTR0]] {
+; CGSCC-DL-NEXT:  entry:
+; CGSCC-DL-NEXT:    [[TMP0:%.*]] = load i32, ptr [[R0]], align 4
+; CGSCC-DL-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
+; CGSCC-DL-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; CGSCC-DL:       if.then:
+; CGSCC-DL-NEXT:    br label [[RETURN:%.*]]
+; CGSCC-DL:       if.end:
+; CGSCC-DL-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rw(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull [[W0]]) #[[ATTR4]]
+; CGSCC-DL-NEXT:    [[TMP1:%.*]] = load i32, ptr [[R0]], align 4
+; CGSCC-DL-NEXT:    [[TMP2:%.*]] = load i32, ptr [[R1]], align 4
+; CGSCC-DL-NEXT:    [[ADD:%.*]] = add nsw i32 [[TMP1]], [[TMP2]]
+; CGSCC-DL-NEXT:    store i32 [[ADD]], ptr [[W0]], align 4
+; CGSCC-DL-NEXT:    [[CALL1:%.*]] = call ptr @internal_ret1_rw(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R1]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR4]]
+; CGSCC-DL-NEXT:    [[CALL2:%.*]] = call ptr @internal_ret0_nw(ptr noalias nocapture nofree noundef nonnull readnone align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; CGSCC-DL-NEXT:    unreachable
+; CGSCC-DL:       return:
+; CGSCC-DL-NEXT:    ret ptr undef
+;
+entry:
+  %0 = load i32, ptr %r0, align 4
+  %tobool = icmp ne i32 %0, 0
+  br i1 %tobool, label %if.end, label %if.then
+
+if.then:                                          ; preds = %entry
+  br label %return
+
+if.end:                                           ; preds = %entry
+  %call = call ptr @internal_ret1_rw(ptr %r0, ptr %w0)
+  %1 = load i32, ptr %r0, align 4
+  %2 = load i32, ptr %r1, align 4
+  %add = add nsw i32 %1, %2
+  store i32 %add, ptr %w0, align 4
+  %call1 = call ptr @internal_ret1_rw(ptr %r1, ptr %w0)
+  %call2 = call ptr @internal_ret0_nw(ptr %r0, ptr %w0)
+  %call3 = call ptr @internal_ret0_nw(ptr %w0, ptr %w0)
+  %call4 = call ptr @external_ret2_nrw(ptr %r0, ptr %r1, ptr %w0)
+  %call5 = call ptr @external_ret2_nrw(ptr %r1, ptr %r0, ptr %w0)
+  %call6 = call ptr @external_sink_ret2_nrw(ptr %r0, ptr %r1, ptr %w0)
+  %call7 = call ptr @external_sink_ret2_nrw(ptr %r1, ptr %r0, ptr %w0)
+  %call8 = call ptr @internal_ret0_nw(ptr %r1, ptr %w0)
+  br label %return
+
+return:                                           ; preds = %if.end, %if.then
+  %retval.0 = phi ptr [ %call8, %if.end ], [ %r1, %if.then ]
+  ret ptr %retval.0
+}
+
+define ptr @external_sink_ret2_nrw(ptr %n0, ptr %r0, ptr %w0) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
+; CHECK-LABEL: define {{[^@]+}}@external_sink_ret2_nrw
+; CHECK-SAME: (ptr nofree [[N0:%.*]], ptr nocapture nofree readonly [[R0:%.*]], ptr nofree returned writeonly "no-capture-maybe-returned" [[W0:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp ne ptr [[N0]], null
+; CHECK-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; CHECK:       if.then:
+; CHECK-NEXT:    br label [[RETURN:%.*]]
+; CHECK:       if.end:
+; CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[R0]], align 4
+; CHECK-NEXT:    store i32 [[TMP0]], ptr [[W0]], align 4
+; CHECK-NEXT:    br label [[RETURN]]
+; CHECK:       return:
+; CHECK-NEXT:    ret ptr [[W0]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)
+; CHECK-DL-LABEL: define {{[^@]+}}@external_sink_ret2_nrw
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone [[N0:%.*]], ptr nocapture nofree nonnull readonly [[R0:%.*]], ptr nofree nonnull returned writeonly "no-capture-maybe-returned" [[W0:%.*]]) #[[ATTR2:[0-9]+]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[IF_END:%.*]]
+; CHECK-DL:       if.then:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       if.end:
+; CHECK-DL-NEXT:    [[TMP0:%.*]] = load i32, ptr [[R0]], align 4
+; CHECK-DL-NEXT:    store i32 [[TMP0]], ptr [[W0]], align 4
+; CHECK-DL-NEXT:    br label [[RETURN:%.*]]
+; CHECK-DL:       return:
+; CHECK-DL-NEXT:    ret ptr [[W0]]
+;
+entry:
+  %tobool = icmp ne ptr %n0, null
+  br i1 %tobool, label %if.end, label %if.then
+
+if.then:                                          ; preds = %entry
+  br label %return
+
+if.end:                                           ; preds = %entry
+  %0 = load i32, ptr %r0, align 4
+  store i32 %0, ptr %w0, align 4
+  br label %return
+
+return:                                           ; preds = %if.end, %if.then
+  ret ptr %w0
+}
+
+define internal ptr @internal_ret1_rw(ptr %r0, ptr %w0) {
+; TUNIT: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; TUNIT-LABEL: define {{[^@]+}}@internal_ret1_rw
+; TUNIT-SAME: (ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0:%.*]], ptr nofree [[W0:%.*]]) #[[ATTR0]] {
+; TUNIT-NEXT:  entry:
+; TUNIT-NEXT:    [[TMP0:%.*]] = load i32, ptr [[R0]], align 4
+; TUNIT-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
+; TUNIT-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; TUNIT:       if.then:
+; TUNIT-NEXT:    br label [[RETURN:%.*]]
+; TUNIT:       if.end:
+; TUNIT-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[TMP1:%.*]] = load i32, ptr [[R0]], align 4
+; TUNIT-NEXT:    store i32 [[TMP1]], ptr [[W0]], align 4
+; TUNIT-NEXT:    [[CALL1:%.*]] = call ptr @internal_ret0_nw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL2:%.*]] = call ptr @internal_ret0_nw(ptr nofree nonnull align 4 dereferenceable(4) [[W0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL3:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull writeonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    [[CALL4:%.*]] = call ptr @external_ret2_nrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    br label [[RETURN]]
+; TUNIT:       return:
+; TUNIT-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[CALL4]], [[IF_END]] ], [ [[W0]], [[IF_THEN]] ]
+; TUNIT-NEXT:    ret ptr [[RETVAL_0]]
+;
+; TUNIT-DL: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; TUNIT-DL-LABEL: define {{[^@]+}}@internal_ret1_rw
+; TUNIT-DL-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0:%.*]], ptr nofree nonnull returned writeonly "no-capture-maybe-returned" [[W0:%.*]]) #[[ATTR0]] {
+; TUNIT-DL-NEXT:  entry:
+; TUNIT-DL-NEXT:    [[TMP0:%.*]] = load i32, ptr [[R0]], align 4
+; TUNIT-DL-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
+; TUNIT-DL-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; TUNIT-DL:       if.then:
+; TUNIT-DL-NEXT:    br label [[RETURN:%.*]]
+; TUNIT-DL:       if.end:
+; TUNIT-DL-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rrw(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nocapture nofree nonnull writeonly [[W0]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[TMP1:%.*]] = load i32, ptr [[R0]], align 4
+; TUNIT-DL-NEXT:    store i32 [[TMP1]], ptr [[W0]], align 4
+; TUNIT-DL-NEXT:    [[CALL1:%.*]] = call ptr @internal_ret0_nw(ptr nocapture nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR4]]
+; TUNIT-DL-NEXT:    unreachable
+; TUNIT-DL:       return:
+; TUNIT-DL-NEXT:    ret ptr [[W0]]
+;
+; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; CGSCC-LABEL: define {{[^@]+}}@internal_ret1_rw
+; CGSCC-SAME: (ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0:%.*]], ptr nofree [[W0:%.*]]) #[[ATTR0]] {
+; CGSCC-NEXT:  entry:
+; CGSCC-NEXT:    [[TMP0:%.*]] = load i32, ptr [[R0]], align 4
+; CGSCC-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
+; CGSCC-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; CGSCC:       if.then:
+; CGSCC-NEXT:    br label [[RETURN:%.*]]
+; CGSCC:       if.end:
+; CGSCC-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[TMP1:%.*]] = load i32, ptr [[R0]], align 4
+; CGSCC-NEXT:    store i32 [[TMP1]], ptr [[W0]], align 4
+; CGSCC-NEXT:    [[CALL1:%.*]] = call ptr @internal_ret0_nw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL2:%.*]] = call ptr @internal_ret0_nw(ptr nofree nonnull align 4 dereferenceable(4) [[W0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    [[CALL3:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull writeonly align 4 dereferenceable(4) [[W0]]) #[[ATTR4]]
+; CGSCC-NEXT:    [[CALL4:%.*]] = call ptr @external_ret2_nrw(ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree noundef nonnull align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR2]]
+; CGSCC-NEXT:    br label [[RETURN]]
+; CGSCC:       return:
+; CGSCC-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[CALL4]], [[IF_END]] ], [ [[W0]], [[IF_THEN]] ]
+; CGSCC-NEXT:    ret ptr [[RETVAL_0]]
+;
+; CGSCC-DL: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; CGSCC-DL-LABEL: define {{[^@]+}}@internal_ret1_rw
+; CGSCC-DL-SAME: (ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0:%.*]], ptr nofree nonnull returned [[W0:%.*]]) #[[ATTR0]] {
+; CGSCC-DL-NEXT:  entry:
+; CGSCC-DL-NEXT:    [[TMP0:%.*]] = load i32, ptr [[R0]], align 4
+; CGSCC-DL-NEXT:    [[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
+; CGSCC-DL-NEXT:    br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+; CGSCC-DL:       if.then:
+; CGSCC-DL-NEXT:    br label [[RETURN:%.*]]
+; CGSCC-DL:       if.end:
+; CGSCC-DL-NEXT:    [[CALL:%.*]] = call ptr @internal_ret1_rrw(ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nocapture nofree noundef nonnull readonly align 4 dereferenceable(4) [[R0]], ptr nofree nonnull [[W0]]) #[[ATTR4]]
+; CGSCC-DL-NEXT:    [[TMP1:%.*]] = load i32, ptr [[R0]], align 4
+; CGSCC-DL-NEXT:    store i32 [[TMP1]], ptr [[W0]], align 4
+; CGSCC-DL-NEXT:    [[CALL1:%.*]] = call ptr @internal_ret0_nw(ptr noalias nocapture nofree noundef nonnull readnone align 4 dereferenceable(4) [[R0]], ptr nofree nonnull align 4 dereferenceable(4) [[W0]]) #[[ATTR3]]
+; CGSCC-DL-NEXT:    unreachable
+; CGSCC-DL:       return:
+; CGSCC-DL-NEXT:    ret ptr [[W0]]
+;
+entry:
+  %0 = load i32, ptr %r0, align 4
+  %tobool = icmp ne i32 %0, 0
+  br i1 %tobool, label %if.end, label %if.then
+
+if.then:                                          ; preds = %entry
+  br label %return
+
+if.end:                                           ; preds = %entry
+  %call = call ptr @internal_ret1_rrw(ptr %r0, ptr %r0, ptr %w0)
+  %1 = load i32, ptr %r0, align 4
+  store i32 %1, ptr %w0, align 4
+  %call1 = call ptr @internal_ret0_nw(ptr %r0, ptr %w0)
+  %call2 = call ptr @internal_ret0_nw(ptr %w0, ptr %w0)
+  %call3 = call ptr @external_sink_ret2_nrw(ptr %r0, ptr %r0, ptr %w0)
+  %call4 = call ptr @external_ret2_nrw(ptr %r0, ptr %r0, ptr %w0)
+  br label %return
+
+return:                                           ; preds = %if.end, %if.then
+  %retval.0 = phi ptr [ %call4, %if.end ], [ %w0, %if.then ]
+  ret ptr %retval.0
+}
+
+define ptr @external_source_ret2_nrw(ptr %n0, ptr %r0, ptr %w0) {
+; TUNIT: Function Attrs: nofree norecurse nosync nounwind memory(argmem: readwrite)
+; TUNIT-LABEL: define {{[^@]+}}@external_source_ret2_nrw
+; TUNIT-SAME: (ptr nofree [[N0:%.*]], ptr nofree [[R0:%.*]], ptr nofree returned [[W0:%.*]]) #[[ATTR2:[0-9]+]] {
+; TUNIT-NEXT:  entry:
+; TUNIT-NEXT:    [[CALL:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree [[N0]], ptr nocapture nofree readonly [[R0]], ptr nofree writeonly "no-capture-maybe-returned" [[W0]]) #[[ATTR4:[0-9]+]]
+; TUNIT-NEXT:    [[CALL1:%.*]] = call ptr @external_ret2_nrw(ptr nofree [[N0]], ptr nofree [[R0]], ptr nofree [[W0]]) #[[ATTR3]]
+; TUNIT-NEXT:    ret ptr [[W0]]
+;
+; TUNIT-DL: Function Attrs: nofree norecurse nosync nounwind memory(argmem: readwrite)
+; TUNIT-DL-LABEL: define {{[^@]+}}@external_source_ret2_nrw
+; TUNIT-DL-SAME: (ptr nocapture nofree nonnull readnone [[N0:%.*]], ptr nocapture nofree nonnull readonly [[R0:%.*]], ptr nofree nonnull returned writeonly "no-capture-maybe-returned" [[W0:%.*]]) #[[ATTR3:[0-9]+]] {
+; TUNIT-DL-NEXT:  entry:
+; TUNIT-DL-NEXT:    [[CALL:%.*]] = call ptr @external_sink_ret2_nrw(ptr noalias nocapture nofree nonnull readnone undef, ptr nocapture nofree nonnull readonly [[R0]], ptr nofree nonnull writeonly "no-capture-maybe-returned" [[W0]]) #[[ATTR6:[0-9]+]]
+; TUNIT-DL-NEXT:    [[CALL1:%.*]] = call ptr @external_ret2_nrw(ptr noalias nocapture nofree nonnull readnone undef, ptr nocapture nofree nonnull readonly [[R0]], ptr nofree nonnull writeonly "no-capture-maybe-returned" [[W0]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    ret ptr [[W0]]
+;
+; CGSCC: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; CGSCC-LABEL: define {{[^@]+}}@external_source_ret2_nrw
+; CGSCC-SAME: (ptr nofree [[N0:%.*]], ptr nofree [[R0:%.*]], ptr nofree [[W0:%.*]]) #[[ATTR0]] {
+; CGSCC-NEXT:  entry:
+; CGSCC-NEXT:    [[CALL:%.*]] = call ptr @external_sink_ret2_nrw(ptr nofree [[N0]], ptr nocapture nofree readonly [[R0]], ptr nofree writeonly [[W0]]) #[[ATTR5:[0-9]+]]
+; CGSCC-NEXT:    [[CALL1:%.*]] = call ptr @external_ret2_nrw(ptr nofree [[N0]], ptr nofree [[R0]], ptr nofree [[W0]]) #[[ATTR3]]
+; CGSCC-NEXT:    ret ptr [[CALL1]]
+;
+; CGSCC-DL: Function Attrs: nofree nosync nounwind memory(argmem: readwrite)
+; CGSCC-DL-LABEL: define {{[^@]+}}@external_source_ret2_nrw
+; CGSCC-DL-SAME: (ptr nocapture nofree nonnull readnone [[N0:%.*]], ptr nocapture nofree nonnull readonly align 4 [[R0:%.*]], ptr nofree nonnull align 4 [[W0:%.*]]) #[[ATTR0]] {
+; CGSCC-DL-NEXT:  entry:
+; CGSCC-DL-NEXT:    [[CALL:%.*]] = call ptr @external_sink_ret2_nrw(ptr noalias nocapture nofree nonnull readnone [[N0]], ptr nocapture nofree nonnull readonly align 4 [[R0]], ptr nofree nonnull writeonly align 4 [[W0]]) #[[ATTR6:[0-9]+]]
+; CGSCC-DL-NEXT:    [[CALL1:%.*]] = call nonnull ptr @external_ret2_nrw(ptr noalias nocapture nofree nonnull readnone [[N0]], ptr nocapture nofree nonnull readonly align 4 [[R0]], ptr nofree nonnull align 4 [[W0]]) #[[ATTR7:[0-9]+]]
+; CGSCC-DL-NEXT:    ret ptr [[CALL1]]
+;
+entry:
+  %call = call ptr @external_sink_ret2_nrw(ptr %n0, ptr %r0, ptr %w0)
+  %call1 = call ptr @external_ret2_nrw(ptr %n0, ptr %r0, ptr %w0)
+  ret ptr %call1
+}
+
+; Verify that we see only expected attribute sets, the above lines only check
+; for a subset relation.
+;.
+; TUNIT: attributes #[[ATTR0]] = { nofree nosync nounwind memory(argmem: readwrite) }
+; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
+; TUNIT: attributes #[[ATTR2]] = { nofree norecurse nosync nounwind memory(argmem: readwrite) }
+; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind }
+; TUNIT: attributes #[[ATTR4]] = { nofree nosync nounwind willreturn }
+;.
+; TUNIT-DL: attributes #[[ATTR0]] = { nofree nosync nounwind memory(argmem: readwrite) }
+; TUNIT-DL: attributes #[[ATTR1]] = { nofree noreturn nosync nounwind memory(argmem: readwrite) }
+; TUNIT-DL: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
+; TUNIT-DL: attributes #[[ATTR3]] = { nofree norecurse nosync nounwind memory(argmem: readwrite) }
+; TUNIT-DL: attributes #[[ATTR4]] = { nofree noreturn nosync nounwind }
+; TUNIT-DL: attributes #[[ATTR5]] = { nofree nosync nounwind }
+; TUNIT-DL: attributes #[[ATTR6]] = { nofree nosync nounwind willreturn }
+;.
+; CGSCC: attributes #[[ATTR0]] = { nofree nosync nounwind memory(argmem: readwrite) }
+; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
+; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind }
+; CGSCC: attributes #[[ATTR3]] = { nofree nounwind }
+; CGSCC: attributes #[[ATTR4]] = { nofree nounwind memory(readwrite) }
+; CGSCC: attributes #[[ATTR5]] = { nofree nounwind willreturn }
+;.
+; CGSCC-DL: attributes #[[ATTR0]] = { nofree nosync nounwind memory(argmem: readwrite) }
+; CGSCC-DL: attributes #[[ATTR1]] = { nofree noreturn nosync nounwind memory(argmem: readwrite) }
+; CGSCC-DL: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite) }
+; CGSCC-DL: attributes #[[ATTR3]] = { nofree noreturn nosync nounwind }
+; CGSCC-DL: attributes #[[ATTR4]] = { nofree nosync nounwind }
+; CGSCC-DL: attributes #[[ATTR5]] = { nofree nounwind memory(readwrite) }
+; CGSCC-DL: attributes #[[ATTR6]] = { nofree nounwind willreturn }
+; CGSCC-DL: attributes #[[ATTR7]] = { nofree nounwind }
+;.
diff --git a/llvm/test/Transforms/Attributor/returned-dl-sentinel.ll b/llvm/test/Transforms/Attributor/returned-dl-sentinel.ll
new file mode 100755
index 0000000000000..32e0aa180913f
--- /dev/null
+++ b/llvm/test/Transforms/Attributor/returned-dl-sentinel.ll
@@ -0,0 +1,1135 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-annotate-decl-cs  -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-annotate-decl-cs  -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL,TUNIT-DL
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs  -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL,CGSCC-DL
+;
+; Test cases specifically designed for the "returned" argument attribute.
+; We use FIXME's to indicate problems and missing attributes.
+;
+
+define ptr @ptr_sink_r0(ptr %r) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@ptr_sink_r0
+; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[R:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret ptr [[R]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@ptr_sink_r0
+; CHECK-DL-SAME: (ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[R:%.*]]) #[[ATTR0:[0-9]+]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret ptr [[R]]
+;
+entry:
+  ret ptr %r
+}
+
+define ptr @ptr_scc_r1(ptr %a, ptr %r, ptr %b) #0 {
+; TUNIT: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; TUNIT-LABEL: define {{[^@]+}}@ptr_scc_r1
+; TUNIT-SAME: (ptr nocapture nofree readnone [[A:%.*]], ptr nofree readnone returned "no-capture-maybe-returned" [[R:%.*]], ptr nocapture nofree readnone [[B:%.*]]) #[[ATTR1:[0-9]+]] {
+; TUNIT-NEXT:  entry:
+; TUNIT-NEXT:    [[CALL1:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[R]], ptr noalias nocapture nofree readnone [[A]], ptr noalias nofree readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5:[0-9]+]]
+; TUNIT-NEXT:    ret ptr [[R]]
+;
+; TUNIT-DL: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; TUNIT-DL-LABEL: define {{[^@]+}}@ptr_scc_r1
+; TUNIT-DL-SAME: (ptr nocapture nofree nonnull readnone [[A:%.*]], ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[R:%.*]], ptr nocapture nofree nonnull readnone [[B:%.*]]) #[[ATTR1:[0-9]+]] {
+; TUNIT-DL-NEXT:  entry:
+; TUNIT-DL-NEXT:    [[CALL1:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[R]], ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nofree nonnull readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5:[0-9]+]]
+; TUNIT-DL-NEXT:    ret ptr [[R]]
+;
+; CGSCC: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; CGSCC-LABEL: define {{[^@]+}}@ptr_scc_r1
+; CGSCC-SAME: (ptr nocapture nofree readnone [[A:%.*]], ptr nofree readnone returned [[R:%.*]], ptr nocapture nofree readnone [[B:%.*]]) #[[ATTR1:[0-9]+]] {
+; CGSCC-NEXT:  entry:
+; CGSCC-NEXT:    [[CALL1:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[R]], ptr noalias nocapture nofree readnone [[A]], ptr noalias nofree readnone [[R]]) #[[ATTR5:[0-9]+]]
+; CGSCC-NEXT:    ret ptr [[R]]
+;
+; CGSCC-DL: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; CGSCC-DL-LABEL: define {{[^@]+}}@ptr_scc_r1
+; CGSCC-DL-SAME: (ptr nocapture nofree nonnull readnone [[A:%.*]], ptr nofree nonnull readnone returned [[R:%.*]], ptr nocapture nofree nonnull readnone [[B:%.*]]) #[[ATTR1:[0-9]+]] {
+; CGSCC-DL-NEXT:  entry:
+; CGSCC-DL-NEXT:    [[CALL1:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[R]], ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nofree nonnull readnone [[R]]) #[[ATTR5:[0-9]+]]
+; CGSCC-DL-NEXT:    ret ptr [[R]]
+;
+entry:
+  %call = call ptr @ptr_sink_r0(ptr %r)
+  %call1 = call ptr @ptr_scc_r2(ptr %r, ptr %a, ptr %call)
+  ret ptr %call1
+}
+
+define ptr @ptr_scc_r2(ptr %a, ptr %b, ptr %r) #0 {
+; TUNIT: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; TUNIT-LABEL: define {{[^@]+}}@ptr_scc_r2
+; TUNIT-SAME: (ptr nocapture nofree readnone [[A:%.*]], ptr nocapture nofree readnone [[B:%.*]], ptr nofree readnone returned "no-capture-maybe-returned" [[R:%.*]]) #[[ATTR1]] {
+; TUNIT-NEXT:  entry:
+; TUNIT-NEXT:    [[CMP:%.*]] = icmp ugt ptr [[A]], [[B]]
+; TUNIT-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; TUNIT:       if.then:
+; TUNIT-NEXT:    [[CALL1:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[B]], ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nofree readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5]]
+; TUNIT-NEXT:    br label [[RETURN:%.*]]
+; TUNIT:       if.end:
+; TUNIT-NEXT:    [[CMP2:%.*]] = icmp ult ptr [[A]], [[B]]
+; TUNIT-NEXT:    br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END12:%.*]]
+; TUNIT:       if.then3:
+; TUNIT-NEXT:    [[CALL5:%.*]] = call ptr @ptr_scc_r1(ptr noalias nocapture nofree readnone [[A]], ptr noalias nofree nonnull readnone "no-capture-maybe-returned" [[B]], ptr noalias nocapture nofree readnone undef) #[[ATTR5]]
+; TUNIT-NEXT:    [[CALL6:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[R]], ptr noalias nocapture nofree readnone [[R]], ptr noalias nofree readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5]]
+; TUNIT-NEXT:    [[CALL7:%.*]] = call ptr @ptr_scc_r1(ptr noalias nocapture nofree readnone [[A]], ptr noalias nofree readnone "no-capture-maybe-returned" [[R]], ptr noalias nocapture nofree readnone undef) #[[ATTR5]]
+; TUNIT-NEXT:    [[CALL8:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[A]], ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nofree readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5]]
+; TUNIT-NEXT:    [[CALL9:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[B]], ptr noalias nocapture nofree readnone [[R]], ptr noalias nofree readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5]]
+; TUNIT-NEXT:    [[CALL11:%.*]] = call ptr @ptr_scc_r1(ptr noalias nocapture nofree readnone [[B]], ptr noalias nofree readnone "no-capture-maybe-returned" [[R]], ptr noalias nocapture nofree readnone undef) #[[ATTR5]]
+; TUNIT-NEXT:    br label [[RETURN]]
+; TUNIT:       if.end12:
+; TUNIT-NEXT:    [[CMP13:%.*]] = icmp eq ptr [[A]], [[B]]
+; TUNIT-NEXT:    br i1 [[CMP13]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+; TUNIT:       cond.true:
+; TUNIT-NEXT:    br label [[COND_END:%.*]]
+; TUNIT:       cond.false:
+; TUNIT-NEXT:    [[CALL14:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[A]], ptr noalias nocapture nofree readnone [[B]], ptr noalias nofree readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5]]
+; TUNIT-NEXT:    br label [[COND_END]]
+; TUNIT:       cond.end:
+; TUNIT-NEXT:    [[COND:%.*]] = phi ptr [ [[R]], [[COND_TRUE]] ], [ [[R]], [[COND_FALSE]] ]
+; TUNIT-NEXT:    br label [[RETURN]]
+; TUNIT:       return:
+; TUNIT-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[R]], [[IF_THEN]] ], [ [[R]], [[IF_THEN3]] ], [ [[R]], [[COND_END]] ]
+; TUNIT-NEXT:    ret ptr [[R]]
+;
+; TUNIT-DL: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; TUNIT-DL-LABEL: define {{[^@]+}}@ptr_scc_r2
+; TUNIT-DL-SAME: (ptr nocapture nofree nonnull readnone [[A:%.*]], ptr nocapture nofree nonnull readnone [[B:%.*]], ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[R:%.*]]) #[[ATTR1]] {
+; TUNIT-DL-NEXT:  entry:
+; TUNIT-DL-NEXT:    [[CMP:%.*]] = icmp ugt ptr [[A]], [[B]]
+; TUNIT-DL-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; TUNIT-DL:       if.then:
+; TUNIT-DL-NEXT:    [[CALL1:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nofree nonnull readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    br label [[RETURN:%.*]]
+; TUNIT-DL:       if.end:
+; TUNIT-DL-NEXT:    [[CMP2:%.*]] = icmp ult ptr [[A]], [[B]]
+; TUNIT-DL-NEXT:    br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END12:%.*]]
+; TUNIT-DL:       if.then3:
+; TUNIT-DL-NEXT:    [[CALL5:%.*]] = call nonnull ptr @ptr_scc_r1(ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nofree nonnull readnone "no-capture-maybe-returned" [[B]], ptr noalias nocapture nofree nonnull readnone undef) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[CALL6:%.*]] = call nonnull ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[R]], ptr noalias nocapture nofree nonnull readnone [[R]], ptr noalias nofree nonnull readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[CALL7:%.*]] = call nonnull ptr @ptr_scc_r1(ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nofree nonnull readnone "no-capture-maybe-returned" [[R]], ptr noalias nocapture nofree nonnull readnone undef) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[CALL8:%.*]] = call nonnull ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nofree nonnull readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[CALL9:%.*]] = call nonnull ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nocapture nofree nonnull readnone [[R]], ptr noalias nofree nonnull readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    [[CALL11:%.*]] = call ptr @ptr_scc_r1(ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nofree nonnull readnone "no-capture-maybe-returned" [[R]], ptr noalias nocapture nofree nonnull readnone undef) #[[ATTR5]]
+; TUNIT-DL-NEXT:    br label [[RETURN]]
+; TUNIT-DL:       if.end12:
+; TUNIT-DL-NEXT:    [[CMP13:%.*]] = icmp eq ptr [[A]], [[B]]
+; TUNIT-DL-NEXT:    br i1 [[CMP13]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+; TUNIT-DL:       cond.true:
+; TUNIT-DL-NEXT:    br label [[COND_END:%.*]]
+; TUNIT-DL:       cond.false:
+; TUNIT-DL-NEXT:    [[CALL14:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nofree nonnull readnone "no-capture-maybe-returned" [[R]]) #[[ATTR5]]
+; TUNIT-DL-NEXT:    br label [[COND_END]]
+; TUNIT-DL:       cond.end:
+; TUNIT-DL-NEXT:    [[COND:%.*]] = phi ptr [ [[R]], [[COND_TRUE]] ], [ [[R]], [[COND_FALSE]] ]
+; TUNIT-DL-NEXT:    br label [[RETURN]]
+; TUNIT-DL:       return:
+; TUNIT-DL-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[R]], [[IF_THEN]] ], [ [[R]], [[IF_THEN3]] ], [ [[R]], [[COND_END]] ]
+; TUNIT-DL-NEXT:    ret ptr [[R]]
+;
+; CGSCC: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; CGSCC-LABEL: define {{[^@]+}}@ptr_scc_r2
+; CGSCC-SAME: (ptr nocapture nofree readnone [[A:%.*]], ptr nocapture nofree readnone [[B:%.*]], ptr nofree readnone returned [[R:%.*]]) #[[ATTR1]] {
+; CGSCC-NEXT:  entry:
+; CGSCC-NEXT:    [[CMP:%.*]] = icmp ugt ptr [[A]], [[B]]
+; CGSCC-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CGSCC:       if.then:
+; CGSCC-NEXT:    [[CALL1:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[B]], ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nofree readnone [[R]]) #[[ATTR5]]
+; CGSCC-NEXT:    br label [[RETURN:%.*]]
+; CGSCC:       if.end:
+; CGSCC-NEXT:    [[CMP2:%.*]] = icmp ult ptr [[A]], [[B]]
+; CGSCC-NEXT:    br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END12:%.*]]
+; CGSCC:       if.then3:
+; CGSCC-NEXT:    [[CALL5:%.*]] = call ptr @ptr_scc_r1(ptr noalias nocapture nofree readnone [[A]], ptr noalias nofree nonnull readnone [[B]], ptr noalias nocapture nofree readnone undef) #[[ATTR5]]
+; CGSCC-NEXT:    [[CALL6:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[R]], ptr noalias nocapture nofree readnone [[R]], ptr noalias nofree readnone [[R]]) #[[ATTR5]]
+; CGSCC-NEXT:    [[CALL7:%.*]] = call ptr @ptr_scc_r1(ptr noalias nocapture nofree readnone [[A]], ptr noalias nofree readnone [[R]], ptr noalias nocapture nofree readnone undef) #[[ATTR5]]
+; CGSCC-NEXT:    [[CALL8:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[A]], ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nofree readnone [[R]]) #[[ATTR5]]
+; CGSCC-NEXT:    [[CALL9:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[B]], ptr noalias nocapture nofree readnone [[R]], ptr noalias nofree readnone [[R]]) #[[ATTR5]]
+; CGSCC-NEXT:    [[CALL11:%.*]] = call ptr @ptr_scc_r1(ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nofree readnone [[R]], ptr noalias nocapture nofree readnone undef) #[[ATTR5]]
+; CGSCC-NEXT:    br label [[RETURN]]
+; CGSCC:       if.end12:
+; CGSCC-NEXT:    [[CMP13:%.*]] = icmp eq ptr [[A]], [[B]]
+; CGSCC-NEXT:    br i1 [[CMP13]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+; CGSCC:       cond.true:
+; CGSCC-NEXT:    br label [[COND_END:%.*]]
+; CGSCC:       cond.false:
+; CGSCC-NEXT:    [[CALL14:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree readnone [[A]], ptr noalias nocapture nofree readnone [[B]], ptr noalias nofree readnone [[R]]) #[[ATTR5]]
+; CGSCC-NEXT:    br label [[COND_END]]
+; CGSCC:       cond.end:
+; CGSCC-NEXT:    [[COND:%.*]] = phi ptr [ [[R]], [[COND_TRUE]] ], [ [[R]], [[COND_FALSE]] ]
+; CGSCC-NEXT:    br label [[RETURN]]
+; CGSCC:       return:
+; CGSCC-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[R]], [[IF_THEN]] ], [ [[R]], [[IF_THEN3]] ], [ [[R]], [[COND_END]] ]
+; CGSCC-NEXT:    ret ptr [[R]]
+;
+; CGSCC-DL: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; CGSCC-DL-LABEL: define {{[^@]+}}@ptr_scc_r2
+; CGSCC-DL-SAME: (ptr nocapture nofree nonnull readnone [[A:%.*]], ptr nocapture nofree nonnull readnone [[B:%.*]], ptr nofree nonnull readnone returned [[R:%.*]]) #[[ATTR1]] {
+; CGSCC-DL-NEXT:  entry:
+; CGSCC-DL-NEXT:    [[CMP:%.*]] = icmp ugt ptr [[A]], [[B]]
+; CGSCC-DL-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CGSCC-DL:       if.then:
+; CGSCC-DL-NEXT:    [[CALL1:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nofree nonnull readnone [[R]]) #[[ATTR5]]
+; CGSCC-DL-NEXT:    br label [[RETURN:%.*]]
+; CGSCC-DL:       if.end:
+; CGSCC-DL-NEXT:    [[CMP2:%.*]] = icmp ult ptr [[A]], [[B]]
+; CGSCC-DL-NEXT:    br i1 [[CMP2]], label [[IF_THEN3:%.*]], label [[IF_END12:%.*]]
+; CGSCC-DL:       if.then3:
+; CGSCC-DL-NEXT:    [[CALL5:%.*]] = call nonnull ptr @ptr_scc_r1(ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nofree nonnull readnone [[B]], ptr noalias nocapture nofree nonnull readnone undef) #[[ATTR5]]
+; CGSCC-DL-NEXT:    [[CALL6:%.*]] = call nonnull ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[R]], ptr noalias nocapture nofree nonnull readnone [[R]], ptr noalias nofree nonnull readnone [[R]]) #[[ATTR5]]
+; CGSCC-DL-NEXT:    [[CALL7:%.*]] = call nonnull ptr @ptr_scc_r1(ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nofree nonnull readnone [[R]], ptr noalias nocapture nofree nonnull readnone undef) #[[ATTR5]]
+; CGSCC-DL-NEXT:    [[CALL8:%.*]] = call nonnull ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nofree nonnull readnone [[R]]) #[[ATTR5]]
+; CGSCC-DL-NEXT:    [[CALL9:%.*]] = call nonnull ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nocapture nofree nonnull readnone [[R]], ptr noalias nofree nonnull readnone [[R]]) #[[ATTR5]]
+; CGSCC-DL-NEXT:    [[CALL11:%.*]] = call ptr @ptr_scc_r1(ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nofree nonnull readnone [[R]], ptr noalias nocapture nofree nonnull readnone undef) #[[ATTR5]]
+; CGSCC-DL-NEXT:    br label [[RETURN]]
+; CGSCC-DL:       if.end12:
+; CGSCC-DL-NEXT:    [[CMP13:%.*]] = icmp eq ptr [[A]], [[B]]
+; CGSCC-DL-NEXT:    br i1 [[CMP13]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
+; CGSCC-DL:       cond.true:
+; CGSCC-DL-NEXT:    br label [[COND_END:%.*]]
+; CGSCC-DL:       cond.false:
+; CGSCC-DL-NEXT:    [[CALL14:%.*]] = call ptr @ptr_scc_r2(ptr noalias nocapture nofree nonnull readnone [[A]], ptr noalias nocapture nofree nonnull readnone [[B]], ptr noalias nofree nonnull readnone [[R]]) #[[ATTR5]]
+; CGSCC-DL-NEXT:    br label [[COND_END]]
+; CGSCC-DL:       cond.end:
+; CGSCC-DL-NEXT:    [[COND:%.*]] = phi ptr [ [[R]], [[COND_TRUE]] ], [ [[R]], [[COND_FALSE]] ]
+; CGSCC-DL-NEXT:    br label [[RETURN]]
+; CGSCC-DL:       return:
+; CGSCC-DL-NEXT:    [[RETVAL_0:%.*]] = phi ptr [ [[R]], [[IF_THEN]] ], [ [[R]], [[IF_THEN3]] ], [ [[R]], [[COND_END]] ]
+; CGSCC-DL-NEXT:    ret ptr [[R]]
+;
+entry:
+  %cmp = icmp ugt ptr %a, %b
+  br i1 %cmp, label %if.then, label %if.end
+
+if.then:                                          ; preds = %entry
+  %call = call ptr @ptr_sink_r0(ptr %r)
+  %call1 = call ptr @ptr_scc_r2(ptr %b, ptr %a, ptr %call)
+  br label %return
+
+if.end:                                           ; preds = %entry
+  %cmp2 = icmp ult ptr %a, %b
+  br i1 %cmp2, label %if.then3, label %if.end12
+
+if.then3:                                         ; preds = %if.end
+  %call4 = call ptr @ptr_sink_r0(ptr %b)
+  %call5 = call ptr @ptr_scc_r1(ptr %a, ptr %b, ptr %r)
+  %call6 = call ptr @ptr_scc_r2(ptr %r, ptr %r, ptr %r)
+  %call7 = call ptr @ptr_scc_r1(ptr %a, ptr %call6, ptr %r)
+  %call8 = call ptr @ptr_scc_r2(ptr %a, ptr %b, ptr %r)
+  %call9 = call ptr @ptr_scc_r2(ptr %call5, ptr %call7, ptr %call8)
+  %call10 = call ptr @ptr_scc_r1(ptr %a, ptr %b, ptr %r)
+  %call11 = call ptr @ptr_scc_r1(ptr %call4, ptr %call9, ptr %call10)
+  br label %return
+
+if.end12:                                         ; preds = %if.end
+  %cmp13 = icmp eq ptr %a, %b
+  br i1 %cmp13, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %if.end12
+  br label %cond.end
+
+cond.false:                                       ; preds = %if.end12
+  %call14 = call ptr @ptr_scc_r2(ptr %a, ptr %b, ptr %r)
+  br label %cond.end
+
+cond.end:                                         ; preds = %cond.false, %cond.true
+  %cond = phi ptr [ %r, %cond.true ], [ %call14, %cond.false ]
+  br label %return
+
+return:                                           ; preds = %cond.end, %if.then3, %if.then
+  %retval.0 = phi ptr [ %call1, %if.then ], [ %call11, %if.then3 ], [ %cond, %cond.end ]
+  ret ptr %retval.0
+}
+
+
+; TEST a no-return singleton SCC
+;
+; int* rt0(int *a) {
+;   return *a ? a : rt0(a);
+; }
+;
+define ptr @rt0(ptr %a) #0 {
+; CHECK: Function Attrs: nofree noinline nosync nounwind memory(argmem: read) uwtable
+; CHECK-LABEL: define {{[^@]+}}@rt0
+; CHECK-SAME: (ptr nofree noundef nonnull readonly returned align 4 dereferenceable(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR2:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @rt0(ptr nofree noundef nonnull readonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[A]]) #[[ATTR6:[0-9]+]]
+; CHECK-NEXT:    ret ptr [[A]]
+;
+; CHECK-DL: Function Attrs: nofree noinline nosync nounwind memory(argmem: read) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@rt0
+; CHECK-DL-SAME: (ptr nofree noundef nonnull readonly returned align 4 dereferenceable(4) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR2:[0-9]+]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    [[CALL:%.*]] = call ptr @rt0(ptr nofree noundef nonnull readonly align 4 dereferenceable(4) "no-capture-maybe-returned" [[A]]) #[[ATTR6:[0-9]+]]
+; CHECK-DL-NEXT:    ret ptr [[A]]
+;
+entry:
+  %v = load i32, ptr %a, align 4
+  %tobool = icmp ne i32 %v, 0
+  %call = call ptr @rt0(ptr %a)
+  %sel = select i1 %tobool, ptr %a, ptr %call
+  ret ptr %sel
+}
+
+; TEST a no-return singleton SCC
+;
+; int* rt1(int *a) {
+;   return *a ? undef : rt1(a);
+; }
+;
+define ptr @rt1(ptr %a) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@rt1
+; CHECK-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR3:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret ptr undef
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@rt1
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone align 4 dereferenceable(4) [[A:%.*]]) #[[ATTR3:[0-9]+]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret ptr undef
+;
+entry:
+  %v = load i32, ptr %a, align 4
+  %tobool = icmp ne i32 %v, 0
+  %call = call ptr @rt1(ptr %a)
+  %sel = select i1 %tobool, ptr undef, ptr %call
+  ret ptr %sel
+}
+
+; TEST another SCC test
+;
+define ptr @rt2_helper(ptr %a) #0 {
+; CHECK: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@rt2_helper
+; CHECK-SAME: (ptr nofree readnone returned [[A:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @rt2(ptr noalias nofree readnone [[A]], ptr noalias nofree readnone "no-capture-maybe-returned" [[A]]) #[[ATTR5:[0-9]+]]
+; CHECK-NEXT:    ret ptr [[A]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@rt2_helper
+; CHECK-DL-SAME: (ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret ptr [[A]]
+;
+entry:
+  %call = call ptr @rt2(ptr %a, ptr %a)
+  ret ptr %call
+}
+
+define ptr @rt2(ptr %a, ptr %b) #0 {
+; CHECK: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@rt2
+; CHECK-SAME: (ptr nofree readnone [[A:%.*]], ptr nofree readnone "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[A]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CHECK:       if.then:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @rt2_helper(ptr noalias nofree readnone [[A]]) #[[ATTR5]]
+; CHECK-NEXT:    br label [[IF_END]]
+; CHECK:       if.end:
+; CHECK-NEXT:    [[SEL:%.*]] = phi ptr [ [[B]], [[ENTRY:%.*]] ], [ [[A]], [[IF_THEN]] ]
+; CHECK-NEXT:    ret ptr [[SEL]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@rt2
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone [[A:%.*]], ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[IF_END:%.*]]
+; CHECK-DL:       if.then:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       if.end:
+; CHECK-DL-NEXT:    ret ptr [[B]]
+;
+entry:
+  %cmp = icmp eq ptr %a, null
+  br i1 %cmp, label %if.then, label %if.end
+
+if.then:
+  %call = call ptr @rt2_helper(ptr %a)
+  br label %if.end
+
+if.end:
+  %sel = phi ptr [ %b, %entry], [%call, %if.then]
+  ret ptr %sel
+}
+
+; TEST another SCC test
+;
+define ptr @rt3_helper(ptr %a, ptr %b) #0 {
+; CHECK: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@rt3_helper
+; CHECK-SAME: (ptr nocapture nofree readnone [[A:%.*]], ptr nofree readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @rt3(ptr noalias nocapture nofree readnone [[A]], ptr noalias nofree readnone "no-capture-maybe-returned" [[B]]) #[[ATTR5]]
+; CHECK-NEXT:    ret ptr [[B]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@rt3_helper
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone [[A:%.*]], ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret ptr [[B]]
+;
+entry:
+  %call = call ptr @rt3(ptr %a, ptr %b)
+  ret ptr %call
+}
+
+define ptr @rt3(ptr %a, ptr %b) #0 {
+; CHECK: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@rt3
+; CHECK-SAME: (ptr nocapture nofree readnone [[A:%.*]], ptr nofree readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[A]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CHECK:       if.then:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @rt3_helper(ptr noalias nocapture nofree readnone [[A]], ptr noalias nofree readnone "no-capture-maybe-returned" [[B]]) #[[ATTR5]]
+; CHECK-NEXT:    br label [[IF_END]]
+; CHECK:       if.end:
+; CHECK-NEXT:    [[SEL:%.*]] = phi ptr [ [[B]], [[ENTRY:%.*]] ], [ [[B]], [[IF_THEN]] ]
+; CHECK-NEXT:    ret ptr [[B]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@rt3
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone [[A:%.*]], ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[IF_END:%.*]]
+; CHECK-DL:       if.then:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       if.end:
+; CHECK-DL-NEXT:    ret ptr [[B]]
+;
+entry:
+  %cmp = icmp eq ptr %a, null
+  br i1 %cmp, label %if.then, label %if.end
+
+if.then:
+  %call = call ptr @rt3_helper(ptr %a, ptr %b)
+  br label %if.end
+
+if.end:
+  %sel = phi ptr [ %b, %entry], [%call, %if.then]
+  ret ptr %sel
+}
+
+; TEST address taken function with call to an external functions
+;
+;  void unknown_fn(void *);
+;
+;  int* calls_unknown_fn(int *r) {
+;    unknown_fn(&calls_unknown_fn);
+;    return r;
+;  }
+;
+declare void @unknown_fn(ptr) #0
+
+define ptr @calls_unknown_fn(ptr %r) #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@calls_unknown_fn
+; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[R:%.*]]) #[[ATTR4:[0-9]+]] {
+; CHECK-NEXT:    tail call void @unknown_fn(ptr noundef nonnull @calls_unknown_fn) #[[ATTR7:[0-9]+]]
+; CHECK-NEXT:    ret ptr [[R]]
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@calls_unknown_fn
+; CHECK-DL-SAME: (ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[R:%.*]]) #[[ATTR4:[0-9]+]] {
+; CHECK-DL-NEXT:    tail call void @unknown_fn(ptr noundef nonnull @calls_unknown_fn) #[[ATTR7:[0-9]+]]
+; CHECK-DL-NEXT:    ret ptr [[R]]
+;
+  tail call void @unknown_fn(ptr nonnull @calls_unknown_fn)
+  ret ptr %r
+}
+
+
+; TEST call to a function that might be redifined at link time
+;
+;  int *maybe_redefined_fn(int *r) {
+;    return r;
+;  }
+;
+;  int *calls_maybe_redefined_fn(int *r) {
+;    maybe_redefined_fn(r);
+;    return r;
+;  }
+;
+; Verify the maybe-redefined function is not annotated:
+;
+define linkonce_odr ptr @maybe_redefined_fn(ptr %r) #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@maybe_redefined_fn
+; CHECK-SAME: (ptr [[R:%.*]]) #[[ATTR4]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret ptr [[R]]
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@maybe_redefined_fn
+; CHECK-DL-SAME: (ptr [[R:%.*]]) #[[ATTR4]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret ptr [[R]]
+;
+entry:
+  ret ptr %r
+}
+
+define ptr @calls_maybe_redefined_fn(ptr %r) #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@calls_maybe_redefined_fn
+; CHECK-SAME: (ptr returned [[R:%.*]]) #[[ATTR4]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @maybe_redefined_fn(ptr [[R]]) #[[ATTR7]]
+; CHECK-NEXT:    ret ptr [[R]]
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@calls_maybe_redefined_fn
+; CHECK-DL-SAME: (ptr nonnull returned [[R:%.*]]) #[[ATTR4]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    [[CALL:%.*]] = call ptr @maybe_redefined_fn(ptr nonnull [[R]]) #[[ATTR7]]
+; CHECK-DL-NEXT:    ret ptr [[R]]
+;
+entry:
+  %call = call ptr @maybe_redefined_fn(ptr %r)
+  ret ptr %r
+}
+
+; TEST return call to a function that might be redifined at link time
+;
+;  int *maybe_redefined_fn2(int *r) {
+;    return r;
+;  }
+;
+;  int *calls_maybe_redefined_fn2(int *r) {
+;    return maybe_redefined_fn2(r);
+;  }
+;
+; Verify the maybe-redefined function is not annotated:
+;
+define linkonce_odr ptr @maybe_redefined_fn2(ptr %r) #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@maybe_redefined_fn2
+; CHECK-SAME: (ptr [[R:%.*]]) #[[ATTR4]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret ptr [[R]]
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@maybe_redefined_fn2
+; CHECK-DL-SAME: (ptr [[R:%.*]]) #[[ATTR4]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret ptr [[R]]
+;
+entry:
+  ret ptr %r
+}
+
+define ptr @calls_maybe_redefined_fn2(ptr %r) #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@calls_maybe_redefined_fn2
+; CHECK-SAME: (ptr [[R:%.*]]) #[[ATTR4]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @maybe_redefined_fn2(ptr [[R]]) #[[ATTR7]]
+; CHECK-NEXT:    ret ptr [[CALL]]
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@calls_maybe_redefined_fn2
+; CHECK-DL-SAME: (ptr nonnull [[R:%.*]]) #[[ATTR4]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    [[CALL:%.*]] = call nonnull ptr @maybe_redefined_fn2(ptr nonnull [[R]]) #[[ATTR7]]
+; CHECK-DL-NEXT:    ret ptr [[CALL]]
+;
+entry:
+  %call = call ptr @maybe_redefined_fn2(ptr %r)
+  ret ptr %call
+}
+
+
+; TEST returned argument goes through select and phi
+;
+; double select_and_phi(double b) {
+;   double x = b;
+;   if (b > 0)
+;     x = b;
+;   return b == 0? b : x;
+; }
+;
+define double @select_and_phi(double %b) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@select_and_phi
+; CHECK-SAME: (double returned [[B:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = fcmp ogt double [[B]], 0.000000e+00
+; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CHECK:       if.then:
+; CHECK-NEXT:    br label [[IF_END]]
+; CHECK:       if.end:
+; CHECK-NEXT:    [[PHI:%.*]] = phi double [ [[B]], [[IF_THEN]] ], [ [[B]], [[ENTRY:%.*]] ]
+; CHECK-NEXT:    ret double [[B]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@select_and_phi
+; CHECK-DL-SAME: (double returned [[B:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    [[CMP:%.*]] = fcmp ogt double [[B]], 0.000000e+00
+; CHECK-DL-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CHECK-DL:       if.then:
+; CHECK-DL-NEXT:    br label [[IF_END]]
+; CHECK-DL:       if.end:
+; CHECK-DL-NEXT:    [[PHI:%.*]] = phi double [ [[B]], [[IF_THEN]] ], [ [[B]], [[ENTRY:%.*]] ]
+; CHECK-DL-NEXT:    ret double [[B]]
+;
+entry:
+  %cmp = fcmp ogt double %b, 0.000000e+00
+  br i1 %cmp, label %if.then, label %if.end
+
+if.then:                                          ; preds = %entry
+  br label %if.end
+
+if.end:                                           ; preds = %if.then, %entry
+  %phi = phi double [ %b, %if.then ], [ %b, %entry ]
+  %cmp1 = fcmp oeq double %b, 0.000000e+00
+  %sel = select i1 %cmp1, double %b, double %phi
+  ret double %sel
+}
+
+
+; TEST returned argument goes through recursion, select, and phi
+;
+; double recursion_select_and_phi(int a, double b) {
+;   double x = b;
+;   if (a-- > 0)
+;     x = recursion_select_and_phi(a, b);
+;   return b == 0? b : x;
+; }
+;
+define double @recursion_select_and_phi(i32 %a, double %b) #0 {
+; CHECK: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@recursion_select_and_phi
+; CHECK-SAME: (i32 [[A:%.*]], double returned [[B:%.*]]) #[[ATTR1]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[DEC:%.*]] = add nsw i32 [[A]], -1
+; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A]], 0
+; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CHECK:       if.then:
+; CHECK-NEXT:    [[CALL:%.*]] = call double @recursion_select_and_phi(i32 [[DEC]], double [[B]]) #[[ATTR5]]
+; CHECK-NEXT:    br label [[IF_END]]
+; CHECK:       if.end:
+; CHECK-NEXT:    [[PHI:%.*]] = phi double [ [[B]], [[IF_THEN]] ], [ [[B]], [[ENTRY:%.*]] ]
+; CHECK-NEXT:    ret double [[B]]
+;
+; CHECK-DL: Function Attrs: nofree noinline nosync nounwind memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@recursion_select_and_phi
+; CHECK-DL-SAME: (i32 [[A:%.*]], double returned [[B:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    [[DEC:%.*]] = add nsw i32 [[A]], -1
+; CHECK-DL-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A]], 0
+; CHECK-DL-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CHECK-DL:       if.then:
+; CHECK-DL-NEXT:    [[CALL:%.*]] = call double @recursion_select_and_phi(i32 [[DEC]], double [[B]]) #[[ATTR5:[0-9]+]]
+; CHECK-DL-NEXT:    br label [[IF_END]]
+; CHECK-DL:       if.end:
+; CHECK-DL-NEXT:    [[PHI:%.*]] = phi double [ [[B]], [[IF_THEN]] ], [ [[B]], [[ENTRY:%.*]] ]
+; CHECK-DL-NEXT:    ret double [[B]]
+;
+entry:
+  %dec = add nsw i32 %a, -1
+  %cmp = icmp sgt i32 %a, 0
+  br i1 %cmp, label %if.then, label %if.end
+
+if.then:                                          ; preds = %entry
+  %call = call double @recursion_select_and_phi(i32 %dec, double %b)
+  br label %if.end
+
+if.end:                                           ; preds = %if.then, %entry
+  %phi = phi double [ %call, %if.then ], [ %b, %entry ]
+  %cmp1 = fcmp oeq double %b, 0.000000e+00
+  %sel = select i1 %cmp1, double %b, double %phi
+  ret double %sel
+}
+
+
+; TEST returned argument goes through bitcasts
+;
+; double* bitcast(int* b) {
+;   return (double*)b;
+; }
+;
+define ptr @bitcast(ptr %b) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@bitcast
+; CHECK-SAME: (ptr nofree readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    ret ptr [[B]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@bitcast
+; CHECK-DL-SAME: (ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    ret ptr [[B]]
+;
+entry:
+  ret ptr %b
+}
+
+
+; TEST returned argument goes through select and phi interleaved with bitcasts
+;
+; double* bitcasts_select_and_phi(int* b) {
+;   double* x = b;
+;   if (b == 0)
+;     x = b;
+;   return b != 0 ? b : x;
+; }
+;
+define ptr @bitcasts_select_and_phi(ptr %b) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@bitcasts_select_and_phi
+; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[B]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
+; CHECK:       if.then:
+; CHECK-NEXT:    br label [[IF_END]]
+; CHECK:       if.end:
+; CHECK-NEXT:    [[PHI:%.*]] = phi ptr [ [[B]], [[IF_THEN]] ], [ [[B]], [[ENTRY:%.*]] ]
+; CHECK-NEXT:    ret ptr [[B]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@bitcasts_select_and_phi
+; CHECK-DL-SAME: (ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[IF_END:%.*]]
+; CHECK-DL:       if.then:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       if.end:
+; CHECK-DL-NEXT:    ret ptr [[B]]
+;
+entry:
+  %cmp = icmp eq ptr %b, null
+  br i1 %cmp, label %if.then, label %if.end
+
+if.then:                                          ; preds = %entry
+  br label %if.end
+
+if.end:                                           ; preds = %if.then, %entry
+  %phi = phi ptr [ %b, %if.then ], [ %b, %entry ]
+  %cmp2 = icmp ne ptr %b, null
+  %sel = select i1 %cmp2, ptr %phi, ptr %b
+  ret ptr %sel
+}
+
+
+; TEST return argument or argument or undef
+;
+; double* ret_arg_arg_undef(int* b) {
+;   if (b == 0)
+;     return (double*)b;
+;   if (b == 0)
+;     return (double*)b;
+;   /* return undef */
+; }
+;
+define ptr @ret_arg_arg_undef(ptr %b) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@ret_arg_arg_undef
+; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[B]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[RET_ARG0:%.*]], label [[IF_END:%.*]]
+; CHECK:       ret_arg0:
+; CHECK-NEXT:    ret ptr [[B]]
+; CHECK:       if.end:
+; CHECK-NEXT:    br i1 [[CMP]], label [[RET_ARG1:%.*]], label [[RET_UNDEF:%.*]]
+; CHECK:       ret_arg1:
+; CHECK-NEXT:    ret ptr [[B]]
+; CHECK:       ret_undef:
+; CHECK-NEXT:    ret ptr undef
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@ret_arg_arg_undef
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone [[B:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[IF_END:%.*]]
+; CHECK-DL:       ret_arg0:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       if.end:
+; CHECK-DL-NEXT:    br label [[RET_UNDEF:%.*]]
+; CHECK-DL:       ret_arg1:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       ret_undef:
+; CHECK-DL-NEXT:    ret ptr undef
+;
+entry:
+  %cmp = icmp eq ptr %b, null
+  br i1 %cmp, label %ret_arg0, label %if.end
+
+ret_arg0:
+  ret ptr %b
+
+if.end:
+  br i1 %cmp, label %ret_arg1, label %ret_undef
+
+ret_arg1:
+  ret ptr %b
+
+ret_undef:
+  ret ptr undef
+}
+
+
+; TEST return undef or argument or argument
+;
+; double* ret_undef_arg_arg(int* b) {
+;   if (b == 0)
+;     return (double*)b;
+;   if (b == 0)
+;     return (double*)b;
+;   /* return undef */
+; }
+;
+define ptr @ret_undef_arg_arg(ptr %b) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@ret_undef_arg_arg
+; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[B]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[RET_UNDEF:%.*]], label [[IF_END:%.*]]
+; CHECK:       ret_undef:
+; CHECK-NEXT:    ret ptr undef
+; CHECK:       if.end:
+; CHECK-NEXT:    br i1 [[CMP]], label [[RET_ARG0:%.*]], label [[RET_ARG1:%.*]]
+; CHECK:       ret_arg0:
+; CHECK-NEXT:    ret ptr [[B]]
+; CHECK:       ret_arg1:
+; CHECK-NEXT:    ret ptr [[B]]
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@ret_undef_arg_arg
+; CHECK-DL-SAME: (ptr nofree nonnull readnone returned "no-capture-maybe-returned" [[B:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[IF_END:%.*]]
+; CHECK-DL:       ret_undef:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       if.end:
+; CHECK-DL-NEXT:    br label [[RET_ARG1:%.*]]
+; CHECK-DL:       ret_arg0:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       ret_arg1:
+; CHECK-DL-NEXT:    ret ptr [[B]]
+;
+entry:
+  %cmp = icmp eq ptr %b, null
+  br i1 %cmp, label %ret_undef, label %if.end
+
+ret_undef:
+  ret ptr undef
+
+if.end:
+  br i1 %cmp, label %ret_arg0, label %ret_arg1
+
+ret_arg0:
+  ret ptr %b
+
+ret_arg1:
+  ret ptr %b
+}
+
+
+; TEST return undef or argument or undef
+;
+; double* ret_undef_arg_undef(int* b) {
+;   if (b == 0)
+;     /* return undef */
+;   if (b == 0)
+;     return (double*)b;
+;   /* return undef */
+; }
+;
+define ptr @ret_undef_arg_undef(ptr %b) #0 {
+; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-LABEL: define {{[^@]+}}@ret_undef_arg_undef
+; CHECK-SAME: (ptr nofree readnone returned [[B:%.*]]) #[[ATTR0]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[B]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[RET_UNDEF0:%.*]], label [[IF_END:%.*]]
+; CHECK:       ret_undef0:
+; CHECK-NEXT:    ret ptr undef
+; CHECK:       if.end:
+; CHECK-NEXT:    br i1 [[CMP]], label [[RET_ARG:%.*]], label [[RET_UNDEF1:%.*]]
+; CHECK:       ret_arg:
+; CHECK-NEXT:    ret ptr [[B]]
+; CHECK:       ret_undef1:
+; CHECK-NEXT:    ret ptr undef
+;
+; CHECK-DL: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@ret_undef_arg_undef
+; CHECK-DL-SAME: (ptr nocapture nofree nonnull readnone [[B:%.*]]) #[[ATTR0]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[IF_END:%.*]]
+; CHECK-DL:       ret_undef0:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       if.end:
+; CHECK-DL-NEXT:    br label [[RET_UNDEF1:%.*]]
+; CHECK-DL:       ret_arg:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       ret_undef1:
+; CHECK-DL-NEXT:    ret ptr undef
+;
+entry:
+  %cmp = icmp eq ptr %b, null
+  br i1 %cmp, label %ret_undef0, label %if.end
+
+ret_undef0:
+  ret ptr undef
+
+if.end:
+  br i1 %cmp, label %ret_arg, label %ret_undef1
+
+ret_arg:
+  ret ptr %b
+
+ret_undef1:
+  ret ptr undef
+}
+
+; TEST return argument or unknown call result
+;
+; int* ret_arg_or_unknown(int* b) {
+;   if (b == 0)
+;     return b;
+;   return unknown();
+; }
+;
+; Verify we do not assume b is returned
+;
+declare ptr @unknown(ptr)
+
+
+define ptr @ret_arg_or_unknown(ptr %b) #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@ret_arg_or_unknown
+; CHECK-SAME: (ptr [[B:%.*]]) #[[ATTR4]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[B]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[RET_ARG:%.*]], label [[RET_UNKNOWN:%.*]]
+; CHECK:       ret_arg:
+; CHECK-NEXT:    ret ptr [[B]]
+; CHECK:       ret_unknown:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @unknown(ptr nonnull [[B]])
+; CHECK-NEXT:    ret ptr [[CALL]]
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@ret_arg_or_unknown
+; CHECK-DL-SAME: (ptr nonnull [[B:%.*]]) #[[ATTR4]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[RET_UNKNOWN:%.*]]
+; CHECK-DL:       ret_arg:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       ret_unknown:
+; CHECK-DL-NEXT:    [[CALL:%.*]] = call nonnull ptr @unknown(ptr nonnull [[B]])
+; CHECK-DL-NEXT:    ret ptr [[CALL]]
+;
+entry:
+  %cmp = icmp eq ptr %b, null
+  br i1 %cmp, label %ret_arg, label %ret_unknown
+
+ret_arg:
+  ret ptr %b
+
+ret_unknown:
+  %call = call ptr @unknown(ptr %b)
+  ret ptr %call
+}
+
+define ptr @ret_arg_or_unknown_through_phi(ptr %b) #0 {
+; CHECK: Function Attrs: noinline nounwind uwtable
+; CHECK-LABEL: define {{[^@]+}}@ret_arg_or_unknown_through_phi
+; CHECK-SAME: (ptr [[B:%.*]]) #[[ATTR4]] {
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[B]], null
+; CHECK-NEXT:    br i1 [[CMP]], label [[RET_ARG:%.*]], label [[RET_UNKNOWN:%.*]]
+; CHECK:       ret_arg:
+; CHECK-NEXT:    br label [[R:%.*]]
+; CHECK:       ret_unknown:
+; CHECK-NEXT:    [[CALL:%.*]] = call ptr @unknown(ptr nonnull [[B]])
+; CHECK-NEXT:    br label [[R]]
+; CHECK:       r:
+; CHECK-NEXT:    [[PHI:%.*]] = phi ptr [ [[B]], [[RET_ARG]] ], [ [[CALL]], [[RET_UNKNOWN]] ]
+; CHECK-NEXT:    ret ptr [[PHI]]
+;
+; CHECK-DL: Function Attrs: noinline nounwind uwtable
+; CHECK-DL-LABEL: define {{[^@]+}}@ret_arg_or_unknown_through_phi
+; CHECK-DL-SAME: (ptr nonnull [[B:%.*]]) #[[ATTR4]] {
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br label [[RET_UNKNOWN:%.*]]
+; CHECK-DL:       ret_arg:
+; CHECK-DL-NEXT:    unreachable
+; CHECK-DL:       ret_unknown:
+; CHECK-DL-NEXT:    [[CALL:%.*]] = call nonnull ptr @unknown(ptr nonnull [[B]])
+; CHECK-DL-NEXT:    br label [[R:%.*]]
+; CHECK-DL:       r:
+; CHECK-DL-NEXT:    ret ptr [[CALL]]
+;
+entry:
+  %cmp = icmp eq ptr %b, null
+  br i1 %cmp, label %ret_arg, label %ret_unknown
+
+ret_arg:
+  br label %r
+
+ret_unknown:
+  %call = call ptr @unknown(ptr %b)
+  br label %r
+
+r:
+  %phi = phi ptr [ %b, %ret_arg ], [ %call, %ret_unknown ]
+  ret ptr %phi
+}
+
+define weak_odr i32 @non_exact_0() {
+; CHECK-LABEL: define {{[^@]+}}@non_exact_0() {
+; CHECK-NEXT:    ret i32 0
+;
+; CHECK-DL-LABEL: define {{[^@]+}}@non_exact_0() {
+; CHECK-DL-NEXT:    ret i32 0
+;
+  ret i32 0
+}
+define weak_odr i32 @non_exact_1(i32 %a) {
+; CHECK-LABEL: define {{[^@]+}}@non_exact_1
+; CHECK-SAME: (i32 [[A:%.*]]) {
+; CHECK-NEXT:    ret i32 [[A]]
+;
+; CHECK-DL-LABEL: define {{[^@]+}}@non_exact_1
+; CHECK-DL-SAME: (i32 [[A:%.*]]) {
+; CHECK-DL-NEXT:    ret i32 [[A]]
+;
+  ret i32 %a
+}
+define weak_odr i32 @non_exact_2(i32 returned %a) {
+; CHECK-LABEL: define {{[^@]+}}@non_exact_2
+; CHECK-SAME: (i32 returned [[A:%.*]]) {
+; CHECK-NEXT:    ret i32 [[A]]
+;
+; CHECK-DL-LABEL: define {{[^@]+}}@non_exact_2
+; CHECK-DL-SAME: (i32 returned [[A:%.*]]) {
+; CHECK-DL-NEXT:    ret i32 [[A]]
+;
+  ret i32 %a
+}
+define weak_odr align 16 ptr @non_exact_3(ptr align 32 returned %a) {
+; CHECK-LABEL: define {{[^@]+}}@non_exact_3
+; CHECK-SAME: (ptr returned align 32 [[A:%.*]]) {
+; CHECK-NEXT:    ret ptr [[A]]
+;
+; CHECK-DL-LABEL: define {{[^@]+}}@non_exact_3
+; CHECK-DL-SAME: (ptr returned align 32 [[A:%.*]]) {
+; CHECK-DL-NEXT:    ret ptr [[A]]
+;
+  ret ptr %a
+}
+define weak_odr align 16 ptr @non_exact_4(ptr align 32 %a) {
+; CHECK-LABEL: define {{[^@]+}}@non_exact_4
+; CHECK-SAME: (ptr align 32 [[A:%.*]]) {
+; CHECK-NEXT:    ret ptr [[A]]
+;
+; CHECK-DL-LABEL: define {{[^@]+}}@non_exact_4
+; CHECK-DL-SAME: (ptr align 32 [[A:%.*]]) {
+; CHECK-DL-NEXT:    ret ptr [[A]]
+;
+  ret ptr %a
+}
+; We can use the alignment information of the weak function non_exact_3 argument
+; because it was given to us and not derived.
+; We can use the return information of the weak function non_exact_4.
+; %c2 and %c3 should be replaced but not %c0 or %c1!
+define i32 @exact(ptr align 8 %a, ptr align 8 %b) {
+; CHECK-LABEL: define {{[^@]+}}@exact
+; CHECK-SAME: (ptr align 8 [[A:%.*]], ptr align 8 [[B:%.*]]) {
+; CHECK-NEXT:    [[C0:%.*]] = call i32 @non_exact_0()
+; CHECK-NEXT:    [[C1:%.*]] = call i32 @non_exact_1(i32 noundef 1)
+; CHECK-NEXT:    [[C2:%.*]] = call i32 @non_exact_2(i32 noundef 2)
+; CHECK-NEXT:    [[C3:%.*]] = call align 32 ptr @non_exact_3(ptr align 32 [[A]])
+; CHECK-NEXT:    [[C4:%.*]] = call align 16 ptr @non_exact_4(ptr align 32 [[B]])
+; CHECK-NEXT:    [[C3L:%.*]] = load i32, ptr [[A]], align 32
+; CHECK-NEXT:    [[C4L:%.*]] = load i32, ptr [[C4]], align 16
+; CHECK-NEXT:    [[ADD1:%.*]] = add i32 [[C0]], [[C1]]
+; CHECK-NEXT:    [[ADD2:%.*]] = add i32 [[ADD1]], 2
+; CHECK-NEXT:    [[ADD3:%.*]] = add i32 [[ADD2]], [[C3L]]
+; CHECK-NEXT:    [[ADD4:%.*]] = add i32 [[ADD3]], [[C4L]]
+; CHECK-NEXT:    ret i32 [[ADD4]]
+;
+; CHECK-DL-LABEL: define {{[^@]+}}@exact
+; CHECK-DL-SAME: (ptr nonnull align 8 [[A:%.*]], ptr nonnull align 8 [[B:%.*]]) {
+; CHECK-DL-NEXT:    [[C0:%.*]] = call i32 @non_exact_0()
+; CHECK-DL-NEXT:    [[C1:%.*]] = call i32 @non_exact_1(i32 noundef 1)
+; CHECK-DL-NEXT:    [[C2:%.*]] = call i32 @non_exact_2(i32 noundef 2)
+; CHECK-DL-NEXT:    [[C3:%.*]] = call align 32 ptr @non_exact_3(ptr nonnull align 32 [[A]])
+; CHECK-DL-NEXT:    [[C4:%.*]] = call align 16 ptr @non_exact_4(ptr nonnull align 32 [[B]])
+; CHECK-DL-NEXT:    [[C3L:%.*]] = load i32, ptr [[A]], align 32
+; CHECK-DL-NEXT:    [[C4L:%.*]] = load i32, ptr [[C4]], align 16
+; CHECK-DL-NEXT:    [[ADD1:%.*]] = add i32 [[C0]], [[C1]]
+; CHECK-DL-NEXT:    [[ADD2:%.*]] = add i32 [[ADD1]], 2
+; CHECK-DL-NEXT:    [[ADD3:%.*]] = add i32 [[ADD2]], [[C3L]]
+; CHECK-DL-NEXT:    [[ADD4:%.*]] = add i32 [[ADD3]], [[C4L]]
+; CHECK-DL-NEXT:    ret i32 [[ADD4]]
+;
+  %c0 = call i32 @non_exact_0()
+  %c1 = call i32 @non_exact_1(i32 1)
+  %c2 = call i32 @non_exact_2(i32 2)
+  %c3 = call ptr @non_exact_3(ptr %a)
+  %c4 = call ptr @non_exact_4(ptr %b)
+  %c3l = load i32, ptr %c3
+  %c4l = load i32, ptr %c4
+  %add1 = add i32 %c0, %c1
+  %add2 = add i32 %add1, %c2
+  %add3 = add i32 %add2, %c3l
+  %add4 = add i32 %add3, %c4l
+  ret i32 %add4
+}
+
+declare dso_local ptr @__dynamic_cast(ptr, ptr, ptr, i64)
+
+; UTC_ARGS: --enable
+
+attributes #0 = { noinline nounwind uwtable }
+;.
+; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
+; TUNIT: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable }
+; TUNIT: attributes #[[ATTR2]] = { nofree noinline nosync nounwind memory(argmem: read) uwtable }
+; TUNIT: attributes #[[ATTR3]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
+; TUNIT: attributes #[[ATTR4]] = { noinline nounwind uwtable }
+; TUNIT: attributes #[[ATTR5]] = { nofree nosync nounwind memory(none) }
+; TUNIT: attributes #[[ATTR6]] = { nofree nosync nounwind memory(read) }
+; TUNIT: attributes #[[ATTR7]] = { nounwind }
+;.
+; TUNIT-DL: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
+; TUNIT-DL: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable }
+; TUNIT-DL: attributes #[[ATTR2]] = { nofree noinline nosync nounwind memory(argmem: read) uwtable }
+; TUNIT-DL: attributes #[[ATTR3]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
+; TUNIT-DL: attributes #[[ATTR4]] = { noinline nounwind uwtable }
+; TUNIT-DL: attributes #[[ATTR5]] = { nofree nosync nounwind memory(none) }
+; TUNIT-DL: attributes #[[ATTR6]] = { nofree nosync nounwind memory(read) }
+; TUNIT-DL: attributes #[[ATTR7]] = { nounwind }
+;.
+; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
+; CGSCC: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable }
+; CGSCC: attributes #[[ATTR2]] = { nofree noinline nosync nounwind memory(argmem: read) uwtable }
+; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
+; CGSCC: attributes #[[ATTR4]] = { noinline nounwind uwtable }
+; CGSCC: attributes #[[ATTR5]] = { nofree nosync nounwind memory(none) }
+; CGSCC: attributes #[[ATTR6]] = { nofree nosync nounwind memory(read) }
+; CGSCC: attributes #[[ATTR7]] = { nounwind }
+;.
+; CGSCC-DL: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable }
+; CGSCC-DL: attributes #[[ATTR1]] = { nofree noinline nosync nounwind memory(none) uwtable }
+; CGSCC-DL: attributes #[[ATTR2]] = { nofree noinline nosync nounwind memory(argmem: read) uwtable }
+; CGSCC-DL: attributes #[[ATTR3]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable }
+; CGSCC-DL: attributes #[[ATTR4]] = { noinline nounwind uwtable }
+; CGSCC-DL: attributes #[[ATTR5]] = { nofree nosync nounwind memory(none) }
+; CGSCC-DL: attributes #[[ATTR6]] = { nofree nosync nounwind memory(read) }
+; CGSCC-DL: attributes #[[ATTR7]] = { nounwind }
+;.
diff --git a/llvm/test/Transforms/Attributor/value-simplify-dl-sentinel.ll b/llvm/test/Transforms/Attributor/value-simplify-dl-sentinel.ll
new file mode 100755
index 0000000000000..244cc49ab5018
--- /dev/null
+++ b/llvm/test/Transforms/Attributor/value-simplify-dl-sentinel.ll
@@ -0,0 +1,158 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-annotate-decl-cs  -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-annotate-decl-cs  -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL,TUNIT-DL
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
+; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs  -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL,CGSCC-DL
+
+declare void @f(i32)
+declare token @llvm.call.preallocated.setup(i32)
+declare ptr @llvm.call.preallocated.arg(token, i32)
+
+@str = private unnamed_addr addrspace(4) constant [1 x i8] c"\00", align 1
+@ConstAS3Ptr = addrspace(3) global i32 0, align 4
+@ConstPtr = constant i32 0, align 4
+@ConstWeakPtr = weak constant i32 0, align 4
+@ConstWeakODRPtr = weak_odr constant i32 0, align 4
+
+; Do not touch complicated arguments (for now)
+%struct.X = type { ptr }
+;.
+; CHECK: @str = private unnamed_addr addrspace(4) constant [1 x i8] zeroinitializer, align 1
+; CHECK: @ConstAS3Ptr = addrspace(3) global i32 0, align 4
+; CHECK: @ConstPtr = constant i32 0, align 4
+; CHECK: @ConstWeakPtr = weak constant i32 0, align 4
+; CHECK: @ConstWeakODRPtr = weak_odr constant i32 0, align 4
+;.
+; TUNIT-DL: @str = private unnamed_addr addrspace(4) constant [1 x i8] zeroinitializer, align 1
+; TUNIT-DL: @ConstAS3Ptr = addrspace(3) global i32 0, align 4
+; TUNIT-DL: @ConstPtr = constant i32 0, align 4
+; TUNIT-DL: @ConstWeakPtr = weak constant i32 0, align 4
+; TUNIT-DL: @ConstWeakODRPtr = weak_odr constant i32 0, align 4
+;.
+; CGSCC-DL: @str = private unnamed_addr addrspace(4) constant [1 x i8] zeroinitializer, align 1
+; CGSCC-DL: @ConstAS3Ptr = addrspace(3) global i32 0, align 4
+; CGSCC-DL: @ConstPtr = constant i32 0, align 4
+; CGSCC-DL: @ConstWeakPtr = weak constant i32 0, align 4
+; CGSCC-DL: @ConstWeakODRPtr = weak_odr constant i32 0, align 4
+;.
+define internal ptr @test_inalloca(ptr inalloca(i32) %a) {
+; CGSCC-LABEL: define {{[^@]+}}@test_inalloca
+; CGSCC-SAME: (ptr inalloca(i32) [[A:%.*]]) {
+; CGSCC-NEXT:    ret ptr [[A]]
+;
+; CGSCC-DL-LABEL: define {{[^@]+}}@test_inalloca
+; CGSCC-DL-SAME: (ptr inalloca(i32) [[A:%.*]]) {
+; CGSCC-DL-NEXT:    ret ptr [[A]]
+;
+  ret ptr %a
+}
+
+define internal void @test_sret(ptr sret(%struct.X) %a, ptr %b) {
+; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; CHECK-LABEL: define {{[^@]+}}@test_sret
+; CHECK-SAME: (ptr noalias nofree noundef writeonly sret([[STRUCT_X:%.*]]) align 4294967296 dereferenceable_or_null(8) [[A:%.*]], ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-NEXT:    store ptr [[A]], ptr [[B]], align 8
+; CHECK-NEXT:    ret void
+;
+; CGSCC-DL: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; CGSCC-DL-LABEL: define {{[^@]+}}@test_sret
+; CGSCC-DL-SAME: (ptr noalias nofree noundef nonnull writeonly sret([[STRUCT_X:%.*]]) align 4294967296 dereferenceable(8) [[A:%.*]], ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B:%.*]]) #[[ATTR1:[0-9]+]] {
+; CGSCC-DL-NEXT:    store ptr [[A]], ptr [[B]], align 8
+; CGSCC-DL-NEXT:    ret void
+;
+  store ptr %a, ptr %b
+  ret void
+}
+; FIXME: Alignment and dereferenceability are not propagated to the argument
+define void @complicated_args_sret(ptr %b) {
+; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; TUNIT-LABEL: define {{[^@]+}}@complicated_args_sret
+; TUNIT-SAME: (ptr nocapture nofree writeonly [[B:%.*]]) #[[ATTR1]] {
+; TUNIT-NEXT:    call void @test_sret(ptr nofree noundef writeonly sret([[STRUCT_X:%.*]]) align 4294967296 null, ptr nocapture nofree noundef writeonly align 8 [[B]]) #[[ATTR3:[0-9]+]]
+; TUNIT-NEXT:    ret void
+;
+; TUNIT-DL: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write)
+; TUNIT-DL-LABEL: define {{[^@]+}}@complicated_args_sret
+; TUNIT-DL-SAME: (ptr nocapture nofree nonnull writeonly [[B:%.*]]) #[[ATTR1:[0-9]+]] {
+; TUNIT-DL-NEXT:    unreachable
+;
+; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: write)
+; CGSCC-LABEL: define {{[^@]+}}@complicated_args_sret
+; CGSCC-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B:%.*]]) #[[ATTR2:[0-9]+]] {
+; CGSCC-NEXT:    call void @test_sret(ptr nofree noundef writeonly sret([[STRUCT_X:%.*]]) align 4294967296 dereferenceable_or_null(8) null, ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B]]) #[[ATTR5:[0-9]+]]
+; CGSCC-NEXT:    ret void
+;
+; CGSCC-DL: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(argmem: write)
+; CGSCC-DL-LABEL: define {{[^@]+}}@complicated_args_sret
+; CGSCC-DL-SAME: (ptr nocapture nofree noundef nonnull writeonly align 8 dereferenceable(8) [[B:%.*]]) #[[ATTR2:[0-9]+]] {
+; CGSCC-DL-NEXT:    unreachable
+;
+  call void @test_sret(ptr sret(%struct.X) null, ptr %b)
+  ret void
+}
+
+define internal ptr @test_nest(ptr nest %a) {
+; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CGSCC-LABEL: define {{[^@]+}}@test_nest
+; CGSCC-SAME: (ptr nest noalias nocapture nofree readnone align 4294967296 [[A:%.*]]) #[[ATTR3:[0-9]+]] {
+; CGSCC-NEXT:    ret ptr null
+;
+; CGSCC-DL: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; CGSCC-DL-LABEL: define {{[^@]+}}@test_nest
+; CGSCC-DL-SAME: (ptr nest noalias nocapture nofree nonnull readnone align 4294967296 [[A:%.*]]) #[[ATTR3:[0-9]+]] {
+; CGSCC-DL-NEXT:    unreachable
+;
+  ret ptr %a
+}
+define ptr @complicated_args_nest() {
+; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; TUNIT-LABEL: define {{[^@]+}}@complicated_args_nest
+; TUNIT-SAME: () #[[ATTR2:[0-9]+]] {
+; TUNIT-NEXT:    ret ptr null
+;
+; TUNIT-DL: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)
+; TUNIT-DL-LABEL: define {{[^@]+}}@complicated_args_nest
+; TUNIT-DL-SAME: () #[[ATTR2:[0-9]+]] {
+; TUNIT-DL-NEXT:    unreachable
+;
+; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
+; CGSCC-LABEL: define {{[^@]+}}@complicated_args_nest
+; CGSCC-SAME: () #[[ATTR4:[0-9]+]] {
+; CGSCC-NEXT:    [[CALL:%.*]] = call noalias noundef align 4294967296 ptr @test_nest(ptr nofree noundef readnone align 4294967296 null) #[[ATTR6:[0-9]+]]
+; CGSCC-NEXT:    ret ptr [[CALL]]
+;
+; CGSCC-DL: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
+; CGSCC-DL-LABEL: define {{[^@]+}}@complicated_args_nest
+; CGSCC-DL-SAME: () #[[ATTR4:[0-9]+]] {
+; CGSCC-DL-NEXT:    unreachable
+;
+  %call = call ptr @test_nest(ptr null)
+  ret ptr %call
+}
+
+;.
+; TUNIT: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn }
+; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
+; TUNIT: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
+; TUNIT: attributes #[[ATTR3]] = { nofree nosync nounwind willreturn memory(write) }
+;.
+; TUNIT-DL: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn }
+; TUNIT-DL: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
+; TUNIT-DL: attributes #[[ATTR2]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
+;.
+; CGSCC: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn }
+; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
+; CGSCC: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: write) }
+; CGSCC: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
+; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
+; CGSCC: attributes #[[ATTR5]] = { nofree nounwind willreturn memory(write) }
+; CGSCC: attributes #[[ATTR6]] = { nofree nosync willreturn }
+;.
+; CGSCC-DL: attributes #[[ATTR0:[0-9]+]] = { nocallback nofree nosync nounwind willreturn }
+; CGSCC-DL: attributes #[[ATTR1]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: write) }
+; CGSCC-DL: attributes #[[ATTR2]] = { mustprogress nofree nosync nounwind willreturn memory(argmem: write) }
+; CGSCC-DL: attributes #[[ATTR3]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
+; CGSCC-DL: attributes #[[ATTR4]] = { mustprogress nofree nosync nounwind willreturn memory(none) }
+;.
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; CHECK-DL: {{.*}}
diff --git a/llvm/test/Transforms/InstCombine/alloca-in-non-alloca-as-sentinel.ll b/llvm/test/Transforms/InstCombine/alloca-in-non-alloca-as-sentinel.ll
new file mode 100755
index 0000000000000..941d649bff054
--- /dev/null
+++ b/llvm/test/Transforms/InstCombine/alloca-in-non-alloca-as-sentinel.ll
@@ -0,0 +1,106 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+; RUN: opt < %s -passes=instcombine -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S | FileCheck -check-prefixes=CHECK-DL %s
+
+; Gracefully handle the alloca that is not in the alloca AS (=5)
+
+declare void @use(ptr)
+declare void @use2(ptr, ptr)
+
+define void @__omp_offloading_802_ea0109_main_l8(ptr %a) {
+; CHECK-LABEL: @__omp_offloading_802_ea0109_main_l8(
+; CHECK-NEXT:  .master:
+; CHECK-NEXT:    [[ALLOCA1:%.*]] = alloca [8 x i8], align 1, addrspace(5)
+; CHECK-NEXT:    store ptr null, ptr addrspace(5) [[ALLOCA1]], align 8
+; CHECK-NEXT:    call void @use2(ptr addrspace(5) [[ALLOCA1]], ptr addrspace(5) [[ALLOCA1]])
+; CHECK-NEXT:    ret void
+;
+; CHECK-DL-LABEL: @__omp_offloading_802_ea0109_main_l8(
+; CHECK-DL-NEXT:  .master:
+; CHECK-DL-NEXT:    [[ALLOCA1:%.*]] = alloca [8 x i8], align 1, addrspace(5)
+; CHECK-DL-NEXT:    store ptr null, ptr addrspace(5) [[ALLOCA1]], align 8
+; CHECK-DL-NEXT:    call void @use2(ptr addrspace(5) nonnull [[ALLOCA1]], ptr addrspace(5) nonnull [[ALLOCA1]])
+; CHECK-DL-NEXT:    ret void
+;
+.master:
+  %alloca = alloca i8, i64 8, align 1, addrspace(5)
+  store ptr null, ptr  addrspace(5) %alloca, align 8
+  call void @use2(ptr  addrspace(5) %alloca, ptr  addrspace(5) %alloca)
+  ret void
+}
+
+%struct.widget = type { [8 x i8] }
+
+define void @spam(ptr %arg1) {
+; CHECK-LABEL: @spam(
+; CHECK-NEXT:  bb:
+; CHECK-NEXT:    [[ALLOCA1:%.*]] = alloca [0 x [30 x %struct.widget]], align 16, addrspace(5)
+; CHECK-NEXT:    call void @zot(ptr addrspace(5) [[ALLOCA1]])
+; CHECK-NEXT:    ret void
+;
+; CHECK-DL-LABEL: @spam(
+; CHECK-DL-NEXT:  bb:
+; CHECK-DL-NEXT:    [[ALLOCA1:%.*]] = alloca [0 x [30 x %struct.widget]], align 16, addrspace(5)
+; CHECK-DL-NEXT:    call void @zot(ptr addrspace(5) nonnull [[ALLOCA1]])
+; CHECK-DL-NEXT:    ret void
+;
+bb:
+  %alloca = alloca [30 x %struct.widget], i32 0, align 16, addrspace(5)
+  call void @zot(ptr  addrspace(5) %alloca)
+  ret void
+}
+
+define i1 @alloca_addrspace_3_nonnull() {
+; CHECK-LABEL: @alloca_addrspace_3_nonnull(
+; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca i8, align 1, addrspace(3)
+; CHECK-NEXT:    call void @use(ptr addrspace(3) [[ALLOCA]])
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne ptr addrspace(3) [[ALLOCA]], null
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+; CHECK-DL-LABEL: @alloca_addrspace_3_nonnull(
+; CHECK-DL-NEXT:    [[ALLOCA:%.*]] = alloca i8, align 1, addrspace(3)
+; CHECK-DL-NEXT:    call void @use(ptr addrspace(3) nonnull [[ALLOCA]])
+; CHECK-DL-NEXT:    ret i1 true
+;
+  %alloca = alloca i8, addrspace(3)
+  call void @use(ptr addrspace(3) %alloca)
+  %cmp = icmp ne ptr addrspace(3) %alloca, null
+  ret i1 %cmp
+}
+
+define i1 @alloca_addrspace_0_nonnull() {
+; CHECK-LABEL: @alloca_addrspace_0_nonnull(
+; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca i8, align 1
+; CHECK-NEXT:    call void @use(ptr nonnull [[ALLOCA]])
+; CHECK-NEXT:    ret i1 true
+;
+; CHECK-DL-LABEL: @alloca_addrspace_0_nonnull(
+; CHECK-DL-NEXT:    [[ALLOCA:%.*]] = alloca i8, align 1
+; CHECK-DL-NEXT:    call void @use(ptr nonnull [[ALLOCA]])
+; CHECK-DL-NEXT:    ret i1 true
+;
+  %alloca = alloca i8
+  call void @use(ptr %alloca)
+  %cmp = icmp ne ptr %alloca, null
+  ret i1 %cmp
+}
+
+define i1 @alloca_addrspace_5_nonnull() {
+; CHECK-LABEL: @alloca_addrspace_5_nonnull(
+; CHECK-NEXT:    [[ALLOCA:%.*]] = alloca i8, align 1, addrspace(5)
+; CHECK-NEXT:    call void @use(ptr addrspace(5) [[ALLOCA]])
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne ptr addrspace(5) [[ALLOCA]], null
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+; CHECK-DL-LABEL: @alloca_addrspace_5_nonnull(
+; CHECK-DL-NEXT:    [[ALLOCA:%.*]] = alloca i8, align 1, addrspace(5)
+; CHECK-DL-NEXT:    call void @use(ptr addrspace(5) nonnull [[ALLOCA]])
+; CHECK-DL-NEXT:    ret i1 true
+;
+  %alloca = alloca i8, addrspace(5)
+  call void @use(ptr addrspace(5) %alloca)
+  %cmp = icmp ne ptr addrspace(5) %alloca, null
+  ret i1 %cmp
+}
+
+declare hidden void @zot(ptr)
diff --git a/llvm/test/Transforms/InstCombine/assume-dl-sentinel.ll b/llvm/test/Transforms/InstCombine/assume-dl-sentinel.ll
new file mode 100755
index 0000000000000..01bff51cab0e2
--- /dev/null
+++ b/llvm/test/Transforms/InstCombine/assume-dl-sentinel.ll
@@ -0,0 +1,332 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=instcombine -S | FileCheck --check-prefixes=CHECK,DEFAULT %s
+; RUN: opt < %s -passes=instcombine -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S | FileCheck --check-prefixes=CHECK-DL,DEFAULT-DL %s
+; RUN: opt < %s -passes=instcombine --enable-knowledge-retention -S | FileCheck --check-prefixes=CHECK,BUNDLES %s
+; RUN: opt < %s -passes=instcombine --enable-knowledge-retention -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S | FileCheck --check-prefixes=CHECK-DL,BUNDLES-DL %s
+
+; RUN: opt < %s -passes=instcombine -S --try-experimental-debuginfo-iterators | FileCheck --check-prefixes=CHECK,DEFAULT %s
+; RUN: opt < %s -passes=instcombine -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S --try-experimental-debuginfo-iterators | FileCheck --check-prefixes=CHECK-DL,DEFAULT-DL %s
+; RUN: opt < %s -passes=instcombine --enable-knowledge-retention -S --try-experimental-debuginfo-iterators | FileCheck --check-prefixes=CHECK,BUNDLES %s
+; RUN: opt < %s -passes=instcombine --enable-knowledge-retention -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S --try-experimental-debuginfo-iterators | FileCheck --check-prefixes=CHECK-DL,BUNDLES-DL %s
+
+target triple = "x86_64-unknown-linux-gnu"
+
+declare void @llvm.assume(i1) #1
+declare void @escape(ptr %a)
+
+; Check that the assume has not been removed:
+
+define i1 @nonnull1(ptr %a) {
+; CHECK-LABEL: @nonnull1(
+; CHECK-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8, !nonnull [[META6:![0-9]+]], !noundef [[META6]]
+; CHECK-NEXT:    tail call void @escape(ptr nonnull [[LOAD]])
+; CHECK-NEXT:    ret i1 false
+;
+; CHECK-DL-LABEL: @nonnull1(
+; CHECK-DL-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-DL-NEXT:    tail call void @escape(ptr nonnull [[LOAD]])
+; CHECK-DL-NEXT:    ret i1 false
+;
+  %load = load ptr, ptr %a
+  %cmp = icmp ne ptr %load, null
+  tail call void @llvm.assume(i1 %cmp)
+  tail call void @escape(ptr %load)
+  %rval = icmp eq ptr %load, null
+  ret i1 %rval
+}
+
+; Make sure the above canonicalization does not trigger
+; if the assume is control dependent on something else
+
+define i1 @nonnull3(ptr %a, i1 %control) {
+; FIXME: in the BUNDLES version we could duplicate the load and keep the assume nonnull.
+; DEFAULT-LABEL: @nonnull3(
+; DEFAULT-NEXT:  entry:
+; DEFAULT-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; DEFAULT-NEXT:    [[CMP:%.*]] = icmp ne ptr [[LOAD]], null
+; DEFAULT-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; DEFAULT:       taken:
+; DEFAULT-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
+; DEFAULT-NEXT:    ret i1 false
+; DEFAULT:       not_taken:
+; DEFAULT-NEXT:    [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null
+; DEFAULT-NEXT:    ret i1 [[RVAL_2]]
+;
+; CHECK-DL-LABEL: @nonnull3(
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; CHECK-DL:       taken:
+; CHECK-DL-NEXT:    ret i1 false
+; CHECK-DL:       not_taken:
+; CHECK-DL-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-DL-NEXT:    [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null
+; CHECK-DL-NEXT:    ret i1 [[RVAL_2]]
+;
+; BUNDLES-LABEL: @nonnull3(
+; BUNDLES-NEXT:  entry:
+; BUNDLES-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; BUNDLES:       taken:
+; BUNDLES-NEXT:    ret i1 false
+; BUNDLES:       not_taken:
+; BUNDLES-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; BUNDLES-NEXT:    [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null
+; BUNDLES-NEXT:    ret i1 [[RVAL_2]]
+;
+entry:
+  %load = load ptr, ptr %a
+  %cmp = icmp ne ptr %load, null
+  br i1 %control, label %taken, label %not_taken
+taken:
+  tail call void @llvm.assume(i1 %cmp)
+  %rval = icmp eq ptr %load, null
+  ret i1 %rval
+not_taken:
+  %rval.2 = icmp sgt ptr %load, null
+  ret i1 %rval.2
+}
+
+; Make sure the above canonicalization does not trigger
+; if the path from the load to the assume is potentially
+; interrupted by an exception being thrown
+
+define i1 @nonnull4(ptr %a) {
+; DEFAULT-LABEL: @nonnull4(
+; DEFAULT-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; DEFAULT-NEXT:    tail call void @escape(ptr [[LOAD]])
+; DEFAULT-NEXT:    [[CMP:%.*]] = icmp ne ptr [[LOAD]], null
+; DEFAULT-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
+; DEFAULT-NEXT:    ret i1 false
+;
+; CHECK-DL-LABEL: @nonnull4(
+; CHECK-DL-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-DL-NEXT:    tail call void @escape(ptr nonnull [[LOAD]])
+; CHECK-DL-NEXT:    ret i1 false
+;
+; BUNDLES-LABEL: @nonnull4(
+; BUNDLES-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; BUNDLES-NEXT:    tail call void @escape(ptr [[LOAD]])
+; BUNDLES-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(ptr [[LOAD]]) ]
+; BUNDLES-NEXT:    ret i1 false
+;
+  %load = load ptr, ptr %a
+  ;; This call may throw!
+  tail call void @escape(ptr %load)
+  %cmp = icmp ne ptr %load, null
+  tail call void @llvm.assume(i1 %cmp)
+  %rval = icmp eq ptr %load, null
+  ret i1 %rval
+}
+define i1 @nonnull5(ptr %a) {
+; CHECK-LABEL: @nonnull5(
+; CHECK-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-NEXT:    tail call void @escape(ptr [[LOAD]])
+; CHECK-NEXT:    [[CMP:%.*]] = icmp slt ptr [[LOAD]], null
+; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
+; CHECK-NEXT:    ret i1 false
+;
+; CHECK-DL-LABEL: @nonnull5(
+; CHECK-DL-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-DL-NEXT:    tail call void @escape(ptr nonnull [[LOAD]])
+; CHECK-DL-NEXT:    [[CMP:%.*]] = icmp slt ptr [[LOAD]], null
+; CHECK-DL-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
+; CHECK-DL-NEXT:    ret i1 false
+;
+  %load = load ptr, ptr %a
+  ;; This call may throw!
+  tail call void @escape(ptr %load)
+  %integral = ptrtoint ptr %load to i64
+  %cmp = icmp slt i64 %integral, 0
+  tail call void @llvm.assume(i1 %cmp) ; %load has at least highest bit set
+  %rval = icmp eq ptr %load, null
+  ret i1 %rval
+}
+
+define i1 @nonnull3A(ptr %a, i1 %control) {
+; DEFAULT-LABEL: @nonnull3A(
+; DEFAULT-NEXT:  entry:
+; DEFAULT-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; DEFAULT-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; DEFAULT:       taken:
+; DEFAULT-NEXT:    [[CMP:%.*]] = icmp ne ptr [[LOAD]], null
+; DEFAULT-NEXT:    call void @llvm.assume(i1 [[CMP]])
+; DEFAULT-NEXT:    ret i1 [[CMP]]
+; DEFAULT:       not_taken:
+; DEFAULT-NEXT:    [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null
+; DEFAULT-NEXT:    ret i1 [[RVAL_2]]
+;
+; CHECK-DL-LABEL: @nonnull3A(
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; CHECK-DL:       taken:
+; CHECK-DL-NEXT:    ret i1 true
+; CHECK-DL:       not_taken:
+; CHECK-DL-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-DL-NEXT:    [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null
+; CHECK-DL-NEXT:    ret i1 [[RVAL_2]]
+;
+; BUNDLES-LABEL: @nonnull3A(
+; BUNDLES-NEXT:  entry:
+; BUNDLES-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; BUNDLES:       taken:
+; BUNDLES-NEXT:    ret i1 true
+; BUNDLES:       not_taken:
+; BUNDLES-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; BUNDLES-NEXT:    [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null
+; BUNDLES-NEXT:    ret i1 [[RVAL_2]]
+;
+entry:
+  %load = load ptr, ptr %a
+  %cmp = icmp ne ptr %load, null
+  br i1 %control, label %taken, label %not_taken
+taken:
+  call void @llvm.assume(i1 %cmp)
+  ret i1 %cmp
+not_taken:
+  call void @llvm.assume(i1 %cmp)
+  %rval.2 = icmp sgt ptr %load, null
+  ret i1 %rval.2
+}
+
+define i1 @nonnull3B(ptr %a, i1 %control) {
+; CHECK-LABEL: @nonnull3B(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; CHECK:       taken:
+; CHECK-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne ptr [[LOAD]], null
+; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]]) [ "nonnull"(ptr [[LOAD]]) ]
+; CHECK-NEXT:    ret i1 [[CMP]]
+; CHECK:       not_taken:
+; CHECK-NEXT:    ret i1 [[CONTROL]]
+;
+; CHECK-DL-LABEL: @nonnull3B(
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-DL-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; CHECK-DL:       taken:
+; CHECK-DL-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(ptr [[LOAD]]) ]
+; CHECK-DL-NEXT:    ret i1 true
+; CHECK-DL:       not_taken:
+; CHECK-DL-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(ptr [[LOAD]]) ]
+; CHECK-DL-NEXT:    ret i1 [[CONTROL]]
+;
+entry:
+  %load = load ptr, ptr %a
+  %cmp = icmp ne ptr %load, null
+  br i1 %control, label %taken, label %not_taken
+taken:
+  call void @llvm.assume(i1 %cmp) ["nonnull"(ptr %load)]
+  ret i1 %cmp
+not_taken:
+  call void @llvm.assume(i1 %cmp) ["nonnull"(ptr %load)]
+  ret i1 %control
+}
+
+declare i1 @tmp1(i1)
+
+define i1 @nonnull3C(ptr %a, i1 %control) {
+; CHECK-LABEL: @nonnull3C(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; CHECK:       taken:
+; CHECK-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne ptr [[LOAD]], null
+; CHECK-NEXT:    [[CMP2:%.*]] = call i1 @tmp1(i1 [[CMP]])
+; CHECK-NEXT:    br label [[EXIT:%.*]]
+; CHECK:       exit:
+; CHECK-NEXT:    ret i1 [[CMP2]]
+; CHECK:       not_taken:
+; CHECK-NEXT:    ret i1 [[CONTROL]]
+;
+; CHECK-DL-LABEL: @nonnull3C(
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-DL-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; CHECK-DL:       taken:
+; CHECK-DL-NEXT:    [[CMP2:%.*]] = call i1 @tmp1(i1 true)
+; CHECK-DL-NEXT:    br label [[EXIT:%.*]]
+; CHECK-DL:       exit:
+; CHECK-DL-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(ptr [[LOAD]]) ]
+; CHECK-DL-NEXT:    ret i1 [[CMP2]]
+; CHECK-DL:       not_taken:
+; CHECK-DL-NEXT:    ret i1 [[CONTROL]]
+;
+entry:
+  %load = load ptr, ptr %a
+  %cmp = icmp ne ptr %load, null
+  br i1 %control, label %taken, label %not_taken
+taken:
+  %cmp2 = call i1 @tmp1(i1 %cmp)
+  br label %exit
+exit:
+  ; FIXME: this shouldn't be dropped because it is still dominated by the new position of %load
+  call void @llvm.assume(i1 %cmp) ["nonnull"(ptr %load)]
+  ret i1 %cmp2
+not_taken:
+  call void @llvm.assume(i1 %cmp)
+  ret i1 %control
+}
+
+define i1 @nonnull3D(ptr %a, i1 %control) {
+; CHECK-LABEL: @nonnull3D(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; CHECK:       taken:
+; CHECK-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-NEXT:    [[CMP:%.*]] = icmp ne ptr [[LOAD]], null
+; CHECK-NEXT:    [[CMP2:%.*]] = call i1 @tmp1(i1 [[CMP]])
+; CHECK-NEXT:    br label [[EXIT:%.*]]
+; CHECK:       exit:
+; CHECK-NEXT:    ret i1 [[CMP2]]
+; CHECK:       not_taken:
+; CHECK-NEXT:    ret i1 [[CONTROL]]
+;
+; CHECK-DL-LABEL: @nonnull3D(
+; CHECK-DL-NEXT:  entry:
+; CHECK-DL-NEXT:    [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8
+; CHECK-DL-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
+; CHECK-DL:       taken:
+; CHECK-DL-NEXT:    [[CMP2:%.*]] = call i1 @tmp1(i1 true)
+; CHECK-DL-NEXT:    br label [[EXIT:%.*]]
+; CHECK-DL:       exit:
+; CHECK-DL-NEXT:    ret i1 [[CMP2]]
+; CHECK-DL:       not_taken:
+; CHECK-DL-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(ptr [[LOAD]]) ]
+; CHECK-DL-NEXT:    ret i1 [[CONTROL]]
+;
+entry:
+  %load = load ptr, ptr %a
+  %cmp = icmp ne ptr %load, null
+  br i1 %control, label %taken, label %not_taken
+taken:
+  %cmp2 = call i1 @tmp1(i1 %cmp)
+  br label %exit
+exit:
+  ret i1 %cmp2
+not_taken:
+  call void @llvm.assume(i1 %cmp) ["nonnull"(ptr %load)]
+  ret i1 %control
+}
+
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!5, !6, !7, !8}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "Me", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: null, retainedTypes: null, imports: null)
+!1 = !DILocalVariable(name: "", arg: 1, scope: !2, file: null, line: 1, type: null)
+!2 = distinct !DISubprogram(name: "debug", linkageName: "debug", scope: null, file: null, line: 0, type: null, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: true, unit: !0)
+!3 = !DIFile(filename: "consecutive-fences.ll", directory: "")
+!5 = !{i32 2, !"Dwarf Version", i32 4}
+!6 = !{i32 2, !"Debug Info Version", i32 3}
+!7 = !{i32 1, !"wchar_size", i32 4}
+!8 = !{i32 7, !"PIC Level", i32 2}
+!9 = !DILocation(line: 0, column: 0, scope: !2)
+
+
+attributes #0 = { nounwind uwtable }
+attributes #1 = { nounwind }
+
+;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
+; BUNDLES-DL: {{.*}}
+; DEFAULT-DL: {{.*}}
diff --git a/llvm/test/Transforms/InstCombine/assume-icmp-null-select-dl-sentinel.ll b/llvm/test/Transforms/InstCombine/assume-icmp-null-select-dl-sentinel.ll
new file mode 100755
index 0000000000000..73aa9b64f6a61
--- /dev/null
+++ b/llvm/test/Transforms/InstCombine/assume-icmp-null-select-dl-sentinel.ll
@@ -0,0 +1,31 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=instcombine -S | FileCheck %s
+; RUN: opt < %s -passes=instcombine -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S | FileCheck -check-prefixes=CHECK-DL %s
+
+target triple = "x86_64-unknown-linux-gnu"
+
+; TODO: this should be folded to `ret ptr %x` as well.
+define ptr @example2(ptr %x) {
+; CHECK-LABEL: @example2(
+; CHECK-NEXT:    [[Y:%.*]] = load ptr, ptr [[X:%.*]], align 8
+; CHECK-NEXT:    [[Y_IS_NULL:%.*]] = icmp eq ptr [[Y]], null
+; CHECK-NEXT:    [[RES:%.*]] = select i1 [[Y_IS_NULL]], ptr null, ptr [[X]]
+; CHECK-NEXT:    [[NONNULL:%.*]] = icmp ne ptr [[RES]], null
+; CHECK-NEXT:    call void @llvm.assume(i1 [[NONNULL]])
+; CHECK-NEXT:    ret ptr [[RES]]
+;
+; CHECK-DL-LABEL: @example2(
+; CHECK-DL-NEXT:    ret ptr [[X:%.*]]
+;
+  %y = load ptr, ptr %x, align 8
+  %y_is_null = icmp eq ptr %y, null
+
+  %res = select i1 %y_is_null, ptr null, ptr %x
+
+  %nonnull = icmp ne ptr %res, null
+  call void @llvm.assume(i1 %nonnull)
+
+  ret ptr %res
+}
+
+declare void @llvm.assume(i1)
diff --git a/llvm/test/Transforms/InstSimplify/compare-dl-sentinel.ll b/llvm/test/Transforms/InstSimplify/compare-dl-sentinel.ll
new file mode 100755
index 0000000000000..15ed6b9880a24
--- /dev/null
+++ b/llvm/test/Transforms/InstSimplify/compare-dl-sentinel.ll
@@ -0,0 +1,66 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
+; RUN: opt < %s -passes=instsimplify -data-layout=p:32:32-p1:64:64-z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL
+
+declare void @llvm.assume(i1)
+declare dereferenceable(4) ptr @returns_nonnull_deref_helper()
+
+define i1 @gep14(ptr %ptr) {
+; CHECK-LABEL: @gep14(
+; CHECK-NEXT:    [[X:%.*]] = getelementptr inbounds { {}, i8 }, ptr [[PTR:%.*]], i32 0, i32 1
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[X]], null
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+; CHECK-DL-LABEL: @gep14(
+; CHECK-DL-NEXT:    ret i1 false
+;
+; We can't simplify this because the offset of one in the GEP actually doesn't
+; move the pointer.
+  %x = getelementptr inbounds { {}, i8 }, ptr %ptr, i32 0, i32 1
+  %cmp = icmp eq ptr %x, null
+  ret i1 %cmp
+}
+
+declare dereferenceable(4) ptr addrspace(1) @returns_nonnull_deref_as_helper()
+define i1 @nonnull_load_as_inner(ptr %addr) {
+; CHECK-LABEL: @nonnull_load_as_inner(
+; CHECK-NEXT:    ret i1 false
+;
+; CHECK-DL-LABEL: @nonnull_load_as_inner(
+; CHECK-DL-NEXT:    [[PTR:%.*]] = load ptr addrspace(1), ptr [[ADDR:%.*]], align 8, !nonnull [[META0:![0-9]+]]
+; CHECK-DL-NEXT:    [[CMP:%.*]] = icmp eq ptr addrspace(1) [[PTR]], null
+; CHECK-DL-NEXT:    ret i1 [[CMP]]
+;
+  %ptr = load ptr addrspace(1), ptr %addr, !nonnull !{}
+  %cmp = icmp eq ptr addrspace(1) %ptr, null
+  ret i1 %cmp
+}
+
+@A = global i32 0
+@B = global i32 0
+@A.alias = alias i32, ptr @A
+
+define i1 @globals_inequal() {
+; CHECK-LABEL: @globals_inequal(
+; CHECK-NEXT:    ret i1 true
+;
+; CHECK-DL-LABEL: @globals_inequal(
+; CHECK-DL-NEXT:    ret i1 true
+;
+  %res = icmp ne ptr @A, @B
+  ret i1 %res
+}
+
+; TODO: Never equal
+define i1 @globals_offset_inequal() {
+; CHECK-LABEL: @globals_offset_inequal(
+; CHECK-NEXT:    ret i1 icmp ne (ptr getelementptr (i8, ptr @A, i64 1), ptr getelementptr (i8, ptr @B, i64 1))
+;
+; CHECK-DL-LABEL: @globals_offset_inequal(
+; CHECK-DL-NEXT:    ret i1 icmp ne (ptr getelementptr (i8, ptr @A, i32 1), ptr getelementptr (i8, ptr @B, i32 1))
+;
+  %a.off = getelementptr i8, ptr @A, i32 1
+  %b.off = getelementptr i8, ptr @B, i32 1
+  %res = icmp ne ptr %a.off, %b.off
+  ret i1 %res
+}
diff --git a/llvm/test/Transforms/InstSimplify/icmp-dl-sentinel.ll b/llvm/test/Transforms/InstSimplify/icmp-dl-sentinel.ll
new file mode 100755
index 0000000000000..c8fd6646d3b7b
--- /dev/null
+++ b/llvm/test/Transforms/InstSimplify/icmp-dl-sentinel.ll
@@ -0,0 +1,23 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
+; RUN: opt < %s -passes=instsimplify -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S | FileCheck -check-prefixes=CHECK-DL %s
+
+declare void @usei8ptr(ptr %ptr)
+
+define i1 @load_ptr_null_valid(ptr %p) null_pointer_is_valid {
+; CHECK-LABEL: @load_ptr_null_valid(
+; CHECK-NEXT:    [[LOAD_P:%.*]] = load ptr, ptr [[P:%.*]], align 8, !dereferenceable [[META0:![0-9]+]]
+; CHECK-NEXT:    [[R:%.*]] = icmp ne ptr [[LOAD_P]], null
+; CHECK-NEXT:    ret i1 [[R]]
+;
+; CHECK-DL-LABEL: @load_ptr_null_valid(
+; CHECK-DL-NEXT:    ret i1 true
+;
+; ASM-LABEL: @load_ptr_null_valid(
+; ASM-NEXT:    [[LOAD_P:%.*]] = load ptr, ptr [[P:%.*]], align 8, !dereferenceable [[META0:![0-9]+]]
+; ASM-NEXT:    [[R:%.*]] = icmp ne ptr [[LOAD_P]], null
+; ASM-NEXT:    ret i1 [[R]]
+  %load_p = load ptr, ptr %p, !dereferenceable !{i64 8}
+  %r = icmp ne ptr %load_p, null
+  ret i1 %r
+}
diff --git a/llvm/test/Transforms/InstSimplify/null-ptr-is-valid-dl-sentinel.ll b/llvm/test/Transforms/InstSimplify/null-ptr-is-valid-dl-sentinel.ll
new file mode 100755
index 0000000000000..0f6a3af63a189
--- /dev/null
+++ b/llvm/test/Transforms/InstSimplify/null-ptr-is-valid-dl-sentinel.ll
@@ -0,0 +1,80 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt -S -passes=instsimplify < %s | FileCheck %s
+; RUN: opt -S -passes=instsimplify -data-layout=z0:1-z2:neg1-z3:neg1-z5:neg1 -S < %s | FileCheck %s --check-prefixes=CHECK-DL
+; A 0 valued byval pointer may be valid
+define i1 @byval_may_be_zero(ptr addrspace(5) byval(i32) %ptr) {
+; CHECK-LABEL: @byval_may_be_zero(
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr addrspace(5) [[PTR:%.*]], null
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+; CHECK-DL-LABEL: @byval_may_be_zero(
+; CHECK-DL-NEXT:    ret i1 false
+;
+  %cmp = icmp eq ptr addrspace(5) %ptr, null
+  ret i1 %cmp
+}
+
+define i1 @non-byval_may_be_zero(ptr addrspace(5) %ptr) {
+; CHECK-LABEL: @non-byval_may_be_zero(
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr addrspace(5) [[PTR:%.*]], null
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+; CHECK-DL-LABEL: @non-byval_may_be_zero(
+; CHECK-DL-NEXT:    ret i1 false
+;
+  %cmp = icmp eq ptr addrspace(5) %ptr, null
+  ret i1 %cmp
+}
+
+define i1 @ptr_may_be_zero(ptr addrspace(5) %ptr) {
+; CHECK-LABEL: @ptr_may_be_zero(
+; CHECK-NEXT:    [[LOAD:%.*]] = load ptr addrspace(5), ptr addrspace(5) [[PTR:%.*]], align 8
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr addrspace(5) [[LOAD]], null
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+; CHECK-DL-LABEL: @ptr_may_be_zero(
+; CHECK-DL-NEXT:    ret i1 false
+;
+  %load = load ptr addrspace(5), ptr addrspace(5) %ptr
+  %cmp = icmp eq ptr addrspace(5) %load, null
+  ret i1 %cmp
+}
+
+; A 0 valued byval pointer may be valid
+define i1 @byval_may_be_zero_addrspace3(ptr addrspace(3) byval(i32) %ptr) {
+; CHECK-LABEL: @byval_may_be_zero_addrspace3(
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr addrspace(3) [[PTR:%.*]], null
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+; CHECK-DL-LABEL: @byval_may_be_zero_addrspace3(
+; CHECK-DL-NEXT:    ret i1 false
+;
+  %cmp = icmp eq ptr addrspace(3) %ptr, null
+  ret i1 %cmp
+}
+
+define i1 @non-byval_may_be_zero_addrspace3(ptr addrspace(3) %ptr) {
+; CHECK-LABEL: @non-byval_may_be_zero_addrspace3(
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr addrspace(3) [[PTR:%.*]], null
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+; CHECK-DL-LABEL: @non-byval_may_be_zero_addrspace3(
+; CHECK-DL-NEXT:    ret i1 false
+;
+  %cmp = icmp eq ptr addrspace(3) %ptr, null
+  ret i1 %cmp
+}
+
+define i1 @ptr_may_be_zero_addrspace3(ptr addrspace(3) %ptr) {
+; CHECK-LABEL: @ptr_may_be_zero_addrspace3(
+; CHECK-NEXT:    [[LOAD:%.*]] = load ptr addrspace(3), ptr addrspace(3) [[PTR:%.*]], align 8
+; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr addrspace(3) [[LOAD]], null
+; CHECK-NEXT:    ret i1 [[CMP]]
+;
+; CHECK-DL-LABEL: @ptr_may_be_zero_addrspace3(
+; CHECK-DL-NEXT:    ret i1 false
+;
+  %load = load ptr addrspace(3), ptr addrspace(3) %ptr
+  %cmp = icmp eq ptr addrspace(3) %load, null
+  ret i1 %cmp
+}