Page MenuHomePhabricator
Differential D63604 Diff 208609 llvm/test/Transforms/FunctionAttrs/nonnull.ll

Changeset View

Standalone View

View Options

llvm/test/Transforms/FunctionAttrs/nonnull.ll

1; RUN: opt -S -functionattrs -enable-nonnull-arg-prop %s | FileCheck %s 1​; RUN: opt -S -functionattrs -enable-nonnull-arg-prop %s | FileCheck %s
2; RUN: opt -S -passes=function-attrs -enable-nonnull-arg-prop %s | FileCheck %s 2​; RUN: opt -S -passes=function-attrs -enable-nonnull-arg-prop %s | FileCheck %s
3​; RUN: opt -attributor --attributor-disable=false -S < %s | FileCheck %s --check-prefix=ATTRIBUTOR
3 4​
jdoerfertUnsubmitted
Done
Reply

We need a target layout here. The test is now dependent on the sizes of pointer (I think) and without target layout it might take the host values which would be bad for 32bit machines.

jdoerfert: We need a target layout here. The test is now dependent on the sizes of pointer (I think) and…
4declare nonnull i8* @ret_nonnull() 5​declare nonnull i8* @ret_nonnull()
5 6​
6; Return a pointer trivially nonnull (call return attribute) 7​; Return a pointer trivially nonnull (call return attribute)
7define i8* @test1() { 8​define i8* @test1() {
8; CHECK: define nonnull i8* @test1 9​; CHECK: define nonnull i8* @test1
10​; ATTRIBUTOR: define nonnull i8* @test1
9 %ret = call i8* @ret_nonnull() 11​ %ret = call i8* @ret_nonnull()
10 ret i8* %ret 12​ ret i8* %ret
11} 13​}
12 14​
13; Return a pointer trivially nonnull (argument attribute) 15​; Return a pointer trivially nonnull (argument attribute)
14define i8* @test2(i8* nonnull %p) { 16​define i8* @test2(i8* nonnull %p) {
15; CHECK: define nonnull i8* @test2 17​; CHECK: define nonnull i8* @test2
18​; ATTRIBUTOR: define nonnull i8* @test2
16 ret i8* %p 19​ ret i8* %p
17} 20​}
18 21​
19; Given an SCC where one of the functions can not be marked nonnull, 22​; Given an SCC where one of the functions can not be marked nonnull,
20; can we still mark the other one which is trivially nonnull 23​; can we still mark the other one which is trivially nonnull
21define i8* @scc_binder() { 24​define i8* @scc_binder() {
22; CHECK: define i8* @scc_binder 25​; CHECK: define i8* @scc_binder
26​; ATTRIBUTOR: define i8* @scc_binder
23 call i8* @test3() 27​ call i8* @test3()
24 ret i8* null 28​ ret i8* null
25} 29​}
26 30​
27define i8* @test3() { 31​define i8* @test3() {
28; CHECK: define nonnull i8* @test3 32​; CHECK: define nonnull i8* @test3
33​; ATTRIBUTOR: define nonnull i8* @test3
29 call i8* @scc_binder() 34​ call i8* @scc_binder()
30 %ret = call i8* @ret_nonnull() 35​ %ret = call i8* @ret_nonnull()
31 ret i8* %ret 36​ ret i8* %ret
32} 37​}
33 38​
34; Given a mutual recursive set of functions, we can mark them 39​; Given a mutual recursive set of functions, we can mark them
35; nonnull if neither can ever return null. (In this case, they 40​; nonnull if neither can ever return null. (In this case, they
36; just never return period.) 41​; just never return period.)
37define i8* @test4_helper() { 42​define i8* @test4_helper() {
38; CHECK: define noalias nonnull i8* @test4_helper 43​; CHECK: define noalias nonnull i8* @test4_helper
44​; ATTRIBUTOR: define nonnull i8* @test4_helper
39 %ret = call i8* @test4() 45​ %ret = call i8* @test4()
40 ret i8* %ret 46​ ret i8* %ret
41} 47​}
42 48​
43define i8* @test4() { 49​define i8* @test4() {
44; CHECK: define noalias nonnull i8* @test4 50​; CHECK: define noalias nonnull i8* @test4
51​; ATTRIBUTOR: define nonnull i8* @test4
45 %ret = call i8* @test4_helper() 52​ %ret = call i8* @test4_helper()
46 ret i8* %ret 53​ ret i8* %ret
47} 54​}
48 55​
49; Given a mutual recursive set of functions which *can* return null 56​; Given a mutual recursive set of functions which *can* return null
50; make sure we haven't marked them as nonnull. 57​; make sure we haven't marked them as nonnull.
51define i8* @test5_helper() { 58​define i8* @test5_helper() {
52; CHECK: define noalias i8* @test5_helper 59​; CHECK: define noalias i8* @test5_helper
60​; ATTRIBUTOR: define i8* @test5_helper
53 %ret = call i8* @test5() 61​ %ret = call i8* @test5()
54 ret i8* null 62​ ret i8* null
55} 63​}
56 64​
57define i8* @test5() { 65​define i8* @test5() {
58; CHECK: define noalias i8* @test5 66​; CHECK: define noalias i8* @test5
67​; ATTRIBUTOR: define i8* @test5
59 %ret = call i8* @test5_helper() 68​ %ret = call i8* @test5_helper()
60 ret i8* %ret 69​ ret i8* %ret
61} 70​}
62 71​
63; Local analysis, but going through a self recursive phi 72​; Local analysis, but going through a self recursive phi
64define i8* @test6() { 73​define i8* @test6() {
65entry: 74​entry:
66; CHECK: define nonnull i8* @test6 75​; CHECK: define nonnull i8* @test6
76​; ATTRIBUTOR: define nonnull i8* @test6
67 %ret = call i8* @ret_nonnull() 77​ %ret = call i8* @ret_nonnull()
68 br label %loop 78​ br label %loop
69loop: 79​loop:
70 %phi = phi i8* [%ret, %entry], [%phi, %loop] 80​ %phi = phi i8* [%ret, %entry], [%phi, %loop]
71 br i1 undef, label %loop, label %exit 81​ br i1 undef, label %loop, label %exit
72exit: 82​exit:
73 ret i8* %phi 83​ ret i8* %phi
74} 84​}
75 85​
86​; CHECK: define i8* @test7
87​; ATTRIBUTOR: define i8* @test7
88​define i8* @test7(i8* %a) {
89​ %b = getelementptr inbounds i8, i8* %a, i64 0
90​ ret i8* %b
91​}
92​
93​; CHECK: define nonnull i8* @test8
94​; ATTRIBUTOR: define nonnull i8* @test8
95​define i8* @test8(i8* %a) {
96​ %b = getelementptr inbounds i8, i8* %a, i64 1
97​ ret i8* %b
98​}
99​
100​; CHECK: define i8* @test9
101​; ATTRIBUTOR: define i8* @test9
102​define i8* @test9(i8* %a, i64 %n) {
103​ %b = getelementptr inbounds i8, i8* %a, i64 %n
104​ ret i8* %b
105​}
106​
107​declare void @llvm.assume(i1)
jdoerfertUnsubmitted
Done
Reply

One more with inbounds (below, untested!) and maybe some without inbounds while we are at it.

; CHECK: define i8* @test10
; FIXME: missing nonnull
; ATTRIBUTOR: define i8* @test10
define i8* @test10(i8* %a, i64 %n) {
  %cmp = icmp ne i64 %n, null 
  call void @llvm.assume(i1 %cmp)
  %b = getelementptr inbounds i8, i8* %a, i64 %n
  ret i8* %b
}
jdoerfert: One more with inbounds (below, untested!) and maybe some without inbounds while we are at it.
108​; CHECK: define i8* @test10
109​; FIXME: missing nonnull
110​; ATTRIBUTOR: define i8* @test10
111​define i8* @test10(i8* %a, i64 %n) {
112​ %cmp = icmp ne i64 %n, 0
113​ call void @llvm.assume(i1 %cmp)
114​ %b = getelementptr inbounds i8, i8* %a, i64 %n
115​ ret i8* %b
116​}
117​
118​; TEST 11
119​; char* test11(char *p) {
120​; return p? p: nonnull();
121​; }
122​; CHECK: define i8* @test11
123​; FIXME: missing nonnull
124​; ATTRIBUTOR: define i8* @test11
125​define i8* @test11(i8*) local_unnamed_addr {
126​ %2 = icmp eq i8* %0, null
127​ br i1 %2, label %3, label %5
128​
129​; <label>:3: ; preds = %1
130​ %4 = tail call i8* @nonnull(i64 1)
131​ br label %5
132​
133​; <label>:5: ; preds = %3, %1
134​ %6 = phi i8* [ %4, %3 ], [ %0, %1 ]
135​ ret i8* %6
136​}
137​
138​declare nonnull i8* @nonnull(i64)
139​
140​
76; Test propagation of nonnull callsite args back to caller. 141​; Test propagation of nonnull callsite args back to caller.
77 142​
78declare void @use1(i8* %x) 143​declare void @use1(i8* %x)
79declare void @use2(i8* %x, i8* %y); 144​declare void @use2(i8* %x, i8* %y);
80declare void @use3(i8* %x, i8* %y, i8* %z); 145​declare void @use3(i8* %x, i8* %y, i8* %z);
81 146​
82declare void @use1nonnull(i8* nonnull %x); 147​declare void @use1nonnull(i8* nonnull %x);
83declare void @use2nonnull(i8* nonnull %x, i8* nonnull %y); 148​declare void @use2nonnull(i8* nonnull %x, i8* nonnull %y);
84declare void @use3nonnull(i8* nonnull %x, i8* nonnull %y, i8* nonnull %z); 149​declare void @use3nonnull(i8* nonnull %x, i8* nonnull %y, i8* nonnull %z);
85 150​
86declare i8 @use1safecall(i8* %x) readonly nounwind ; readonly+nounwind guarantees that execution continues to successor 151​declare i8 @use1safecall(i8* %x) readonly nounwind ; readonly+nounwind guarantees that execution continues to successor
87 152​
jdoerfertUnsubmitted
Not Done
Reply

We derive nonnull here because test13 is dead, correct? Maybe that is not what you wanted to test ;)

jdoerfert: We derive `nonnull` here because `test13` is dead, correct? Maybe that is not what you wanted…
88; Can't extend non-null to parent for any argument because the 2nd call is not guaranteed to execute. 153​; Can't extend non-null to parent for any argument because the 2nd call is not guaranteed to execute.
89 154​
90define void @parent1(i8* %a, i8* %b, i8* %c) { 155​define void @parent1(i8* %a, i8* %b, i8* %c) {
91; CHECK-LABEL: @parent1(i8* %a, i8* %b, i8* %c) 156​; CHECK-LABEL: @parent1(i8* %a, i8* %b, i8* %c)
92; CHECK-NEXT: call void @use3(i8* %c, i8* %a, i8* %b) 157​; CHECK-NEXT: call void @use3(i8* %c, i8* %a, i8* %b)
93; CHECK-NEXT: call void @use3nonnull(i8* %b, i8* %c, i8* %a) 158​; CHECK-NEXT: call void @use3nonnull(i8* %b, i8* %c, i8* %a)
94; CHECK-NEXT: ret void 159​; CHECK-NEXT: ret void
95; 160​;
96 call void @use3(i8* %c, i8* %a, i8* %b) 161​ call void @use3(i8* %c, i8* %a, i8* %b)
97 call void @use3nonnull(i8* %b, i8* %c, i8* %a) 162​ call void @use3nonnull(i8* %b, i8* %c, i8* %a)
98 ret void 163​ ret void
99} 164​}
100 165​
101; Extend non-null to parent for all arguments. 166​; Extend non-null to parent for all arguments.
102 167​
103define void @parent2(i8* %a, i8* %b, i8* %c) { 168​define void @parent2(i8* %a, i8* %b, i8* %c) {
104; CHECK-LABEL: @parent2(i8* nonnull %a, i8* nonnull %b, i8* nonnull %c) 169​; CHECK-LABEL: @parent2(i8* nonnull %a, i8* nonnull %b, i8* nonnull %c)
105; CHECK-NEXT: call void @use3nonnull(i8* %b, i8* %c, i8* %a) 170​; CHECK-NEXT: call void @use3nonnull(i8* %b, i8* %c, i8* %a)
106; CHECK-NEXT: call void @use3(i8* %c, i8* %a, i8* %b) 171​; CHECK-NEXT: call void @use3(i8* %c, i8* %a, i8* %b)
107; CHECK-NEXT: ret void 172​; CHECK-NEXT: ret void
108; 173​;
109 call void @use3nonnull(i8* %b, i8* %c, i8* %a) 174​ call void @use3nonnull(i8* %b, i8* %c, i8* %a)
110 call void @use3(i8* %c, i8* %a, i8* %b) 175​ call void @use3(i8* %c, i8* %a, i8* %b)
jdoerfertUnsubmitted
Not Done
Reply

Will be fixed with D64708.

jdoerfert: Will be fixed with D64708.
111 ret void 176​ ret void
112} 177​}
113 178​
114; Extend non-null to parent for 1st argument. 179​; Extend non-null to parent for 1st argument.
115 180​
116define void @parent3(i8* %a, i8* %b, i8* %c) { 181​define void @parent3(i8* %a, i8* %b, i8* %c) {
117; CHECK-LABEL: @parent3(i8* nonnull %a, i8* %b, i8* %c) 182​; CHECK-LABEL: @parent3(i8* nonnull %a, i8* %b, i8* %c)
118; CHECK-NEXT: call void @use1nonnull(i8* %a) 183​; CHECK-NEXT: call void @use1nonnull(i8* %a)
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Line(s)
210 275​
211cont: 276​cont:
212 %null_check = icmp eq i8* %b, null 277​ %null_check = icmp eq i8* %b, null
213 ret i1 %null_check 278​ ret i1 %null_check
214 279​
215exc: 280​exc:
216 %lp = landingpad { i8*, i32 } 281​ %lp = landingpad { i8*, i32 }
217 filter [0 x i8*] zeroinitializer 282​ filter [0 x i8*] zeroinitializer
218 unreachable 283​ unreachable
jdoerfertUnsubmitted
Done
Reply

These are a lot of copies. Could we somehow make the "default" check and only specialize/copy when the two (-funcattr and -attributor) generate different code? Or is this already what you did and I just missed it? Also, could you add FIXMEs where we fail to deduce something with the attributor?

jdoerfert: These are a lot of copies. Could we somehow make the "default" check and only specialize/copy…
219} 284​}
220 285​
221; CHECK: define nonnull i32* @gep1( 286​; CHECK: define nonnull i32* @gep1(
222define i32* @gep1(i32* %p) { 287​define i32* @gep1(i32* %p) {
223 %q = getelementptr inbounds i32, i32* %p, i32 1 288​ %q = getelementptr inbounds i32, i32* %p, i32 1
224 ret i32* %q 289​ ret i32* %q
225} 290​}
226 291​
Show All 14 Lines