test/Transforms/FunctionAttrs/nonnull.ll

   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 --check-prefixes=BOTH,FNATTR
   3 ; RUN: opt -attributor --attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=8 -S < %s | FileCheck %s --check-prefixes=BOTH,ATTRIBUTOR
   4
   5 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   6
   7 declare nonnull i8* @ret_nonnull()
   8
   9 ; Return a pointer trivially nonnull (call return attribute)
  10 define i8* @test1() {
  11 ; BOTH: define nonnull i8* @test1
  12   %ret = call i8* @ret_nonnull()
  13   ret i8* %ret
  14 }
  15
  16 ; Return a pointer trivially nonnull (argument attribute)
  17 define i8* @test2(i8* nonnull %p) {
  18 ; BOTH: define nonnull i8* @test2
  19   ret i8* %p
  20 }
  21
  22 ; Given an SCC where one of the functions can not be marked nonnull,
  23 ; can we still mark the other one which is trivially nonnull
  24 define i8* @scc_binder(i1 %c) {
  25 ; FNATTR: define i8* @scc_binder
  26 ; ATTRIBUTOR: define noalias i8* @scc_binder
  27   br i1 %c, label %rec, label %end
  28 rec:
  29   call i8* @test3(i1 %c)
  30   br label %end
  31 end:
  32   ret i8* null
  33 }
  34
  35 define i8* @test3(i1 %c) {
  36 ; BOTH: define nonnull i8* @test3
  37   call i8* @scc_binder(i1 %c)
  38   %ret = call i8* @ret_nonnull()
  39   ret i8* %ret
  40 }
  41
  42 ; Given a mutual recursive set of functions, we can mark them
  43 ; nonnull if neither can ever return null.  (In this case, they
  44 ; just never return period.)
  45 define i8* @test4_helper() {
  46 ; FNATTR: define noalias nonnull i8* @test4_helper
  47 ; ATTRIBUTOR: define noalias nonnull align 536870912 dereferenceable(4294967295) i8* @test4_helper
  48   %ret = call i8* @test4()
  49   ret i8* %ret
  50 }
  51
  52 define i8* @test4() {
  53 ; FNATTR: define noalias nonnull i8* @test4
  54 ; ATTRIBUTOR: define noalias nonnull align 536870912 dereferenceable(4294967295) i8* @test4
  55   %ret = call i8* @test4_helper()
  56   ret i8* %ret
  57 }
  58
  59 ; Given a mutual recursive set of functions which *can* return null
  60 ; make sure we haven't marked them as nonnull.
  61 define i8* @test5_helper(i1 %c) {
  62 ; FNATTR: define noalias i8* @test5_helper
  63 ; ATTRIBUTOR: define noalias i8* @test5_helper
  64   br i1 %c, label %rec, label %end
  65 rec:
  66   %ret = call i8* @test5(i1 %c)
  67   br label %end
  68 end:
  69   ret i8* null
  70 }
  71
  72 define i8* @test5(i1 %c) {
  73 ; FNATTR: define noalias i8* @test5
  74 ; ATTRIBUTOR: define noalias i8* @test5
  75   %ret = call i8* @test5_helper(i1 %c)
  76   ret i8* %ret
  77 }
  78
  79 ; Local analysis, but going through a self recursive phi
  80 define i8* @test6() {
  81 entry:
  82 ; BOTH: define nonnull i8* @test6
  83   %ret = call i8* @ret_nonnull()
  84   br label %loop
  85 loop:
  86   %phi = phi i8* [%ret, %entry], [%phi, %loop]
  87   br i1 undef, label %loop, label %exit
  88 exit:
  89   ret i8* %phi
  90 }
  91
  92 ; BOTH: define i8* @test7
  93 define i8* @test7(i8* %a) {
  94   %b = getelementptr inbounds i8, i8* %a, i64 0
  95   ret i8* %b
  96 }
  97
  98 ; BOTH: define nonnull i8* @test8
  99 define i8* @test8(i8* %a) {
 100   %b = getelementptr inbounds i8, i8* %a, i64 1
 101   ret i8* %b
 102 }
 103
 104 ; BOTH: define i8* @test9
 105 define i8* @test9(i8* %a, i64 %n) {
 106   %b = getelementptr inbounds i8, i8* %a, i64 %n
 107   ret i8* %b
 108 }
 109
 110 declare void @llvm.assume(i1)
 111 ; FNATTR: define i8* @test10
 112 ; FIXME: missing nonnull
 113 ; ATTRIBUTOR: define i8* @test10
 114 define i8* @test10(i8* %a, i64 %n) {
 115   %cmp = icmp ne i64 %n, 0
 116   call void @llvm.assume(i1 %cmp)
 117   %b = getelementptr inbounds i8, i8* %a, i64 %n
 118   ret i8* %b
 119 }
 120
 121 ; TEST 11
 122 ; char* test11(char *p) {
 123 ;   return p? p: nonnull();
 124 ; }
 125 ; FNATTR: define i8* @test11
 126 ; FIXME: missing nonnull
 127 ; ATTRIBUTOR: define i8* @test11
 128 define i8* @test11(i8*) local_unnamed_addr {
 129   %2 = icmp eq i8* %0, null
 130   br i1 %2, label %3, label %5
 131
 132 ; <label>:3:                                      ; preds = %1
 133   %4 = tail call i8* @ret_nonnull()
 134   br label %5
 135
 136 ; <label>:5:                                      ; preds = %3, %1
 137   %6 = phi i8* [ %4, %3 ], [ %0, %1 ]
 138   ret i8* %6
 139 }
 140
 141 ; TEST 12
 142 ; Simple CallSite Test
 143 declare void @test12_helper(i8*)
 144 define void @test12(i8* nonnull %a) {
 145 ; ATTRIBUTOR: define void @test12(i8* nonnull %a)
 146 ; ATTRIBUTOR-NEXT: tail call void @test12_helper(i8* nonnull %a)
 147   tail call void @test12_helper(i8* %a)
 148   ret void
 149 }
 150
 151 ; TEST 13
 152 ; Simple Argument Tests
 153 declare i8* @unknown()
 154 define void @test13_helper() {
 155   %nonnullptr = tail call i8* @ret_nonnull()
 156   %maybenullptr = tail call i8* @unknown()
 157   tail call void @test13(i8* %nonnullptr, i8* %nonnullptr, i8* %maybenullptr)
 158   tail call void @test13(i8* %nonnullptr, i8* %maybenullptr, i8* %nonnullptr)
 159   ret void
 160 }
 161 define internal void @test13(i8* %a, i8* %b, i8* %c) {
 162 ; ATTRIBUTOR: define internal void @test13(i8* nocapture nonnull readnone %a, i8* nocapture readnone %b, i8* nocapture readnone %c)
 163   ret void
 164 }
 165
 166 declare nonnull i8* @nonnull()
 167
 168 ; TEST 14
 169 ; Complex propagation
 170 ; Argument of f1, f2, f3 can be marked with nonnull.
 171
 172 ; * Argument
 173 ; 1. In f1:bb6, %arg can be marked with nonnull because of the comparison in bb1
 174 ; 2. Because f2 is internal function, f2(i32* %arg) -> @f2(i32* nonnull %arg)
 175 ; 3. In f1:bb4 %tmp5 is nonnull and f3 is internal function.
 176 ;    Then, f3(i32* %arg) -> @f3(i32* nonnull %arg)
 177 ; 4. We get nonnull in whole f1 call sites so f1(i32* %arg) -> @f1(i32* nonnull %arg)
 178
 179
 180 define internal i32* @f1(i32* %arg) {
 181 ; FIXME: missing nonnull It should be nonnull @f1(i32* nonnull readonly %arg)
 182 ; ATTRIBUTOR: define internal nonnull i32* @f1(i32* readonly %arg)
 183
 184 bb:
 185   %tmp = icmp eq i32* %arg, null
 186   br i1 %tmp, label %bb9, label %bb1
 187
 188 bb1:                                              ; preds = %bb
 189   %tmp2 = load i32, i32* %arg, align 4
 190   %tmp3 = icmp eq i32 %tmp2, 0
 191   br i1 %tmp3, label %bb6, label %bb4
 192
 193 bb4:                                              ; preds = %bb1
 194   %tmp5 = getelementptr inbounds i32, i32* %arg, i64 1
 195 ; ATTRIBUTOR: %tmp5b = tail call i32* @f3(i32* nonnull %tmp5)
 196   %tmp5b = tail call i32* @f3(i32* %tmp5)
 197   br label %bb9
 198
 199 bb6:                                              ; preds = %bb1
 200 ; FIXME: missing nonnull. It should be @f2(i32* nonnull %arg)
 201 ; ATTRIBUTOR: %tmp7 = tail call nonnull i32* @f2(i32* readonly %arg)
 202   %tmp7 = tail call i32* @f2(i32* %arg)
 203   ret i32* %tmp7
 204
 205 bb9:                                              ; preds = %bb4, %bb
 206   %tmp10 = phi i32* [ %tmp5, %bb4 ], [ inttoptr (i64 4 to i32*), %bb ]
 207   ret i32* %tmp10
 208 }
 209
 210 define internal i32* @f2(i32* %arg) {
 211 ; FIXME: missing nonnull. It should be nonnull @f2(i32* nonnull %arg)
 212 ; ATTRIBUTOR: define internal nonnull i32* @f2(i32* readonly %arg)
 213 bb:
 214
 215 ; FIXME: missing nonnull. It should be @f1(i32* nonnull readonly %arg)
 216 ; ATTRIBUTOR:   %tmp = tail call nonnull i32* @f1(i32* readonly %arg)
 217   %tmp = tail call i32* @f1(i32* %arg)
 218   ret i32* %tmp
 219 }
 220
 221 define dso_local noalias i32* @f3(i32* %arg) {
 222 ; FIXME: missing nonnull. It should be nonnull @f3(i32* nonnull readonly %arg)
 223 ; ATTRIBUTOR: define dso_local noalias i32* @f3(i32* nocapture readonly %arg)
 224 bb:
 225 ; FIXME: missing nonnull. It should be @f1(i32* nonnull readonly %arg)
 226 ; ATTRIBUTOR:   %tmp = call i32* @f1(i32* readonly %arg)
 227   %tmp = call i32* @f1(i32* %arg)
 228   ret i32* null
 229 }
 230
 231 ; TEST 15
 232 define void @f15(i8* %arg) {
 233 ; ATTRIBUTOR:   tail call void @use1(i8* nonnull dereferenceable(4) %arg)
 234
 235   tail call void @use1(i8* dereferenceable(4) %arg)
 236   ret void
 237 }
 238
 239 declare void @fun0() #1
 240 declare void @fun1(i8*) #1
 241 declare void @fun2(i8*, i8*) #1
 242 declare void @fun3(i8*, i8*, i8*) #1
 243 ; TEST 16 simple path test
 244 ; if(..)
 245 ;   fun2(nonnull %a, nonnull %b)
 246 ; else
 247 ;   fun2(nonnull %a, %b)
 248 ; We can say that %a is nonnull but %b is not.
 249 define void @f16(i8* %a, i8 * %b, i8 %c) {
 250 ; FIXME: missing nonnull on %a
 251 ; ATTRIBUTOR: define void @f16(i8* %a, i8* %b, i8 %c)
 252   %cmp = icmp eq i8 %c, 0
 253   br i1 %cmp, label %if.then, label %if.else
 254 if.then:
 255   tail call void @fun2(i8* nonnull %a, i8* nonnull %b)
 256   ret void
 257 if.else:
 258   tail call void @fun2(i8* nonnull %a, i8* %b)
 259   ret void
 260 }
 261 ; TEST 17 explore child BB test
 262 ; if(..)
 263 ;    ... (willreturn & nounwind)
 264 ; else
 265 ;    ... (willreturn & nounwind)
 266 ; fun1(nonnull %a)
 267 ; We can say that %a is nonnull
 268 define void @f17(i8* %a, i8 %c) {
 269 ; FIXME: missing nonnull on %a
 270 ; ATTRIBUTOR: define void @f17(i8* %a, i8 %c)
 271   %cmp = icmp eq i8 %c, 0
 272   br i1 %cmp, label %if.then, label %if.else
 273 if.then:
 274   tail call void @fun0()
 275   br label %cont
 276 if.else:
 277   tail call void @fun0()
 278   br label %cont
 279 cont:
 280   tail call void @fun1(i8* nonnull %a)
 281   ret void
 282 }
 283 ; TEST 18 More complex test
 284 ; if(..)
 285 ;    ... (willreturn & nounwind)
 286 ; else
 287 ;    ... (willreturn & nounwind)
 288 ; if(..)
 289 ;    ... (willreturn & nounwind)
 290 ; else
 291 ;    ... (willreturn & nounwind)
 292 ; fun1(nonnull %a)
 293
 294 define void @f18(i8* %a, i8* %b, i8 %c) {
 295 ; FIXME: missing nonnull on %a
 296 ; ATTRIBUTOR: define void @f18(i8* %a, i8* %b, i8 %c)
 297   %cmp1 = icmp eq i8 %c, 0
 298   br i1 %cmp1, label %if.then, label %if.else
 299 if.then:
 300   tail call void @fun0()
 301   br label %cont
 302 if.else:
 303   tail call void @fun0()
 304   br label %cont
 305 cont:
 306   %cmp2 = icmp eq i8 %c, 1
 307   br i1 %cmp2, label %cont.then, label %cont.else
 308 cont.then:
 309   tail call void @fun1(i8* nonnull %b)
 310   br label %cont2
 311 cont.else:
 312   tail call void @fun0()
 313   br label %cont2
 314 cont2:
 315   tail call void @fun1(i8* nonnull %a)
 316   ret void
 317 }
 318
 319 ; TEST 19: Loop
 320
 321 define void @f19(i8* %a, i8* %b, i8 %c) {
 322 ; FIXME: missing nonnull on %b
 323 ; ATTRIBUTOR: define void @f19(i8* %a, i8* %b, i8 %c)
 324   br label %loop.header
 325 loop.header:
 326   %cmp2 = icmp eq i8 %c, 0
 327   br i1 %cmp2, label %loop.body, label %loop.exit
 328 loop.body:
 329   tail call void @fun1(i8* nonnull %b)
 330   tail call void @fun1(i8* nonnull %a)
 331   br label %loop.header
 332 loop.exit:
 333   tail call void @fun1(i8* nonnull %b)
 334   ret void
 335 }
 336
 337 ; Test propagation of nonnull callsite args back to caller.
 338
 339 declare void @use1(i8* %x)
 340 declare void @use2(i8* %x, i8* %y);
 341 declare void @use3(i8* %x, i8* %y, i8* %z);
 342
 343 declare void @use1nonnull(i8* nonnull %x);
 344 declare void @use2nonnull(i8* nonnull %x, i8* nonnull %y);
 345 declare void @use3nonnull(i8* nonnull %x, i8* nonnull %y, i8* nonnull %z);
 346
 347 declare i8 @use1safecall(i8* %x) readonly nounwind ; readonly+nounwind guarantees that execution continues to successor
 348
 349 ; Can't extend non-null to parent for any argument because the 2nd call is not guaranteed to execute.
 350
 351 define void @parent1(i8* %a, i8* %b, i8* %c) {
 352 ; BOTH-LABEL: @parent1(i8* %a, i8* %b, i8* %c)
 353 ; BOTH-NEXT:    call void @use3(i8* %c, i8* %a, i8* %b)
 354 ; FNATTR-NEXT:    call void @use3nonnull(i8* %b, i8* %c, i8* %a)
 355 ; ATTRIBUTOR-NEXT:    call void @use3nonnull(i8* nonnull %b, i8* nonnull %c, i8* nonnull %a)
 356 ; BOTH-NEXT:    ret void
 357   call void @use3(i8* %c, i8* %a, i8* %b)
 358   call void @use3nonnull(i8* %b, i8* %c, i8* %a)
 359   ret void
 360 }
 361
 362 ; Extend non-null to parent for all arguments.
 363
 364 define void @parent2(i8* %a, i8* %b, i8* %c) {
 365 ; FNATTR-LABEL: @parent2(i8* nonnull %a, i8* nonnull %b, i8* nonnull %c)
 366 ; FNATTR-NEXT:    call void @use3nonnull(i8* %b, i8* %c, i8* %a)
 367 ; FNATTR-NEXT:    call void @use3(i8* %c, i8* %a, i8* %b)
 368
 369 ; ATTRIBUTOR-LABEL: @parent2(i8* nonnull %a, i8* nonnull %b, i8* nonnull %c)
 370 ; ATTRIBUTOR-NEXT:    call void @use3nonnull(i8* nonnull %b, i8* nonnull %c, i8* nonnull %a)
 371 ; ATTRIBUTOR-NEXT:    call void @use3(i8* nonnull %c, i8* nonnull %a, i8* nonnull %b)
 372
 373 ; BOTH-NEXT:    ret void
 374   call void @use3nonnull(i8* %b, i8* %c, i8* %a)
 375   call void @use3(i8* %c, i8* %a, i8* %b)
 376   ret void
 377 }
 378
 379 ; Extend non-null to parent for 1st argument.
 380
 381 define void @parent3(i8* %a, i8* %b, i8* %c) {
 382 ; FNATTR-LABEL: @parent3(i8* nonnull %a, i8* %b, i8* %c)
 383 ; FNATTR-NEXT:    call void @use1nonnull(i8* %a)
 384 ; FNATTR-NEXT:    call void @use3(i8* %c, i8* %b, i8* %a)
 385
 386 ; ATTRIBUTOR-LABEL: @parent3(i8* nonnull %a, i8* %b, i8* %c)
 387 ; ATTRIBUTOR-NEXT:    call void @use1nonnull(i8* nonnull %a)
 388 ; ATTRIBUTOR-NEXT:    call void @use3(i8* %c, i8* %b, i8* nonnull %a)
 389
 390 ; BOTH-NEXT:  ret void
 391
 392   call void @use1nonnull(i8* %a)
 393   call void @use3(i8* %c, i8* %b, i8* %a)
 394   ret void
 395 }
 396
 397 ; Extend non-null to parent for last 2 arguments.
 398
 399 define void @parent4(i8* %a, i8* %b, i8* %c) {
 400 ; CHECK-LABEL: @parent4(i8* %a, i8* nonnull %b, i8* nonnull %c)
 401 ; CHECK-NEXT:    call void @use2nonnull(i8* %c, i8* %b)
 402 ; CHECK-NEXT:    call void @use2(i8* %a, i8* %c)
 403 ; CHECK-NEXT:    call void @use1(i8* %b)
 404
 405 ; ATTRIBUTOR-LABEL: @parent4(i8* %a, i8* nonnull %b, i8* nonnull %c)
 406 ; ATTRIBUTOR-NEXT:    call void @use2nonnull(i8* nonnull %c, i8* nonnull %b)
 407 ; ATTRIBUTOR-NEXT:    call void @use2(i8* %a, i8* nonnull %c)
 408 ; ATTRIBUTOR-NEXT:    call void @use1(i8* nonnull %b)
 409
 410 ; BOTH: ret void
 411
 412   call void @use2nonnull(i8* %c, i8* %b)
 413   call void @use2(i8* %a, i8* %c)
 414   call void @use1(i8* %b)
 415   ret void
 416 }
 417
 418 ; The callsite must execute in order for the attribute to transfer to the parent.
 419 ; It appears benign to extend non-null to the parent in this case, but we can't do that
 420 ; because it would incorrectly propagate the wrong information to its callers.
 421
 422 define void @parent5(i8* %a, i1 %a_is_notnull) {
 423 ; BOTH: @parent5(i8* %a, i1 %a_is_notnull)
 424 ; BOTH-NEXT:    br i1 %a_is_notnull, label %t, label %f
 425 ; BOTH:       t:
 426 ; FNATTR-NEXT:    call void @use1nonnull(i8* %a)
 427 ; ATTRIBUTOR-NEXT:    call void @use1nonnull(i8* nonnull %a)
 428 ; BOTH-NEXT:    ret void
 429 ; BOTH:       f:
 430 ; BOTH-NEXT:    ret void
 431
 432   br i1 %a_is_notnull, label %t, label %f
 433 t:
 434   call void @use1nonnull(i8* %a)
 435   ret void
 436 f:
 437   ret void
 438 }
 439
 440 ; The callsite must execute in order for the attribute to transfer to the parent.
 441 ; The volatile load can't trap, so we can guarantee that we'll get to the call.
 442
 443 define i8 @parent6(i8* %a, i8* %b) {
 444 ; FNATTR-LABEL: @parent6(i8* nonnull %a, i8* %b)
 445 ; ATTRIBUTOR-LABEL: @parent6(i8* nonnull %a, i8* %b)
 446 ; BOTH-NEXT:    [[C:%.*]] = load volatile i8, i8* %b
 447 ; FNATTR-NEXT:    call void @use1nonnull(i8* %a)
 448 ; ATTRIBUTOR-NEXT:    call void @use1nonnull(i8* nonnull %a)
 449 ; BOTH-NEXT:    ret i8 [[C]]
 450
 451   %c = load volatile i8, i8* %b
 452   call void @use1nonnull(i8* %a)
 453   ret i8 %c
 454 }
 455
 456 ; The nonnull callsite is guaranteed to execute, so the argument must be nonnull throughout the parent.
 457
 458 define i8 @parent7(i8* %a) {
 459 ; FNATTR-LABEL: @parent7(i8* nonnull %a)
 460 ; FNATTR-NEXT:    [[RET:%.*]] = call i8 @use1safecall(i8* %a)
 461 ; FNATTR-NEXT:    call void @use1nonnull(i8* %a)
 462
 463
 464 ; ATTRIBUTOR-LABEL: @parent7(i8* nonnull %a)
 465 ; ATTRIBUTOR-NEXT:    [[RET:%.*]] = call i8 @use1safecall(i8* nonnull %a)
 466 ; ATTRIBUTOR-NEXT:    call void @use1nonnull(i8* nonnull %a)
 467
 468 ; BOTH-NEXT: ret i8 [[RET]]
 469
 470   %ret = call i8 @use1safecall(i8* %a)
 471   call void @use1nonnull(i8* %a)
 472   ret i8 %ret
 473 }
 474
 475 ; Make sure that an invoke works similarly to a call.
 476
 477 declare i32 @esfp(...)
 478
 479 define i1 @parent8(i8* %a, i8* %bogus1, i8* %b) personality i8* bitcast (i32 (...)* @esfp to i8*){
 480 ; BOTH-LABEL: @parent8(i8* nonnull %a, i8* nocapture readnone %bogus1, i8* nonnull %b)
 481 ; BOTH-NEXT:  entry:
 482 ; FNATTR-NEXT:    invoke void @use2nonnull(i8* %a, i8* %b)
 483 ; ATTRIBUTOR-NEXT:    invoke void @use2nonnull(i8* nonnull %a, i8* nonnull %b)
 484 ; BOTH-NEXT:    to label %cont unwind label %exc
 485 ; BOTH:       cont:
 486 ; BOTH-NEXT:    [[NULL_CHECK:%.*]] = icmp eq i8* %b, null
 487 ; BOTH-NEXT:    ret i1 [[NULL_CHECK]]
 488 ; BOTH:       exc:
 489 ; BOTH-NEXT:    [[LP:%.*]] = landingpad { i8*, i32 }
 490 ; BOTH-NEXT:    filter [0 x i8*] zeroinitializer
 491 ; BOTH-NEXT:    unreachable
 492
 493 entry:
 494   invoke void @use2nonnull(i8* %a, i8* %b)
 495   to label %cont unwind label %exc
 496
 497 cont:
 498   %null_check = icmp eq i8* %b, null
 499   ret i1 %null_check
 500
 501 exc:
 502   %lp = landingpad { i8*, i32 }
 503   filter [0 x i8*] zeroinitializer
 504   unreachable
 505 }
 506
 507 ; BOTH: define nonnull i32* @gep1(
 508 define i32* @gep1(i32* %p) {
 509   %q = getelementptr inbounds i32, i32* %p, i32 1
 510   ret i32* %q
 511 }
 512
 513 define i32* @gep1_no_null_opt(i32* %p) #0 {
 514 ; Should't be able to derive nonnull based on gep.
 515 ; BOTH: define i32* @gep1_no_null_opt(
 516   %q = getelementptr inbounds i32, i32* %p, i32 1
 517   ret i32* %q
 518 }
 519
 520 ; BOTH: define i32 addrspace(3)* @gep2(
 521 define i32 addrspace(3)* @gep2(i32 addrspace(3)* %p) {
 522   %q = getelementptr inbounds i32, i32 addrspace(3)* %p, i32 1
 523   ret i32 addrspace(3)* %q
 524 }
 525
 526 ; FNATTR:     define i32 addrspace(3)* @as(i32 addrspace(3)* readnone returned dereferenceable(4) %p)
 527 ; FIXME: We should propagate dereferenceable here but *not* nonnull
 528 ; ATTRIBUTOR: define dereferenceable_or_null(4) i32 addrspace(3)* @as(i32 addrspace(3)* readnone returned dereferenceable(4) dereferenceable_or_null(4) %p)
 529 define i32 addrspace(3)* @as(i32 addrspace(3)* dereferenceable(4) %p) {
 530   ret i32 addrspace(3)* %p
 531 }
 532
 533 ; BOTH: define internal nonnull i32* @g2()
 534 define internal i32* @g2() {
 535   ret i32* inttoptr (i64 4 to i32*)
 536 }
 537
 538 define  i32* @g1() {
 539  %c = call i32* @g2()
 540   ret i32* %c
 541 }
 542
 543 declare void @use_i32_ptr(i32*) readnone nounwind
 544 ; ATTRIBUTOR: define internal void @called_by_weak(i32* nocapture nonnull readnone %a)
 545 define internal void @called_by_weak(i32* %a) {
 546   call void @use_i32_ptr(i32* %a)
 547   ret void
 548 }
 549
 550 ; Check we do not annotate the function interface of this weak function.
 551 ; ATTRIBUTOR: define weak_odr void @weak_caller(i32* nonnull %a)
 552 define weak_odr void @weak_caller(i32* nonnull %a) {
 553   call void @called_by_weak(i32* %a)
 554   ret void
 555 }
 556
 557 ; Expect nonnull
 558 ; ATTRIBUTOR: define internal void @control(i32* nocapture nonnull readnone align 16 dereferenceable(8) %a)
 559 define internal void @control(i32* dereferenceable(4) %a) {
 560   call void @use_i32_ptr(i32* %a)
 561   ret void
 562 }
 563 ; Avoid nonnull as we do not touch naked functions
 564 ; ATTRIBUTOR: define internal void @naked(i32* dereferenceable(4) %a)
 565 define internal void @naked(i32* dereferenceable(4) %a) naked {
 566   call void @use_i32_ptr(i32* %a)
 567   ret void
 568 }
 569 ; Avoid nonnull as we do not touch optnone
 570 ; ATTRIBUTOR: define internal void @optnone(i32* dereferenceable(4) %a)
 571 define internal void @optnone(i32* dereferenceable(4) %a) optnone noinline {
 572   call void @use_i32_ptr(i32* %a)
 573   ret void
 574 }
 575 define void @make_live(i32* nonnull dereferenceable(8) %a) {
 576   call void @naked(i32* nonnull dereferenceable(8) align 16 %a)
 577   call void @control(i32* nonnull dereferenceable(8) align 16 %a)
 578   call void @optnone(i32* nonnull dereferenceable(8) align 16 %a)
 579   ret void
 580 }
 581
 582 attributes #0 = { "null-pointer-is-valid"="true" }
 583 attributes #1 = { nounwind willreturn}