Page MenuHomePhabricator
Differential D63604 Diff 209724 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 --check-prefixes=BOTH,FNATTR
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 --check-prefixes=BOTH,FNATTR
3​; RUN: opt -attributor --attributor-disable=false -S < %s | FileCheck %s --check-prefixes=BOTH,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​; BOTH: define nonnull i8* @test1
9 %ret = call i8* @ret_nonnull() 10​ %ret = call i8* @ret_nonnull()
10 ret i8* %ret 11​ ret i8* %ret
11} 12​}
12 13​
13; Return a pointer trivially nonnull (argument attribute) 14​; Return a pointer trivially nonnull (argument attribute)
14define i8* @test2(i8* nonnull %p) { 15​define i8* @test2(i8* nonnull %p) {
15; CHECK: define nonnull i8* @test2 16​; BOTH: define nonnull i8* @test2
16 ret i8* %p 17​ ret i8* %p
17} 18​}
18 19​
19; Given an SCC where one of the functions can not be marked nonnull, 20​; 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 21​; can we still mark the other one which is trivially nonnull
21define i8* @scc_binder() { 22​define i8* @scc_binder() {
22; CHECK: define i8* @scc_binder 23​; BOTH: define i8* @scc_binder
23 call i8* @test3() 24​ call i8* @test3()
24 ret i8* null 25​ ret i8* null
25} 26​}
26 27​
27define i8* @test3() { 28​define i8* @test3() {
28; CHECK: define nonnull i8* @test3 29​; BOTH: define nonnull i8* @test3
29 call i8* @scc_binder() 30​ call i8* @scc_binder()
30 %ret = call i8* @ret_nonnull() 31​ %ret = call i8* @ret_nonnull()
31 ret i8* %ret 32​ ret i8* %ret
32} 33​}
33 34​
34; Given a mutual recursive set of functions, we can mark them 35​; Given a mutual recursive set of functions, we can mark them
35; nonnull if neither can ever return null. (In this case, they 36​; nonnull if neither can ever return null. (In this case, they
36; just never return period.) 37​; just never return period.)
37define i8* @test4_helper() { 38​define i8* @test4_helper() {
38; CHECK: define noalias nonnull i8* @test4_helper 39​; FNATTR: define noalias nonnull i8* @test4_helper
40​; ATTRIBUTOR: define nonnull i8* @test4_helper
39 %ret = call i8* @test4() 41​ %ret = call i8* @test4()
40 ret i8* %ret 42​ ret i8* %ret
41} 43​}
42 44​
43define i8* @test4() { 45​define i8* @test4() {
44; CHECK: define noalias nonnull i8* @test4 46​; FNATTR: define noalias nonnull i8* @test4
47​; ATTRIBUTOR: define nonnull i8* @test4
45 %ret = call i8* @test4_helper() 48​ %ret = call i8* @test4_helper()
46 ret i8* %ret 49​ ret i8* %ret
47} 50​}
48 51​
49; Given a mutual recursive set of functions which *can* return null 52​; Given a mutual recursive set of functions which *can* return null
50; make sure we haven't marked them as nonnull. 53​; make sure we haven't marked them as nonnull.
51define i8* @test5_helper() { 54​define i8* @test5_helper() {
52; CHECK: define noalias i8* @test5_helper 55​; FNATTR: define noalias i8* @test5_helper
56​; ATTRIBUTOR: define i8* @test5_helper
53 %ret = call i8* @test5() 57​ %ret = call i8* @test5()
54 ret i8* null 58​ ret i8* null
55} 59​}
56 60​
57define i8* @test5() { 61​define i8* @test5() {
58; CHECK: define noalias i8* @test5 62​; FNATTR: define noalias i8* @test5
63​; ATTRIBUTOR: define i8* @test5
59 %ret = call i8* @test5_helper() 64​ %ret = call i8* @test5_helper()
60 ret i8* %ret 65​ ret i8* %ret
61} 66​}
62 67​
63; Local analysis, but going through a self recursive phi 68​; Local analysis, but going through a self recursive phi
64define i8* @test6() { 69​define i8* @test6() {
65entry: 70​entry:
66; CHECK: define nonnull i8* @test6 71​; BOTH: define nonnull i8* @test6
67 %ret = call i8* @ret_nonnull() 72​ %ret = call i8* @ret_nonnull()
68 br label %loop 73​ br label %loop
69loop: 74​loop:
70 %phi = phi i8* [%ret, %entry], [%phi, %loop] 75​ %phi = phi i8* [%ret, %entry], [%phi, %loop]
71 br i1 undef, label %loop, label %exit 76​ br i1 undef, label %loop, label %exit
72exit: 77​exit:
73 ret i8* %phi 78​ ret i8* %phi
74} 79​}
75 80​
81​; BOTH: define i8* @test7
82​define i8* @test7(i8* %a) {
83​ %b = getelementptr inbounds i8, i8* %a, i64 0
84​ ret i8* %b
85​}
86​
87​; BOTH: define nonnull i8* @test8
88​define i8* @test8(i8* %a) {
89​ %b = getelementptr inbounds i8, i8* %a, i64 1
90​ ret i8* %b
91​}
92​
93​; BOTH: define i8* @test9
94​define i8* @test9(i8* %a, i64 %n) {
95​ %b = getelementptr inbounds i8, i8* %a, i64 %n
96​ ret i8* %b
97​}
98​
99​declare void @llvm.assume(i1)
100​; FNATTR: define i8* @test10
101​; FIXME: missing nonnull
102​; ATTRIBUTOR: define i8* @test10
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.
103​define i8* @test10(i8* %a, i64 %n) {
104​ %cmp = icmp ne i64 %n, 0
105​ call void @llvm.assume(i1 %cmp)
106​ %b = getelementptr inbounds i8, i8* %a, i64 %n
107​ ret i8* %b
108​}
109​
110​; TEST 11
111​; char* test11(char *p) {
112​; return p? p: nonnull();
113​; }
114​; FNATTR: define i8* @test11
115​; FIXME: missing nonnull
116​; ATTRIBUTOR: define i8* @test11
117​define i8* @test11(i8*) local_unnamed_addr {
118​ %2 = icmp eq i8* %0, null
119​ br i1 %2, label %3, label %5
120​
121​; <label>:3: ; preds = %1
122​ %4 = tail call i8* @ret_nonnull()
123​ br label %5
124​
125​; <label>:5: ; preds = %3, %1
126​ %6 = phi i8* [ %4, %3 ], [ %0, %1 ]
127​ ret i8* %6
128​}
129​
130​; TEST 12
131​; Simple CallSite Test
132​declare void @test12_helper(i8*)
133​define void @test12(i8* nonnull %a) {
134​; ATTRIBUTOR: define void @test12(i8* nonnull %a)
135​; ATTRIBUTOR-NEXT: tail call void @test12_helper(i8* nonnull %a)
136​ tail call void @test12_helper(i8* %a)
137​ ret void
138​}
139​
140​; TEST 13
141​; Simple Argument Tests
142​declare i8* @unknown()
143​define void @test13_helper() {
144​ %nonnullptr = tail call i8* @ret_nonnull()
145​ %maybenullptr = tail call i8* @unknown()
146​ tail call void @test13(i8* %nonnullptr, i8* %nonnullptr, i8* %maybenullptr)
147​ tail call void @test13(i8* %nonnullptr, i8* %maybenullptr, i8* %nonnullptr)
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…
148​ ret void
149​}
150​define internal void @test13(i8* %a, i8* %b, i8* %c) {
151​; ATTRIBUTOR: define internal void @test13(i8* nonnull %a, i8* %b, i8* %c)
152​ ret void
153​}
154​
155​declare nonnull i8* @nonnull()
156​
157​; TEST 14
158​; Complex propagation
159​; Argument and return value of f1, f2, f3 can be marked with nonnull.
160​
161​; * Argument
162​; 1. In f1:bb6, %arg can be marked with nonnull because of the comparison in bb1
163​; 2. Because f2 is internal function, f2(i32* %arg) -> @f2(i32* nonnull %arg)
164​; 3. In f1:bb4 %tmp5 is nonnull and f3 is internal function.
165​; Then, f3(i32* %arg) -> @f3(i32* nonnull %arg)
166​; 4. We get nonnull in whole f1 call sites so f1(i32* %arg) -> @f1(i32* nonnull %arg)
167​
168​; * Return value
169​; Return value is trivial but currently missing nonnull because
170​; isKnownNonZero(inttoptr(4)) returns false now.
jdoerfertUnsubmitted
Not Done
Reply

Will be fixed with D64708.

jdoerfert: Will be fixed with D64708.
171​
172​
173​define internal i32* @f1(i32* %arg) {
174​; FIXME: missing nonnull It should be nonnull @f1(i32* nonnull %arg)
175​; ATTRIBUTOR: define internal i32* @f1(i32* %arg)
176​
177​bb:
178​ %tmp = icmp eq i32* %arg, null
179​ br i1 %tmp, label %bb9, label %bb1
180​
181​bb1: ; preds = %bb
182​ %tmp2 = load i32, i32* %arg, align 4
183​ %tmp3 = icmp eq i32 %tmp2, 0
184​ br i1 %tmp3, label %bb6, label %bb4
185​
186​bb4: ; preds = %bb1
187​ %tmp5 = getelementptr inbounds i32, i32* %arg, i64 1
188​; ATTRIBUTOR: %tmp5b = tail call i32* @f3(i32* nonnull %tmp5)
189​ %tmp5b = tail call i32* @f3(i32* %tmp5)
190​ br label %bb9
191​
192​bb6: ; preds = %bb1
193​; FIXME: missing nonnull. It should be @f2(i32* nonnull %arg)
194​; ATTRIBUTOR: %tmp7 = tail call i32* @f2(i32* %arg)
195​ %tmp7 = tail call i32* @f2(i32* %arg)
196​ ret i32* %tmp7
197​
198​bb9: ; preds = %bb4, %bb
199​ %tmp10 = phi i32* [ %tmp5, %bb4 ], [ inttoptr (i64 4 to i32*), %bb ]
200​ ret i32* %tmp10
201​}
202​
203​define internal i32* @f2(i32* %arg) {
204​; FIXME: missing nonnull. It should be nonnull @f2(i32* nonnull %arg)
205​; ATTRIBUTOR: define internal i32* @f2(i32* %arg)
206​bb:
207​
208​; FIXME: missing nonnull. It should be @f1(i32* nonnull %arg)
209​; ATTRIBUTOR: %tmp = tail call i32* @f1(i32* %arg)
210​ %tmp = tail call i32* @f1(i32* %arg)
211​ ret i32* %tmp
212​}
213​
214​define dso_local noalias i32* @f3(i32* %arg) {
215​; FIXME: missing nonnull. It should be nonnull @f3(i32* nonnull %arg)
216​; ATTRIBUTOR: define dso_local noalias i32* @f3(i32* %arg)
217​bb:
218​; FIXME: missing nonnull. It should be @f1(i32* nonnull %arg)
219​; ATTRIBUTOR: %tmp = call i32* @f1(i32* %arg)
220​ %tmp = call i32* @f1(i32* %arg)
221​ ret i32* null
222​}
76; Test propagation of nonnull callsite args back to caller. 223​; Test propagation of nonnull callsite args back to caller.
77 224​
78declare void @use1(i8* %x) 225​declare void @use1(i8* %x)
79declare void @use2(i8* %x, i8* %y); 226​declare void @use2(i8* %x, i8* %y);
80declare void @use3(i8* %x, i8* %y, i8* %z); 227​declare void @use3(i8* %x, i8* %y, i8* %z);
81 228​
82declare void @use1nonnull(i8* nonnull %x); 229​declare void @use1nonnull(i8* nonnull %x);
83declare void @use2nonnull(i8* nonnull %x, i8* nonnull %y); 230​declare void @use2nonnull(i8* nonnull %x, i8* nonnull %y);
84declare void @use3nonnull(i8* nonnull %x, i8* nonnull %y, i8* nonnull %z); 231​declare void @use3nonnull(i8* nonnull %x, i8* nonnull %y, i8* nonnull %z);
85 232​
86declare i8 @use1safecall(i8* %x) readonly nounwind ; readonly+nounwind guarantees that execution continues to successor 233​declare i8 @use1safecall(i8* %x) readonly nounwind ; readonly+nounwind guarantees that execution continues to successor
87 234​
88; Can't extend non-null to parent for any argument because the 2nd call is not guaranteed to execute. 235​; Can't extend non-null to parent for any argument because the 2nd call is not guaranteed to execute.
89 236​
90define void @parent1(i8* %a, i8* %b, i8* %c) { 237​define void @parent1(i8* %a, i8* %b, i8* %c) {
91; CHECK-LABEL: @parent1(i8* %a, i8* %b, i8* %c) 238​; BOTH-LABEL: @parent1(i8* %a, i8* %b, i8* %c)
92; CHECK-NEXT: call void @use3(i8* %c, i8* %a, i8* %b) 239​; BOTH-NEXT: call void @use3(i8* %c, i8* %a, i8* %b)
93; CHECK-NEXT: call void @use3nonnull(i8* %b, i8* %c, i8* %a) 240​; FNATTR-NEXT: call void @use3nonnull(i8* %b, i8* %c, i8* %a)
94; CHECK-NEXT: ret void 241​; ATTRIBUTOR-NEXT: call void @use3nonnull(i8* nonnull %b, i8* nonnull %c, i8* nonnull %a)
95; 242​; BOTH-NEXT: ret void
96 call void @use3(i8* %c, i8* %a, i8* %b) 243​ call void @use3(i8* %c, i8* %a, i8* %b)
97 call void @use3nonnull(i8* %b, i8* %c, i8* %a) 244​ call void @use3nonnull(i8* %b, i8* %c, i8* %a)
98 ret void 245​ ret void
99} 246​}
100 247​
101; Extend non-null to parent for all arguments. 248​; Extend non-null to parent for all arguments.
102 249​
103define void @parent2(i8* %a, i8* %b, i8* %c) { 250​define void @parent2(i8* %a, i8* %b, i8* %c) {
104; CHECK-LABEL: @parent2(i8* nonnull %a, i8* nonnull %b, i8* nonnull %c) 251​; FNATTR-LABEL: @parent2(i8* nonnull %a, i8* nonnull %b, i8* nonnull %c)
105; CHECK-NEXT: call void @use3nonnull(i8* %b, i8* %c, i8* %a) 252​; FNATTR-NEXT: call void @use3nonnull(i8* %b, i8* %c, i8* %a)
106; CHECK-NEXT: call void @use3(i8* %c, i8* %a, i8* %b) 253​; FNATTR-NEXT: call void @use3(i8* %c, i8* %a, i8* %b)
107; CHECK-NEXT: ret void 254​
108; 255​; FIXME: missing "nonnull", it should be
256​; @parent2(i8* nonnull %a, i8* nonnull %b, i8* nonnull %c)
257​; call void @use3nonnull(i8* nonnull %b, i8* nonnull %c, i8* nonnull %a)
258​; call void @use3(i8* nonnull %c, i8* nonnull %a, i8* nonnull %b)
259​
260​; ATTRIBUTOR-LABEL: @parent2(i8* %a, i8* %b, i8* %c)
261​; ATTRIBUTOR-NEXT: call void @use3nonnull(i8* nonnull %b, i8* nonnull %c, i8* nonnull %a)
262​; ATTRIBUTOR-NEXT: call void @use3(i8* %c, i8* %a, i8* %b)
263​
264​; BOTH-NEXT: ret void
109 call void @use3nonnull(i8* %b, i8* %c, i8* %a) 265​ call void @use3nonnull(i8* %b, i8* %c, i8* %a)
110 call void @use3(i8* %c, i8* %a, i8* %b) 266​ call void @use3(i8* %c, i8* %a, i8* %b)
111 ret void 267​ ret void
112} 268​}
113 269​
114; Extend non-null to parent for 1st argument. 270​; Extend non-null to parent for 1st argument.
115 271​
116define void @parent3(i8* %a, i8* %b, i8* %c) { 272​define void @parent3(i8* %a, i8* %b, i8* %c) {
117; CHECK-LABEL: @parent3(i8* nonnull %a, i8* %b, i8* %c) 273​; FNATTR-LABEL: @parent3(i8* nonnull %a, i8* %b, i8* %c)
118; CHECK-NEXT: call void @use1nonnull(i8* %a) 274​; FNATTR-NEXT: call void @use1nonnull(i8* %a)
119; CHECK-NEXT: call void @use3(i8* %c, i8* %b, i8* %a) 275​; FNATTR-NEXT: call void @use3(i8* %c, i8* %b, i8* %a)
120; CHECK-NEXT: ret void 276​
121; 277​; FIXME: missing "nonnull", it should be,
278​; @parent3(i8* nonnull %a, i8* %b, i8* %c)
279​; call void @use1nonnull(i8* nonnull %a)
280​; call void @use3(i8* %c, i8* %b, i8* nonnull %a)
281​; ATTRIBUTOR-LABEL: @parent3(i8* %a, i8* %b, i8* %c)
282​; ATTRIBUTOR-NEXT: call void @use1nonnull(i8* nonnull %a)
283​; ATTRIBUTOR-NEXT: call void @use3(i8* %c, i8* %b, i8* %a)
284​
285​; BOTH-NEXT: ret void
286​
122 call void @use1nonnull(i8* %a) 287​ call void @use1nonnull(i8* %a)
123 call void @use3(i8* %c, i8* %b, i8* %a) 288​ call void @use3(i8* %c, i8* %b, i8* %a)
124 ret void 289​ ret void
125} 290​}
126 291​
127; Extend non-null to parent for last 2 arguments. 292​; Extend non-null to parent for last 2 arguments.
128 293​
129define void @parent4(i8* %a, i8* %b, i8* %c) { 294​define void @parent4(i8* %a, i8* %b, i8* %c) {
130; CHECK-LABEL: @parent4(i8* %a, i8* nonnull %b, i8* nonnull %c) 295​; CHECK-LABEL: @parent4(i8* %a, i8* nonnull %b, i8* nonnull %c)
131; CHECK-NEXT: call void @use2nonnull(i8* %c, i8* %b) 296​; CHECK-NEXT: call void @use2nonnull(i8* %c, i8* %b)
132; CHECK-NEXT: call void @use2(i8* %a, i8* %c) 297​; CHECK-NEXT: call void @use2(i8* %a, i8* %c)
133; CHECK-NEXT: call void @use1(i8* %b) 298​; CHECK-NEXT: call void @use1(i8* %b)
134; CHECK-NEXT: ret void 299​
135; 300​; FIXME : missing "nonnull", it should be
301​; @parent4(i8* %a, i8* nonnull %b, i8* nonnull %c)
302​; call void @use2nonnull(i8* nonnull %c, i8* nonull %b)
303​; call void @use2(i8* %a, i8* nonnull %c)
304​; call void @use1(i8* nonnull %b)
305​
306​; ATTRIBUTOR-LABEL: @parent4(i8* %a, i8* %b, i8* %c)
307​; ATTRIBUTOR-NEXT: call void @use2nonnull(i8* nonnull %c, i8* nonnull %b)
308​; ATTRIBUTOR-NEXT: call void @use2(i8* %a, i8* %c)
309​; ATTRIBUTOR-NEXT: call void @use1(i8* %b)
310​
311​; BOTH: ret void
312​
136 call void @use2nonnull(i8* %c, i8* %b) 313​ call void @use2nonnull(i8* %c, i8* %b)
137 call void @use2(i8* %a, i8* %c) 314​ call void @use2(i8* %a, i8* %c)
138 call void @use1(i8* %b) 315​ call void @use1(i8* %b)
139 ret void 316​ ret void
140} 317​}
141 318​
142; The callsite must execute in order for the attribute to transfer to the parent. 319​; The callsite must execute in order for the attribute to transfer to the parent.
143; It appears benign to extend non-null to the parent in this case, but we can't do that 320​; It appears benign to extend non-null to the parent in this case, but we can't do that
144; because it would incorrectly propagate the wrong information to its callers. 321​; because it would incorrectly propagate the wrong information to its callers.
145 322​
146define void @parent5(i8* %a, i1 %a_is_notnull) { 323​define void @parent5(i8* %a, i1 %a_is_notnull) {
147; CHECK-LABEL: @parent5(i8* %a, i1 %a_is_notnull) 324​; BOTH: @parent5(i8* %a, i1 %a_is_notnull)
148; CHECK-NEXT: br i1 %a_is_notnull, label %t, label %f 325​; BOTH-NEXT: br i1 %a_is_notnull, label %t, label %f
149; CHECK: t: 326​; BOTH: t:
150; CHECK-NEXT: call void @use1nonnull(i8* %a) 327​; FNATTR-NEXT: call void @use1nonnull(i8* %a)
151; CHECK-NEXT: ret void 328​; ATTRIBUTOR-NEXT: call void @use1nonnull(i8* nonnull %a)
152; CHECK: f: 329​; BOTH-NEXT: ret void
153; CHECK-NEXT: ret void 330​; BOTH: f:
154; 331​; BOTH-NEXT: ret void
332​
155 br i1 %a_is_notnull, label %t, label %f 333​ br i1 %a_is_notnull, label %t, label %f
156t: 334​t:
157 call void @use1nonnull(i8* %a) 335​ call void @use1nonnull(i8* %a)
158 ret void 336​ ret void
159f: 337​f:
160 ret void 338​ ret void
161} 339​}
162 340​
163; The callsite must execute in order for the attribute to transfer to the parent. 341​; The callsite must execute in order for the attribute to transfer to the parent.
164; The volatile load might trap, so there's no guarantee that we'll ever get to the call. 342​; The volatile load might trap, so there's no guarantee that we'll ever get to the call.
165 343​
166define i8 @parent6(i8* %a, i8* %b) { 344​define i8 @parent6(i8* %a, i8* %b) {
167; CHECK-LABEL: @parent6(i8* %a, i8* %b) 345​; BOTH-LABEL: @parent6(i8* %a, i8* %b)
168; CHECK-NEXT: [[C:%.*]] = load volatile i8, i8* %b 346​; BOTH-NEXT: [[C:%.*]] = load volatile i8, i8* %b
169; CHECK-NEXT: call void @use1nonnull(i8* %a) 347​; FNATTR-NEXT: call void @use1nonnull(i8* %a)
170; CHECK-NEXT: ret i8 [[C]] 348​; ATTRIBUTOR-NEXT: call void @use1nonnull(i8* nonnull %a)
171; 349​; BOTH-NEXT: ret i8 [[C]]
350​
172 %c = load volatile i8, i8* %b 351​ %c = load volatile i8, i8* %b
173 call void @use1nonnull(i8* %a) 352​ call void @use1nonnull(i8* %a)
174 ret i8 %c 353​ ret i8 %c
175} 354​}
176 355​
177; The nonnull callsite is guaranteed to execute, so the argument must be nonnull throughout the parent. 356​; The nonnull callsite is guaranteed to execute, so the argument must be nonnull throughout the parent.
178 357​
179define i8 @parent7(i8* %a) { 358​define i8 @parent7(i8* %a) {
180; CHECK-LABEL: @parent7(i8* nonnull %a) 359​; FNATTR-LABEL: @parent7(i8* nonnull %a)
181; CHECK-NEXT: [[RET:%.*]] = call i8 @use1safecall(i8* %a) 360​; FNATTR-NEXT: [[RET:%.*]] = call i8 @use1safecall(i8* %a)
182; CHECK-NEXT: call void @use1nonnull(i8* %a) 361​; FNATTR-NEXT: call void @use1nonnull(i8* %a)
183; CHECK-NEXT: ret i8 [[RET]] 362​
184; 363​; FIXME : missing "nonnull", it should be
364​; @parent7(i8* nonnull %a)
365​; [[RET:%.*]] = call i8 @use1safecall(i8* nonnull %a)
366​; call void @use1nonnull(i8* nonnull %a)
367​; ret i8 [[RET]]
368​
369​; ATTRIBUTOR-LABEL: @parent7(i8* %a)
370​; ATTRIBUTOR-NEXT: [[RET:%.*]] = call i8 @use1safecall(i8* %a)
371​; ATTRIBUTOR-NEXT: call void @use1nonnull(i8* nonnull %a)
372​
373​; BOTH-NEXT: ret i8 [[RET]]
374​
185 %ret = call i8 @use1safecall(i8* %a) 375​ %ret = call i8 @use1safecall(i8* %a)
186 call void @use1nonnull(i8* %a) 376​ call void @use1nonnull(i8* %a)
187 ret i8 %ret 377​ ret i8 %ret
188} 378​}
189 379​
190; Make sure that an invoke works similarly to a call. 380​; Make sure that an invoke works similarly to a call.
191 381​
192declare i32 @esfp(...) 382​declare i32 @esfp(...)
193 383​
194define i1 @parent8(i8* %a, i8* %bogus1, i8* %b) personality i8* bitcast (i32 (...)* @esfp to i8*){ 384​define i1 @parent8(i8* %a, i8* %bogus1, i8* %b) personality i8* bitcast (i32 (...)* @esfp to i8*){
195; CHECK-LABEL: @parent8(i8* nonnull %a, i8* nocapture readnone %bogus1, i8* nonnull %b) 385​; FNATTR-LABEL: @parent8(i8* nonnull %a, i8* nocapture readnone %bogus1, i8* nonnull %b)
196; CHECK-NEXT: entry: 386​; FIXME : missing "nonnull", it should be @parent8(i8* nonnull %a, i8* %bogus1, i8* nonnull %b)
197; CHECK-NEXT: invoke void @use2nonnull(i8* %a, i8* %b) 387​; ATTRIBUTOR-LABEL: @parent8(i8* %a, i8* %bogus1, i8* %b)
198; CHECK-NEXT: to label %cont unwind label %exc 388​; BOTH-NEXT: entry:
199; CHECK: cont: 389​; FNATTR-NEXT: invoke void @use2nonnull(i8* %a, i8* %b)
200; CHECK-NEXT: [[NULL_CHECK:%.*]] = icmp eq i8* %b, null 390​; ATTRIBUTOR-NEXT: invoke void @use2nonnull(i8* nonnull %a, i8* nonnull %b)
201; CHECK-NEXT: ret i1 [[NULL_CHECK]] 391​; BOTH-NEXT: to label %cont unwind label %exc
202; CHECK: exc: 392​; BOTH: cont:
203; CHECK-NEXT: [[LP:%.*]] = landingpad { i8*, i32 } 393​; BOTH-NEXT: [[NULL_CHECK:%.*]] = icmp eq i8* %b, null
204; CHECK-NEXT: filter [0 x i8*] zeroinitializer 394​; BOTH-NEXT: ret i1 [[NULL_CHECK]]
205; CHECK-NEXT: unreachable 395​; BOTH: exc:
206; 396​; BOTH-NEXT: [[LP:%.*]] = landingpad { i8*, i32 }
397​; BOTH-NEXT: filter [0 x i8*] zeroinitializer
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…
398​; BOTH-NEXT: unreachable
399​
207entry: 400​entry:
208 invoke void @use2nonnull(i8* %a, i8* %b) 401​ invoke void @use2nonnull(i8* %a, i8* %b)
209 to label %cont unwind label %exc 402​ to label %cont unwind label %exc
210 403​
211cont: 404​cont:
212 %null_check = icmp eq i8* %b, null 405​ %null_check = icmp eq i8* %b, null
213 ret i1 %null_check 406​ ret i1 %null_check
214 407​
215exc: 408​exc:
216 %lp = landingpad { i8*, i32 } 409​ %lp = landingpad { i8*, i32 }
217 filter [0 x i8*] zeroinitializer 410​ filter [0 x i8*] zeroinitializer
218 unreachable 411​ unreachable
219} 412​}
220 413​
221; CHECK: define nonnull i32* @gep1( 414​; BOTH: define nonnull i32* @gep1(
222define i32* @gep1(i32* %p) { 415​define i32* @gep1(i32* %p) {
223 %q = getelementptr inbounds i32, i32* %p, i32 1 416​ %q = getelementptr inbounds i32, i32* %p, i32 1
224 ret i32* %q 417​ ret i32* %q
225} 418​}
226 419​
227define i32* @gep1_no_null_opt(i32* %p) #0 { 420​define i32* @gep1_no_null_opt(i32* %p) #0 {
228; Should't be able to derive nonnull based on gep. 421​; Should't be able to derive nonnull based on gep.
229; CHECK: define i32* @gep1_no_null_opt( 422​; BOTH: define i32* @gep1_no_null_opt(
230 %q = getelementptr inbounds i32, i32* %p, i32 1 423​ %q = getelementptr inbounds i32, i32* %p, i32 1
231 ret i32* %q 424​ ret i32* %q
232} 425​}
233 426​
234; CHECK: define i32 addrspace(3)* @gep2( 427​; BOTH: define i32 addrspace(3)* @gep2(
235define i32 addrspace(3)* @gep2(i32 addrspace(3)* %p) { 428​define i32 addrspace(3)* @gep2(i32 addrspace(3)* %p) {
236 %q = getelementptr inbounds i32, i32 addrspace(3)* %p, i32 1 429​ %q = getelementptr inbounds i32, i32 addrspace(3)* %p, i32 1
237 ret i32 addrspace(3)* %q 430​ ret i32 addrspace(3)* %q
238} 431​}
239 432​
240attributes #0 = { "null-pointer-is-valid"="true" } 433​attributes #0 = { "null-pointer-is-valid"="true" }