| ; 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,TUNIT |
| ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC |
| ; |
| ; 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" |
| 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]] |
| ; |
| 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]] |
| ; |
| 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 singleton SCC |
| ; |
| ; double *srec0(double *a) { |
| ; srec0(a); |
| ; return 0; |
| ; } |
| ; |
| define ptr @srec0(ptr %a) #0 { |
| ; CHECK: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable |
| ; CHECK-LABEL: define noalias noundef align 4294967296 ptr @srec0 |
| ; CHECK-SAME: (ptr nocapture nofree readnone [[A:%.*]]) #[[ATTR1:[0-9]+]] { |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: ret ptr null |
| ; |
| entry: |
| %call = call ptr @srec0(ptr %a) |
| ret ptr null |
| } |
| |
| ; TEST singleton SCC with lots of nested recursive calls |
| ; |
| ; int* srec16(int* a) { |
| ; return srec16(srec16(srec16(srec16( |
| ; srec16(srec16(srec16(srec16( |
| ; srec16(srec16(srec16(srec16( |
| ; srec16(srec16(srec16(srec16( |
| ; a |
| ; )))))))))))))))); |
| ; } |
| ; |
| ; Other arguments are possible here due to the no-return behavior. |
| ; |
| define ptr @srec16(ptr %a) #0 { |
| ; CHECK: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable |
| ; CHECK-LABEL: define noalias nonnull align 4294967296 dereferenceable(4294967295) ptr @srec16 |
| ; CHECK-SAME: (ptr nocapture nofree readnone [[A:%.*]]) #[[ATTR1]] { |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: ret ptr undef |
| ; |
| entry: |
| %call = call ptr @srec16(ptr %a) |
| %call1 = call ptr @srec16(ptr %call) |
| %call2 = call ptr @srec16(ptr %call1) |
| %call3 = call ptr @srec16(ptr %call2) |
| %call4 = call ptr @srec16(ptr %call3) |
| %call5 = call ptr @srec16(ptr %call4) |
| %call6 = call ptr @srec16(ptr %call5) |
| %call7 = call ptr @srec16(ptr %call6) |
| %call8 = call ptr @srec16(ptr %call7) |
| %call9 = call ptr @srec16(ptr %call8) |
| %call10 = call ptr @srec16(ptr %call9) |
| %call11 = call ptr @srec16(ptr %call10) |
| %call12 = call ptr @srec16(ptr %call11) |
| %call13 = call ptr @srec16(ptr %call12) |
| %call14 = call ptr @srec16(ptr %call13) |
| %call15 = call ptr @srec16(ptr %call14) |
| ret ptr %call15 |
| } |
| |
| ; 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:%.*]]) #[[ATTR2:[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]]) #[[ATTR2]] |
| ; 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]]) #[[ATTR2]] |
| ; CHECK-NEXT: [[CALL2:%.*]] = call ptr @scc_A(ptr noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[A]]) #[[ATTR2]] |
| ; 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]] |
| ; |
| 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:%.*]]) #[[ATTR2]] { |
| ; 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]]) #[[ATTR2]] |
| ; 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]]) #[[ATTR2]] |
| ; CHECK-NEXT: [[CALL2:%.*]] = call ptr @scc_C(ptr noalias nofree noundef readnone dereferenceable_or_null(8) "no-capture-maybe-returned" [[A]]) #[[ATTR2]] |
| ; 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]] |
| ; |
| 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:%.*]]) #[[ATTR2]] { |
| ; 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]]) #[[ATTR2]] |
| ; 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]]) #[[ATTR2]] |
| ; 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]]) #[[ATTR2]] |
| ; 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]]) #[[ATTR2]] |
| ; CHECK-NEXT: ret ptr [[A]] |
| ; |
| 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 call to external function, marked no-capture |
| ; |
| ; void external_no_capture(int /* no-capture */ *p); |
| ; void test_external_no_capture(int *p) { |
| ; external_no_capture(p); |
| ; } |
| ; |
| declare void @external_no_capture(ptr nocapture) |
| |
| define void @test_external_no_capture(ptr %p) #0 { |
| ; CHECK: Function Attrs: noinline nounwind uwtable |
| ; CHECK-LABEL: define void @test_external_no_capture |
| ; CHECK-SAME: (ptr nocapture [[P:%.*]]) #[[ATTR3:[0-9]+]] { |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: call void @external_no_capture(ptr nocapture [[P]]) |
| ; CHECK-NEXT: ret void |
| ; |
| entry: |
| call void @external_no_capture(ptr %p) |
| ret void |
| } |
| |
| ; TEST call to external var-args function, marked no-capture |
| ; |
| ; void test_var_arg_call(char *p, int a) { |
| ; printf(p, a); |
| ; } |
| ; |
| define void @test_var_arg_call(ptr %p, i32 %a) #0 { |
| ; CHECK: Function Attrs: noinline nounwind uwtable |
| ; CHECK-LABEL: define void @test_var_arg_call |
| ; CHECK-SAME: (ptr nocapture [[P:%.*]], i32 [[A:%.*]]) #[[ATTR3]] { |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[CALL:%.*]] = call i32 (ptr, ...) @printf(ptr nocapture [[P]], i32 [[A]]) |
| ; CHECK-NEXT: ret void |
| ; |
| entry: |
| %call = call i32 (ptr, ...) @printf(ptr %p, i32 %a) |
| ret void |
| } |
| |
| declare i32 @printf(ptr nocapture, ...) |
| |
| |
| ; TEST "captured" only through return |
| ; |
| ; long *not_captured_but_returned_0(long *a) { |
| ; *a1 = 0; |
| ; return a; |
| ; } |
| ; |
| ; There should *not* be a no-capture attribute on %a |
| define ptr @not_captured_but_returned_0(ptr %a) #0 { |
| ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable |
| ; CHECK-LABEL: define noundef nonnull align 8 dereferenceable(8) ptr @not_captured_but_returned_0 |
| ; CHECK-SAME: (ptr nofree noundef nonnull returned writeonly align 8 dereferenceable(8) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4:[0-9]+]] { |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: store i64 0, ptr [[A]], align 8 |
| ; CHECK-NEXT: ret ptr [[A]] |
| ; |
| entry: |
| store i64 0, ptr %a, align 8 |
| ret ptr %a |
| } |
| |
| ; TEST "captured" only through return |
| ; |
| ; long *not_captured_but_returned_1(long *a) { |
| ; *(a+1) = 1; |
| ; return a + 1; |
| ; } |
| ; |
| ; There should *not* be a no-capture attribute on %a |
| define ptr @not_captured_but_returned_1(ptr %a) #0 { |
| ; CHECK: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable |
| ; CHECK-LABEL: define noundef nonnull align 8 dereferenceable(8) ptr @not_captured_but_returned_1 |
| ; CHECK-SAME: (ptr nofree nonnull writeonly align 8 dereferenceable(16) "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4]] { |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr inbounds i64, ptr [[A]], i64 1 |
| ; CHECK-NEXT: store i64 1, ptr [[ADD_PTR]], align 8 |
| ; CHECK-NEXT: ret ptr [[ADD_PTR]] |
| ; |
| entry: |
| %add.ptr = getelementptr inbounds i64, ptr %a, i64 1 |
| store i64 1, ptr %add.ptr, align 8 |
| ret ptr %add.ptr |
| } |
| |
| ; TEST calls to "captured" only through return functions |
| ; |
| ; void test_not_captured_but_returned_calls(long *a) { |
| ; not_captured_but_returned_0(a); |
| ; not_captured_but_returned_1(a); |
| ; } |
| ; |
| define void @test_not_captured_but_returned_calls(ptr %a) #0 { |
| ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable |
| ; TUNIT-LABEL: define void @test_not_captured_but_returned_calls |
| ; TUNIT-SAME: (ptr nocapture nofree writeonly align 8 [[A:%.*]]) #[[ATTR4]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call ptr @not_captured_but_returned_0(ptr nofree noundef writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR12:[0-9]+]] |
| ; TUNIT-NEXT: [[CALL1:%.*]] = call ptr @not_captured_but_returned_1(ptr nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR12]] |
| ; TUNIT-NEXT: ret void |
| ; |
| ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable |
| ; CGSCC-LABEL: define void @test_not_captured_but_returned_calls |
| ; CGSCC-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A:%.*]]) #[[ATTR5:[0-9]+]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call ptr @not_captured_but_returned_0(ptr nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR14:[0-9]+]] |
| ; CGSCC-NEXT: [[CALL1:%.*]] = call ptr @not_captured_but_returned_1(ptr nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR14]] |
| ; CGSCC-NEXT: ret void |
| ; |
| entry: |
| %call = call ptr @not_captured_but_returned_0(ptr %a) |
| %call1 = call ptr @not_captured_but_returned_1(ptr %a) |
| ret void |
| } |
| |
| ; TEST "captured" only through transitive return |
| ; |
| ; long* negative_test_not_captured_but_returned_call_0a(long *a) { |
| ; return not_captured_but_returned_0(a); |
| ; } |
| ; |
| ; There should *not* be a no-capture attribute on %a |
| define ptr @negative_test_not_captured_but_returned_call_0a(ptr %a) #0 { |
| ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable |
| ; TUNIT-LABEL: define align 8 ptr @negative_test_not_captured_but_returned_call_0a |
| ; TUNIT-SAME: (ptr nofree returned writeonly align 8 "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call ptr @not_captured_but_returned_0(ptr nofree noundef writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR12]] |
| ; TUNIT-NEXT: ret ptr [[A]] |
| ; |
| ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable |
| ; CGSCC-LABEL: define noundef nonnull align 8 dereferenceable(8) ptr @negative_test_not_captured_but_returned_call_0a |
| ; CGSCC-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A:%.*]]) #[[ATTR5]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call noundef nonnull align 8 dereferenceable(8) ptr @not_captured_but_returned_0(ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A]]) #[[ATTR14]] |
| ; CGSCC-NEXT: ret ptr [[CALL]] |
| ; |
| entry: |
| %call = call ptr @not_captured_but_returned_0(ptr %a) |
| ret ptr %call |
| } |
| |
| ; TEST captured through write |
| ; |
| ; void negative_test_not_captured_but_returned_call_0b(long *a) { |
| ; *a = (long)not_captured_but_returned_0(a); |
| ; } |
| ; |
| ; There should *not* be a no-capture attribute on %a |
| define void @negative_test_not_captured_but_returned_call_0b(ptr %a) #0 { |
| ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable |
| ; TUNIT-LABEL: define void @negative_test_not_captured_but_returned_call_0b |
| ; TUNIT-SAME: (ptr nofree writeonly align 8 [[A:%.*]]) #[[ATTR4]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call ptr @not_captured_but_returned_0(ptr nofree noundef writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR12]] |
| ; TUNIT-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[A]] to i64 |
| ; TUNIT-NEXT: store i64 [[TMP0]], ptr [[A]], align 8 |
| ; TUNIT-NEXT: ret void |
| ; |
| ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable |
| ; CGSCC-LABEL: define void @negative_test_not_captured_but_returned_call_0b |
| ; CGSCC-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A:%.*]]) #[[ATTR5]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call ptr @not_captured_but_returned_0(ptr nofree noundef nonnull writeonly align 8 dereferenceable(8) [[A]]) #[[ATTR14]] |
| ; CGSCC-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[CALL]] to i64 |
| ; CGSCC-NEXT: store i64 [[TMP0]], ptr [[A]], align 8 |
| ; CGSCC-NEXT: ret void |
| ; |
| entry: |
| %call = call ptr @not_captured_but_returned_0(ptr %a) |
| %0 = ptrtoint ptr %call to i64 |
| store i64 %0, ptr %a, align 8 |
| ret void |
| } |
| |
| ; TEST "captured" only through transitive return |
| ; |
| ; long* negative_test_not_captured_but_returned_call_1a(long *a) { |
| ; return not_captured_but_returned_1(a); |
| ; } |
| ; |
| ; There should *not* be a no-capture attribute on %a |
| define ptr @negative_test_not_captured_but_returned_call_1a(ptr %a) #0 { |
| ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable |
| ; TUNIT-LABEL: define noundef nonnull align 8 dereferenceable(8) ptr @negative_test_not_captured_but_returned_call_1a |
| ; TUNIT-SAME: (ptr nofree writeonly align 8 "no-capture-maybe-returned" [[A:%.*]]) #[[ATTR4]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call noundef nonnull align 8 dereferenceable(8) ptr @not_captured_but_returned_1(ptr nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR12]] |
| ; TUNIT-NEXT: ret ptr [[CALL]] |
| ; |
| ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable |
| ; CGSCC-LABEL: define noundef nonnull align 8 dereferenceable(8) ptr @negative_test_not_captured_but_returned_call_1a |
| ; CGSCC-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A:%.*]]) #[[ATTR5]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call noundef nonnull align 8 dereferenceable(8) ptr @not_captured_but_returned_1(ptr nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR14]] |
| ; CGSCC-NEXT: ret ptr [[CALL]] |
| ; |
| entry: |
| %call = call ptr @not_captured_but_returned_1(ptr %a) |
| ret ptr %call |
| } |
| |
| ; TEST captured through write |
| ; |
| ; void negative_test_not_captured_but_returned_call_1b(long *a) { |
| ; *a = (long)not_captured_but_returned_1(a); |
| ; } |
| ; |
| ; There should *not* be a no-capture attribute on %a |
| define void @negative_test_not_captured_but_returned_call_1b(ptr %a) #0 { |
| ; TUNIT: Function Attrs: mustprogress nofree noinline norecurse nosync nounwind willreturn memory(write) uwtable |
| ; TUNIT-LABEL: define void @negative_test_not_captured_but_returned_call_1b |
| ; TUNIT-SAME: (ptr nofree writeonly align 8 [[A:%.*]]) #[[ATTR5:[0-9]+]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call align 8 ptr @not_captured_but_returned_1(ptr nofree writeonly align 8 "no-capture-maybe-returned" [[A]]) #[[ATTR12]] |
| ; TUNIT-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[CALL]] to i64 |
| ; TUNIT-NEXT: store i64 [[TMP0]], ptr [[CALL]], align 8 |
| ; TUNIT-NEXT: ret void |
| ; |
| ; CGSCC: Function Attrs: mustprogress nofree noinline nosync nounwind willreturn memory(write) uwtable |
| ; CGSCC-LABEL: define void @negative_test_not_captured_but_returned_call_1b |
| ; CGSCC-SAME: (ptr nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A:%.*]]) #[[ATTR6:[0-9]+]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call align 8 ptr @not_captured_but_returned_1(ptr nofree noundef nonnull writeonly align 8 dereferenceable(16) [[A]]) #[[ATTR14]] |
| ; CGSCC-NEXT: [[TMP0:%.*]] = ptrtoint ptr [[CALL]] to i64 |
| ; CGSCC-NEXT: store i64 [[TMP0]], ptr [[CALL]], align 8 |
| ; CGSCC-NEXT: ret void |
| ; |
| entry: |
| %call = call ptr @not_captured_but_returned_1(ptr %a) |
| %0 = ptrtoint ptr %call to i64 |
| store i64 %0, ptr %call, align 8 |
| ret void |
| } |
| |
| ; 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:%.*]]) #[[ATTR3]] { |
| ; 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]] |
| ; |
| 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:%.*]]) #[[ATTR3]] { |
| ; 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]] |
| ; |
| 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 |
| } |
| |
| |
| ; TEST not captured by readonly external function |
| ; |
| declare ptr @readonly_unknown(ptr, ptr) readonly |
| |
| define void @not_captured_by_readonly_call(ptr %b) #0 { |
| ; TUNIT: Function Attrs: noinline nosync nounwind memory(read) uwtable |
| ; TUNIT-LABEL: define void @not_captured_by_readonly_call |
| ; TUNIT-SAME: (ptr nocapture readonly [[B:%.*]]) #[[ATTR7:[0-9]+]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call ptr @readonly_unknown(ptr readonly [[B]], ptr readonly [[B]]) #[[ATTR13:[0-9]+]] |
| ; TUNIT-NEXT: ret void |
| ; |
| ; CGSCC: Function Attrs: noinline nosync nounwind memory(read) uwtable |
| ; CGSCC-LABEL: define void @not_captured_by_readonly_call |
| ; CGSCC-SAME: (ptr nocapture readonly [[B:%.*]]) #[[ATTR8:[0-9]+]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call ptr @readonly_unknown(ptr readonly [[B]], ptr readonly [[B]]) #[[ATTR15:[0-9]+]] |
| ; CGSCC-NEXT: ret void |
| ; |
| entry: |
| %call = call ptr @readonly_unknown(ptr %b, ptr %b) |
| ret void |
| } |
| |
| |
| ; TEST not captured by readonly external function if return chain is known |
| ; |
| ; Make sure the returned flag on %r is strong enough to justify nocapture on %b but **not** on %r. |
| ; |
| define ptr @not_captured_by_readonly_call_not_returned_either1(ptr %b, ptr returned %r) { |
| ; TUNIT: Function Attrs: nosync nounwind memory(read) |
| ; TUNIT-LABEL: define ptr @not_captured_by_readonly_call_not_returned_either1 |
| ; TUNIT-SAME: (ptr nocapture readonly [[B:%.*]], ptr readonly returned [[R:%.*]]) #[[ATTR8:[0-9]+]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call ptr @readonly_unknown(ptr readonly [[B]], ptr readonly [[R]]) #[[ATTR8]] |
| ; TUNIT-NEXT: ret ptr [[CALL]] |
| ; |
| ; CGSCC: Function Attrs: nosync nounwind memory(read) |
| ; CGSCC-LABEL: define ptr @not_captured_by_readonly_call_not_returned_either1 |
| ; CGSCC-SAME: (ptr nocapture readonly [[B:%.*]], ptr readonly returned [[R:%.*]]) #[[ATTR9:[0-9]+]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call ptr @readonly_unknown(ptr readonly [[B]], ptr readonly [[R]]) #[[ATTR9]] |
| ; CGSCC-NEXT: ret ptr [[CALL]] |
| ; |
| entry: |
| %call = call ptr @readonly_unknown(ptr %b, ptr %r) nounwind |
| ret ptr %call |
| } |
| |
| declare ptr @readonly_unknown_r1a(ptr, ptr returned) readonly |
| define ptr @not_captured_by_readonly_call_not_returned_either2(ptr %b, ptr %r) { |
| ; TUNIT: Function Attrs: nosync nounwind memory(read) |
| ; TUNIT-LABEL: define ptr @not_captured_by_readonly_call_not_returned_either2 |
| ; TUNIT-SAME: (ptr readonly [[B:%.*]], ptr readonly [[R:%.*]]) #[[ATTR8]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call ptr @readonly_unknown_r1a(ptr readonly [[B]], ptr readonly [[R]]) #[[ATTR8]] |
| ; TUNIT-NEXT: ret ptr [[CALL]] |
| ; |
| ; CGSCC: Function Attrs: nosync nounwind memory(read) |
| ; CGSCC-LABEL: define ptr @not_captured_by_readonly_call_not_returned_either2 |
| ; CGSCC-SAME: (ptr readonly [[B:%.*]], ptr readonly [[R:%.*]]) #[[ATTR9]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call ptr @readonly_unknown_r1a(ptr readonly [[B]], ptr readonly [[R]]) #[[ATTR9]] |
| ; CGSCC-NEXT: ret ptr [[CALL]] |
| ; |
| entry: |
| %call = call ptr @readonly_unknown_r1a(ptr %b, ptr %r) nounwind |
| ret ptr %call |
| } |
| |
| declare ptr @readonly_unknown_r1b(ptr, ptr returned) readonly nounwind |
| define ptr @not_captured_by_readonly_call_not_returned_either3(ptr %b, ptr %r) { |
| ; TUNIT: Function Attrs: nosync nounwind memory(read) |
| ; TUNIT-LABEL: define ptr @not_captured_by_readonly_call_not_returned_either3 |
| ; TUNIT-SAME: (ptr nocapture readonly [[B:%.*]], ptr readonly [[R:%.*]]) #[[ATTR8]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call ptr @readonly_unknown_r1b(ptr nocapture readonly [[B]], ptr readonly [[R]]) #[[ATTR8]] |
| ; TUNIT-NEXT: ret ptr [[CALL]] |
| ; |
| ; CGSCC: Function Attrs: nosync nounwind memory(read) |
| ; CGSCC-LABEL: define ptr @not_captured_by_readonly_call_not_returned_either3 |
| ; CGSCC-SAME: (ptr nocapture readonly [[B:%.*]], ptr readonly [[R:%.*]]) #[[ATTR9]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call ptr @readonly_unknown_r1b(ptr nocapture readonly [[B]], ptr readonly [[R]]) #[[ATTR9]] |
| ; CGSCC-NEXT: ret ptr [[CALL]] |
| ; |
| entry: |
| %call = call ptr @readonly_unknown_r1b(ptr %b, ptr %r) |
| ret ptr %call |
| } |
| |
| define ptr @not_captured_by_readonly_call_not_returned_either4(ptr %b, ptr %r) nounwind { |
| ; TUNIT: Function Attrs: nosync nounwind memory(read) |
| ; TUNIT-LABEL: define ptr @not_captured_by_readonly_call_not_returned_either4 |
| ; TUNIT-SAME: (ptr readonly [[B:%.*]], ptr readonly [[R:%.*]]) #[[ATTR8]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call ptr @readonly_unknown_r1a(ptr readonly [[B]], ptr readonly [[R]]) #[[ATTR13]] |
| ; TUNIT-NEXT: ret ptr [[CALL]] |
| ; |
| ; CGSCC: Function Attrs: nosync nounwind memory(read) |
| ; CGSCC-LABEL: define ptr @not_captured_by_readonly_call_not_returned_either4 |
| ; CGSCC-SAME: (ptr readonly [[B:%.*]], ptr readonly [[R:%.*]]) #[[ATTR9]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call ptr @readonly_unknown_r1a(ptr readonly [[B]], ptr readonly [[R]]) #[[ATTR15]] |
| ; CGSCC-NEXT: ret ptr [[CALL]] |
| ; |
| entry: |
| %call = call ptr @readonly_unknown_r1a(ptr %b, ptr %r) |
| ret ptr %call |
| } |
| |
| |
| declare ptr @unknown_i32p(ptr) |
| define void @nocapture_is_not_subsumed_1(ptr nocapture %b) { |
| ; CHECK-LABEL: define void @nocapture_is_not_subsumed_1 |
| ; CHECK-SAME: (ptr nocapture [[B:%.*]]) { |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[CALL:%.*]] = call ptr @unknown_i32p(ptr [[B]]) |
| ; CHECK-NEXT: store i32 0, ptr [[CALL]], align 4 |
| ; CHECK-NEXT: ret void |
| ; |
| entry: |
| %call = call ptr @unknown_i32p(ptr %b) |
| store i32 0, ptr %call |
| ret void |
| } |
| |
| declare ptr @readonly_i32p(ptr) readonly |
| define void @nocapture_is_not_subsumed_2(ptr nocapture %b) { |
| ; TUNIT: Function Attrs: nosync |
| ; TUNIT-LABEL: define void @nocapture_is_not_subsumed_2 |
| ; TUNIT-SAME: (ptr nocapture [[B:%.*]]) #[[ATTR10:[0-9]+]] { |
| ; TUNIT-NEXT: entry: |
| ; TUNIT-NEXT: [[CALL:%.*]] = call ptr @readonly_i32p(ptr readonly [[B]]) #[[ATTR13]] |
| ; TUNIT-NEXT: store i32 0, ptr [[CALL]], align 4 |
| ; TUNIT-NEXT: ret void |
| ; |
| ; CGSCC: Function Attrs: nosync |
| ; CGSCC-LABEL: define void @nocapture_is_not_subsumed_2 |
| ; CGSCC-SAME: (ptr nocapture [[B:%.*]]) #[[ATTR11:[0-9]+]] { |
| ; CGSCC-NEXT: entry: |
| ; CGSCC-NEXT: [[CALL:%.*]] = call ptr @readonly_i32p(ptr readonly [[B]]) #[[ATTR15]] |
| ; CGSCC-NEXT: store i32 0, ptr [[CALL]], align 4 |
| ; CGSCC-NEXT: ret void |
| ; |
| entry: |
| %call = call ptr @readonly_i32p(ptr %b) |
| store i32 0, ptr %call |
| ret void |
| } |
| |
| ; Make sure %p is not not marked nocapture (Bug #64613). |
| ; Version a failed with the lightweight attributor, b with the full one. |
| define ptr @b64613_a(ptr noundef %p) { |
| ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) |
| ; TUNIT-LABEL: define noundef ptr @b64613_a |
| ; TUNIT-SAME: (ptr nofree noundef readnone returned "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR11:[0-9]+]] { |
| ; TUNIT-NEXT: [[P_ADDR:%.*]] = alloca ptr, align 1 |
| ; TUNIT-NEXT: store ptr [[P]], ptr [[P_ADDR]], align 1 |
| ; TUNIT-NEXT: ret ptr [[P]] |
| ; |
| ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) |
| ; CGSCC-LABEL: define noundef ptr @b64613_a |
| ; CGSCC-SAME: (ptr nofree noundef readnone returned "no-capture-maybe-returned" [[P:%.*]]) #[[ATTR12:[0-9]+]] { |
| ; CGSCC-NEXT: [[P_ADDR:%.*]] = alloca ptr, align 1 |
| ; CGSCC-NEXT: store ptr [[P]], ptr [[P_ADDR]], align 1 |
| ; CGSCC-NEXT: ret ptr [[P]] |
| ; |
| %p.addr = alloca ptr, align 1 |
| store ptr %p, ptr %p.addr, align 1 |
| %r = load ptr, ptr %p.addr, align 1 |
| ret ptr %r |
| } |
| define ptr @b64613_b(ptr noundef %p, i32 %i) { |
| ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) |
| ; TUNIT-LABEL: define ptr @b64613_b |
| ; TUNIT-SAME: (ptr nofree noundef [[P:%.*]], i32 [[I:%.*]]) #[[ATTR11]] { |
| ; TUNIT-NEXT: [[P_ADDR:%.*]] = alloca <2 x ptr>, align 1 |
| ; TUNIT-NEXT: [[G:%.*]] = getelementptr i8, ptr [[P_ADDR]], i32 [[I]] |
| ; TUNIT-NEXT: store ptr [[P]], ptr [[G]], align 1 |
| ; TUNIT-NEXT: [[R:%.*]] = load ptr, ptr [[P_ADDR]], align 1 |
| ; TUNIT-NEXT: ret ptr [[R]] |
| ; |
| ; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) |
| ; CGSCC-LABEL: define ptr @b64613_b |
| ; CGSCC-SAME: (ptr nofree noundef [[P:%.*]], i32 [[I:%.*]]) #[[ATTR12]] { |
| ; CGSCC-NEXT: [[P_ADDR:%.*]] = alloca <2 x ptr>, align 1 |
| ; CGSCC-NEXT: [[G:%.*]] = getelementptr i8, ptr [[P_ADDR]], i32 [[I]] |
| ; CGSCC-NEXT: store ptr [[P]], ptr [[G]], align 1 |
| ; CGSCC-NEXT: [[R:%.*]] = load ptr, ptr [[P_ADDR]], align 1 |
| ; CGSCC-NEXT: ret ptr [[R]] |
| ; |
| %p.addr = alloca <2 x ptr>, align 1 |
| %g = getelementptr i8, ptr %p.addr, i32 %i |
| store ptr %p, ptr %g, align 1 |
| %r = load ptr, ptr %p.addr, align 1 |
| ret ptr %r |
| } |
| define void @b64613_positive(ptr noundef %p, i32 %i) { |
| ; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none) |
| ; TUNIT-LABEL: define void @b64613_positive |
| ; TUNIT-SAME: (ptr nocapture nofree noundef [[P:%.*]], i32 [[I:%.*]]) #[[ATTR11]] { |
| ; TUNIT-NEXT: [[P_ADDR:%.*]] = alloca <2 x ptr>, align 1 |
| ; TUNIT-NEXT: [[G:%.*]] = getelementptr i8, ptr [[P_ADDR]], i32 [[I]] |
| ; TUNIT-NEXT: store ptr [[P]], ptr [[G]], align 1 |
| ; TUNIT-NEXT: ret void |
| ; |
| ; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none) |
| ; CGSCC-LABEL: define void @b64613_positive |
| ; CGSCC-SAME: (ptr nocapture nofree noundef [[P:%.*]], i32 [[I:%.*]]) #[[ATTR13:[0-9]+]] { |
| ; CGSCC-NEXT: [[P_ADDR:%.*]] = alloca <2 x ptr>, align 1 |
| ; CGSCC-NEXT: [[G:%.*]] = getelementptr i8, ptr [[P_ADDR]], i32 [[I]] |
| ; CGSCC-NEXT: store ptr [[P]], ptr [[G]], align 1 |
| ; CGSCC-NEXT: ret void |
| ; |
| %p.addr = alloca <2 x ptr>, align 1 |
| %g = getelementptr i8, ptr %p.addr, i32 %i |
| store ptr %p, ptr %g, align 1 |
| %r = load ptr, ptr %p.addr, align 1 |
| %q = call ptr @b64613_b(ptr %r, i32 %i) |
| ret void |
| } |
| |
| attributes #0 = { noinline nounwind uwtable } |
| ;. |
| ; TUNIT: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } |
| ; TUNIT: attributes #[[ATTR1]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable } |
| ; TUNIT: attributes #[[ATTR2]] = { nofree nosync nounwind memory(none) } |
| ; TUNIT: attributes #[[ATTR3]] = { noinline nounwind uwtable } |
| ; TUNIT: attributes #[[ATTR4]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable } |
| ; TUNIT: attributes #[[ATTR5]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(write) uwtable } |
| ; TUNIT: attributes #[[ATTR6:[0-9]+]] = { memory(read) } |
| ; TUNIT: attributes #[[ATTR7]] = { noinline nosync nounwind memory(read) uwtable } |
| ; TUNIT: attributes #[[ATTR8]] = { nosync nounwind memory(read) } |
| ; TUNIT: attributes #[[ATTR9:[0-9]+]] = { nounwind memory(read) } |
| ; TUNIT: attributes #[[ATTR10]] = { nosync } |
| ; TUNIT: attributes #[[ATTR11]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) } |
| ; TUNIT: attributes #[[ATTR12]] = { nofree nosync nounwind willreturn memory(write) } |
| ; TUNIT: attributes #[[ATTR13]] = { nosync memory(read) } |
| ;. |
| ; CGSCC: attributes #[[ATTR0]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable } |
| ; CGSCC: attributes #[[ATTR1]] = { mustprogress nofree noinline nosync nounwind willreturn memory(none) uwtable } |
| ; CGSCC: attributes #[[ATTR2]] = { nofree nosync nounwind memory(none) } |
| ; CGSCC: attributes #[[ATTR3]] = { noinline nounwind uwtable } |
| ; CGSCC: attributes #[[ATTR4]] = { mustprogress nofree noinline norecurse nosync nounwind willreturn memory(argmem: write) uwtable } |
| ; CGSCC: attributes #[[ATTR5]] = { mustprogress nofree noinline nosync nounwind willreturn memory(argmem: write) uwtable } |
| ; CGSCC: attributes #[[ATTR6]] = { mustprogress nofree noinline nosync nounwind willreturn memory(write) uwtable } |
| ; CGSCC: attributes #[[ATTR7:[0-9]+]] = { memory(read) } |
| ; CGSCC: attributes #[[ATTR8]] = { noinline nosync nounwind memory(read) uwtable } |
| ; CGSCC: attributes #[[ATTR9]] = { nosync nounwind memory(read) } |
| ; CGSCC: attributes #[[ATTR10:[0-9]+]] = { nounwind memory(read) } |
| ; CGSCC: attributes #[[ATTR11]] = { nosync } |
| ; CGSCC: attributes #[[ATTR12]] = { mustprogress nofree norecurse nosync nounwind willreturn memory(none) } |
| ; CGSCC: attributes #[[ATTR13]] = { mustprogress nofree nosync nounwind willreturn memory(none) } |
| ; CGSCC: attributes #[[ATTR14]] = { nofree nounwind willreturn memory(write) } |
| ; CGSCC: attributes #[[ATTR15]] = { nosync memory(read) } |
| ;. |
