[Attributor] AANoCapture: Regard a comparison to null as nocapture

[uenoku]

Summary

This patch treats a pointer comparison to constant null as no capture instruction when null pointer is not defined in AANoCapture.

[uenoku]

I have missed to check the dereferenceability of the pointer. I'll fix it later.
So now the tests are broken.

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

4361

I think we have enough use cases of this hideous construct by now that we can make a helper function.

[uenoku]

I have misunderstood how CaptureTracker works. AANoCapture already has this functionality :) So I'd close it.
But I have thought some of FIXME in the test seems wrong.

llvm/lib/Transforms/IPO/Attributor.cpp

4361

I'll add some helper function for this.

llvm/test/Transforms/Attributor/nocapture-2.ll

14–42

Based on the discussion in D60047, %p can't have nocapture in both functions.

llvm/lib/Transforms/IPO/Attributor.cpp

if (isa<PtrToIntInst>(UInst)) {
       return valueMayBeCaptured(UInst);
     }
 
     // Explicitly catch return instructions.
     if (isa<ReturnInst>(UInst))
       return isCapturedIn(/* Memory */ false, /* Integer */ false,
                           /* Return */ true);
 
+    // Comparison to null should be regarded as nocapture.
+    if (ICmpInst *ICmp = dyn_cast<ICmpInst>(UInst)) {
+      const Function *F = UInst->getFunction();
+      bool NullPointerIsDefined =
+          F ? llvm::NullPointerIsDefined(
+                  F, U->get()->getType()->getPointerAddressSpace())
+            : true;
+      if (!NullPointerIsDefined &&
+          isa<ConstantPointerNull>(ICmp->getOperand(1 - U->getOperandNo())))
+        return isCapturedIn(/* Memory */ false, /* Integer */ false,
+                            /* Return */ false);
+    }
+
     // For now we only use special logic for call sites. However, the tracker
     // itself knows about a lot of other non-capturing cases already.
     CallSite CS(UInst);
     if (!CS || !CS.isArgOperand(U))
       return isCapturedIn(/* Memory */ true, /* Integer */ true,
                           /* Return */ true);
 
     unsigned ArgNo = CS.getArgumentNo(U);

llvm/test/Transforms/Attributor/noalias.ll

 
 return:
   %retval.0 = phi i8* [ %A, %if.end ], [ null, %entry ]
   ret i8* %retval.0
 }
 
 ; TEST 8
 
-; CHECK: define noalias i8* @test8(i32* %0)
+; CHECK: define noalias i8* @test8(i32* nocapture readnone %0)
 define i8* @test8(i32* %0) nounwind uwtable {
   %2 = tail call noalias i8* @malloc(i64 4)
   %3 = icmp ne i32* %0, null
   br i1 %3, label %4, label %5
 
 4:                                                ; preds = %1
   store i8 10, i8* %2
   br label %5

llvm/test/Transforms/Attributor/nocapture-1.ll

 @g3 = global i8* null
 ; ATTRIBUTOR: define void @captureStrip(i8* writeonly %p)
 define void @captureStrip(i8* %p) {
   %b = call i8* @llvm.strip.invariant.group.p0i8(i8* %p)
   store i8* %b, i8** @g3
   ret void
 }
 
-; ATTRIBUTOR: define i1 @captureICmp(i32* nofree readnone %x)
+; ATTRIBUTOR: define i1 @captureICmp(i32* nocapture nofree readnone %x)
 define i1 @captureICmp(i32* %x) {
   %1 = icmp eq i32* %x, null
   ret i1 %1
 }
 
-; ATTRIBUTOR: define i1 @captureICmpRev(i32* nofree readnone %x)
+; ATTRIBUTOR: define i1 @captureICmpRev(i32* nocapture nofree readnone %x)
 define i1 @captureICmpRev(i32* %x) {
   %1 = icmp eq i32* null, %x
   ret i1 %1
 }
 
 ; ATTRIBUTOR: define i1 @nocaptureInboundsGEPICmp(i32* nocapture nofree readnone %x)
 define i1 @nocaptureInboundsGEPICmp(i32* %x) {
   %1 = getelementptr inbounds i32, i32* %x, i32 5

llvm/test/Transforms/Attributor/nocapture-2.ll

 ; RUN: opt -functionattrs -attributor -attributor-manifest-internal -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=5 -S < %s | FileCheck %s
 ;
 ; Test cases specifically designed for the "no-capture" argument attribute.
 ; We use FIXME's to indicate problems and missing attributes.
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; TEST comparison against NULL
 ;
 ; int is_null_return(int *p) {
 ;   return p == 0;
 ; }
 ;
-; FIXME: no-capture missing for %p
-; CHECK: define i32 @is_null_return(i32* nofree readnone %p)
+; CHECK: define i32 @is_null_return(i32* nocapture nofree readnone %p)
 define i32 @is_null_return(i32* %p) #0 {
 entry:
   %cmp = icmp eq i32* %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;
 ; }
 ;
-; FIXME: no-capture missing for %p
-; CHECK: define i32 @is_null_control(i32* nofree readnone %p)
+; CHECK: define i32 @is_null_control(i32* nocapture nofree readnone %p)
 define i32 @is_null_control(i32* %p) #0 {
 entry:
   %retval = alloca i32, align 4
   %cmp = icmp eq i32* %p, null
   br i1 %cmp, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   store i32 1, i32* %retval, align 4
   br label %return
 
 if.end:                                           ; preds = %entry
   %cmp1 = icmp eq i32* null, %p
   br i1 %cmp1, label %if.then2, label %if.end3
 
 if.then2:                                         ; preds = %if.end
   store i32 1, i32* %retval, align 4

 ; 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.
 ;
-; CHECK:     define i32* @ret_arg_or_unknown(i32* readnone %b)
-; CHECK:     define i32* @ret_arg_or_unknown_through_phi(i32* readnone %b)
+; CHECK:     define i32* @ret_arg_or_unknown(i32* readnone "no-capture-maybe-returned" %b)
+; CHECK:     define i32* @ret_arg_or_unknown_through_phi(i32* readnone "no-capture-maybe-returned" %b)
 
 declare i32* @unknown()
 
 define i32* @ret_arg_or_unknown(i32* %b) #0 {
 entry:
   %cmp = icmp eq i32* %b, null
   br i1 %cmp, label %ret_arg, label %ret_unknown
 

llvm/test/Transforms/Attributor/nonnull.ll

 ; 2. Because f2 is internal function, f2(i32* %arg) -> @f2(i32* nonnull %arg)
 ; 3. In f1:bb4 %tmp5 is nonnull and f3 is internal function.
 ;    Then, f3(i32* %arg) -> @f3(i32* nonnull %arg)
 ; 4. We get nonnull in whole f1 call sites so f1(i32* %arg) -> @f1(i32* nonnull %arg)
 
 
 define internal i32* @f1(i32* %arg) {
 ; FIXME: missing nonnull It should be nonnull @f1(i32* nonnull readonly %arg)
-; ATTRIBUTOR: define internal nonnull i32* @f1(i32* nofree readonly %arg)
+; ATTRIBUTOR: define internal nonnull i32* @f1(i32* nocapture nofree readonly %arg)
 
 bb:
   %tmp = icmp eq i32* %arg, null
   br i1 %tmp, label %bb9, label %bb1
 
 bb1:                                              ; preds = %bb
   %tmp2 = load i32, i32* %arg, align 4
   %tmp3 = icmp eq i32 %tmp2, 0
   br i1 %tmp3, label %bb6, label %bb4
 
 bb4:                                              ; preds = %bb1
   %tmp5 = getelementptr inbounds i32, i32* %arg, i64 1
-; ATTRIBUTOR: %tmp5b = tail call nonnull i32* @f3(i32* nofree nonnull readonly %tmp5)
+; ATTRIBUTOR: %tmp5b = tail call nonnull i32* @f3(i32* nocapture nofree nonnull readonly %tmp5)
   %tmp5b = tail call i32* @f3(i32* %tmp5)
   %tmp5c = getelementptr inbounds i32, i32* %tmp5b, i64 -1
   br label %bb9
 
 bb6:                                              ; preds = %bb1
-; ATTRIBUTOR: %tmp7 = tail call nonnull i32* @f2(i32* nofree nonnull readonly align 4 dereferenceable(4) %arg)
+; ATTRIBUTOR: %tmp7 = tail call nonnull i32* @f2(i32* nocapture nofree nonnull readonly align 4 dereferenceable(4) %arg)
   %tmp7 = tail call i32* @f2(i32* %arg)
   ret i32* %tmp7
 
 bb9:                                              ; preds = %bb4, %bb
   %tmp10 = phi i32* [ %tmp5c, %bb4 ], [ inttoptr (i64 4 to i32*), %bb ]
   ret i32* %tmp10
 }
 
 define internal i32* @f2(i32* %arg) {
-; ATTRIBUTOR: define internal nonnull i32* @f2(i32* nofree nonnull readonly align 4 dereferenceable(4) %arg)
+; ATTRIBUTOR: define internal nonnull i32* @f2(i32* nocapture nofree nonnull readonly align 4 dereferenceable(4) %arg)
 bb:
-; ATTRIBUTOR:   %tmp = tail call nonnull i32* @f1(i32* nofree nonnull readonly align 4 dereferenceable(4) %arg)
+; ATTRIBUTOR:   %tmp = tail call nonnull i32* @f1(i32* nocapture nofree nonnull readonly align 4 dereferenceable(4) %arg)
   %tmp = tail call i32* @f1(i32* %arg)
   ret i32* %tmp
 }
 
 define dso_local noalias i32* @f3(i32* %arg) {
-; FIXME: missing nonnull. It should be nonnull @f3(i32* nonnull readonly %arg)
-; ATTRIBUTOR: define dso_local noalias nonnull i32* @f3(i32* nofree readonly %arg)
+; FIXME: missing nonnull. It should be nonnull @f3(i32* nocapture nonnull readonly %arg)
+; ATTRIBUTOR: define dso_local noalias nonnull i32* @f3(i32* nocapture nofree readonly %arg)
 bb:
 ; FIXME: missing nonnull. It should be @f1(i32* nonnull readonly %arg)
-; ATTRIBUTOR:   %tmp = call nonnull i32* @f1(i32* nofree readonly %arg)
+; ATTRIBUTOR:   %tmp = call nonnull i32* @f1(i32* nocapture nofree readonly %arg)
   %tmp = call i32* @f1(i32* %arg)
   ret i32* %tmp
 }
 
 ; TEST 15
 define void @f15(i8* %arg) {
 ; ATTRIBUTOR:   tail call void @use1(i8* nonnull dereferenceable(4) %arg)
 

llvm/test/Transforms/Attributor/read_write_returned_arguments_scc.ll

-; RUN: opt -functionattrs -enable-nonnull-arg-prop -attributor -attributor-manifest-internal -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=6 -S < %s | FileCheck %s
+; RUN: opt -functionattrs -enable-nonnull-arg-prop -attributor -attributor-manifest-internal -attributor-disable=false -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=7 -S < %s | FileCheck %s
 ;
 ; 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);

 ;   4 - Number of arguments marked readnone
 ;   6 - Number of arguments marked writeonly
 ;   6 - Number of arguments marked readonly
 ;   6 - Number of arguments marked returned
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; CHECK: Function Attrs: argmemonly nofree nosync nounwind
-; CHECK-NEXT: define i32* @external_ret2_nrw(i32* nofree %n0, i32* nofree %r0, i32* nofree returned %w0)
+; CHECK-NEXT: define i32* @external_ret2_nrw(i32* nocapture nofree readnone %n0, i32* nocapture nofree readonly %r0, i32* nofree returned writeonly "no-capture-maybe-returned" %w0)
 define i32* @external_ret2_nrw(i32* %n0, i32* %r0, i32* %w0) {
 entry:
   %call = call i32* @internal_ret0_nw(i32* %n0, i32* %w0)
   %call1 = call i32* @internal_ret1_rrw(i32* %r0, i32* %r0, i32* %w0)
   %call2 = call i32* @external_sink_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
   %call3 = call i32* @internal_ret1_rw(i32* %r0, i32* %w0)
   ret i32* %call3
 }
 
 ; CHECK: Function Attrs: argmemonly nofree nosync nounwind
-; CHECK-NEXT: define internal i32* @internal_ret0_nw(i32* nofree returned %n0, i32* nofree %w0)
+; CHECK-NEXT: define internal i32* @internal_ret0_nw(i32* noalias nofree readnone returned "no-capture-maybe-returned" %n0, i32* nocapture nofree writeonly %w0)
 define internal i32* @internal_ret0_nw(i32* %n0, i32* %w0) {
 entry:
   %r0 = alloca i32, align 4
   %r1 = alloca i32, align 4
   %tobool = icmp ne i32* %n0, null
   br i1 %tobool, label %if.end, label %if.then
 
 if.then:                                          ; preds = %entry
if.end:                                           ; preds = %entry
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   %retval.0 = phi i32* [ %call5, %if.end ], [ %n0, %if.then ]
   ret i32* %retval.0
 }
 
 ; CHECK: Function Attrs: argmemonly nofree nosync nounwind
-; CHECK-NEXT: define internal i32* @internal_ret1_rrw(i32* nofree nonnull align 4 dereferenceable(4) %r0, i32* nofree returned %r1, i32* nofree %w0)
+; CHECK-NEXT: define internal i32* @internal_ret1_rrw(i32* nocapture nofree nonnull readonly align 4 dereferenceable(4) %r0, i32* nocapture nofree readonly returned %r1, i32* nocapture nofree writeonly %w0)
 define internal i32* @internal_ret1_rrw(i32* %r0, i32* %r1, i32* %w0) {
 entry:
   %0 = load i32, i32* %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
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   %retval.0 = phi i32* [ %call8, %if.end ], [ %r1, %if.then ]
   ret i32* %retval.0
 }
 
 ; CHECK: Function Attrs: argmemonly nofree norecurse nosync nounwind
-; CHECK-NEXT: define i32* @external_sink_ret2_nrw(i32* nofree readnone %n0, i32* nocapture nofree readonly %r0, i32* nofree returned writeonly "no-capture-maybe-returned" %w0)
+; CHECK-NEXT: define i32* @external_sink_ret2_nrw(i32* nocapture nofree readnone %n0, i32* nocapture nofree readonly %r0, i32* nofree returned writeonly "no-capture-maybe-returned" %w0)
 define i32* @external_sink_ret2_nrw(i32* %n0, i32* %r0, i32* %w0) {
 entry:
   %tobool = icmp ne i32* %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, i32* %r0, align 4
   store i32 %0, i32* %w0, align 4
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   ret i32* %w0
 }
 
 ; CHECK: Function Attrs: argmemonly nofree nosync nounwind
-; CHECK-NEXT: define internal i32* @internal_ret1_rw(i32* nofree nonnull align 4 dereferenceable(4) %r0, i32* nofree returned %w0)
+; CHECK-NEXT: define internal i32* @internal_ret1_rw(i32* nocapture nofree nonnull readonly align 4 dereferenceable(4) %r0, i32* nofree returned writeonly "no-capture-maybe-returned" %w0)
 define internal i32* @internal_ret1_rw(i32* %r0, i32* %w0) {
 entry:
   %0 = load i32, i32* %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
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   %retval.0 = phi i32* [ %call4, %if.end ], [ %w0, %if.then ]
   ret i32* %retval.0
 }
 
 ; CHECK: Function Attrs: argmemonly nofree nosync nounwind
-; CHECK-NEXT: define i32* @external_source_ret2_nrw(i32* nofree %n0, i32* nofree %r0, i32* nofree returned %w0)
+; CHECK-NEXT: define i32* @external_source_ret2_nrw(i32* nocapture nofree readnone %n0, i32* nocapture nofree readonly %r0, i32* nofree returned writeonly "no-capture-maybe-returned" %w0)
 define i32* @external_source_ret2_nrw(i32* %n0, i32* %r0, i32* %w0) {
 entry:
   %call = call i32* @external_sink_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
   %call1 = call i32* @external_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
   ret i32* %call1
 }
 
 ; Verify that we see only expected attribute sets, the above lines only check
 ; for a subset relation.
 ;
 ; CHECK-NOT: attributes #
 ; CHECK: attributes #{{.*}} = { argmemonly nofree nosync nounwind }
 ; CHECK: attributes #{{.*}} = { argmemonly nofree norecurse nosync nounwind }
 ; CHECK: attributes #{{.*}} = { nosync nounwind }
 ; CHECK-NOT: attributes #

llvm/test/Transforms/Attributor/returned.ll

entry:
   %tobool = icmp ne i32 %v, 0
   %call = call i32* @rt1(i32* %a)
   %sel = select i1 %tobool, i32* undef, i32* %call
   ret i32* %sel
 }
 
 ; TEST another SCC test
 ;
-; BOTH:    define i32* @rt2_helper(i32* nofree readnone returned %a)
-; BOTH:    define i32* @rt2(i32* nofree readnone %a, i32* nofree readnone "no-capture-maybe-returned" %b)
+; BOTH:    define i32* @rt2_helper(i32* nofree readnone returned "no-capture-maybe-returned" %a)
+; BOTH:    define i32* @rt2(i32* nofree readnone "no-capture-maybe-returned" %a, i32* nofree readnone "no-capture-maybe-returned" %b)
 define i32* @rt2_helper(i32* %a) #0 {
 entry:
   %call = call i32* @rt2(i32* %a, i32* %a)
   ret i32* %call
 }
 
 define i32* @rt2(i32* %a, i32 *%b) #0 {
 entry:
   %cmp = icmp eq i32* %a, null
   br i1 %cmp, label %if.then, label %if.end
 
 if.then:
   %call = call i32* @rt2_helper(i32* %a)
   br label %if.end
 
 if.end:
   %sel = phi i32* [ %b, %entry], [%call, %if.then]
   ret i32* %sel
 }
 
 ; TEST another SCC test
 ;
-; BOTH:    define i32* @rt3_helper(i32* nofree readnone %a, i32* nofree readnone returned "no-capture-maybe-returned" %b)
-; BOTH:    define i32* @rt3(i32* nofree readnone %a, i32* nofree readnone returned "no-capture-maybe-returned" %b)
+; BOTH:    define i32* @rt3_helper(i32* nocapture nofree readnone %a, i32* nofree readnone returned "no-capture-maybe-returned" %b)
+; BOTH:    define i32* @rt3(i32* nocapture nofree readnone %a, i32* nofree readnone returned "no-capture-maybe-returned" %b)
 define i32* @rt3_helper(i32* %a, i32* %b) #0 {
 entry:
   %call = call i32* @rt3(i32* %a, i32* %b)
   ret i32* %call
 }
 
 define i32* @rt3(i32* %a, i32 *%b) #0 {
 entry:

 ; double* bitcasts_select_and_phi(int* b) {
 ;   double* x = b;
 ;   if (b == 0)
 ;     x = b;
 ;   return b != 0 ? b : x;
 ; }
 ;
 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
-; BOTH-NEXT: define double* @bitcasts_select_and_phi(i32* nofree readnone returned %b)
+; BOTH-NEXT: define double* @bitcasts_select_and_phi(i32* nofree readnone returned "no-capture-maybe-returned" %b)
 ;
 ;
 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind readnone uwtable
-; ATTRIBUTOR-NEXT: define double* @bitcasts_select_and_phi(i32* nofree readnone returned %b)
+; ATTRIBUTOR-NEXT: define double* @bitcasts_select_and_phi(i32* nofree readnone returned "no-capture-maybe-returned" %b)
 define double* @bitcasts_select_and_phi(i32* %b) #0 {
 entry:
   %bc0 = bitcast i32* %b to double*
   %cmp = icmp eq double* %bc0, null
   br i1 %cmp, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   %bc1 = bitcast i32* %b to double*

 ;   if (b == 0)
 ;     return (double*)b;
 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
-; BOTH-NEXT:  define double* @ret_arg_arg_undef(i32* nofree readnone returned %b)
+; BOTH-NEXT:  define double* @ret_arg_arg_undef(i32* nofree readnone returned "no-capture-maybe-returned" %b)
 ;
 ;
 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind readnone uwtable
-; ATTRIBUTOR-NEXT: define double* @ret_arg_arg_undef(i32* nofree readnone returned %b)
+; ATTRIBUTOR-NEXT: define double* @ret_arg_arg_undef(i32* nofree readnone returned "no-capture-maybe-returned" %b)
 define double* @ret_arg_arg_undef(i32* %b) #0 {
 entry:
   %bc0 = bitcast i32* %b to double*
   %cmp = icmp eq double* %bc0, null
   br i1 %cmp, label %ret_arg0, label %if.end
 
 ret_arg0:
   %bc1 = bitcast i32* %b to double*

 ;   if (b == 0)
 ;     return (double*)b;
 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
-; BOTH-NEXT:  define double* @ret_undef_arg_arg(i32* nofree readnone returned %b)
+; BOTH-NEXT:  define double* @ret_undef_arg_arg(i32* nofree readnone returned "no-capture-maybe-returned" %b)
 ;
 ;
 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind readnone uwtable
-; ATTRIBUTOR-NEXT: define double* @ret_undef_arg_arg(i32* nofree readnone returned %b)
+; ATTRIBUTOR-NEXT: define double* @ret_undef_arg_arg(i32* nofree readnone returned "no-capture-maybe-returned" %b)
 define double* @ret_undef_arg_arg(i32* %b) #0 {
 entry:
   %bc0 = bitcast i32* %b to double*
   %cmp = icmp eq double* %bc0, null
   br i1 %cmp, label %ret_undef, label %if.end
 
 ret_undef:
   ret double *undef

 ;   if (b == 0)
 ;     /* return undef */
 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
-; BOTH-NEXT:  define double* @ret_undef_arg_undef(i32* nofree readnone returned %b)
+; BOTH-NEXT:  define double* @ret_undef_arg_undef(i32* nofree readnone returned "no-capture-maybe-returned" %b)
 ;
-; ATTRIBUTOR: define double* @ret_undef_arg_undef(i32* nofree readnone returned %b)
+; ATTRIBUTOR: define double* @ret_undef_arg_undef(i32* nofree readnone returned "no-capture-maybe-returned" %b)
 define double* @ret_undef_arg_undef(i32* %b) #0 {
 entry:
   %bc0 = bitcast i32* %b to double*
   %cmp = icmp eq double* %bc0, null
   br i1 %cmp, label %ret_undef0, label %if.end
 
 ret_undef0:
   ret double *undef