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 5target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 6 7declare nonnull i8* @ret_nonnull() 8 9; Return a pointer trivially nonnull (call return attribute) 10define 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) 17define 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 24define 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 28rec: 29 call i8* @test3(i1 %c) 30 br label %end 31end: 32 ret i8* null 33} 34 35define 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.) 45define 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 52define 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. 61define 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 65rec: 66 %ret = call i8* @test5(i1 %c) 67 br label %end 68end: 69 ret i8* null 70} 71 72define 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 80define i8* @test6() { 81entry: 82; BOTH: define nonnull i8* @test6 83 %ret = call i8* @ret_nonnull() 84 br label %loop 85loop: 86 %phi = phi i8* [%ret, %entry], [%phi, %loop] 87 br i1 undef, label %loop, label %exit 88exit: 89 ret i8* %phi 90} 91 92; BOTH: define i8* @test7 93define 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 99define i8* @test8(i8* %a) { 100 %b = getelementptr inbounds i8, i8* %a, i64 1 101 ret i8* %b 102} 103 104; BOTH: define i8* @test9 105define i8* @test9(i8* %a, i64 %n) { 106 %b = getelementptr inbounds i8, i8* %a, i64 %n 107 ret i8* %b 108} 109 110declare void @llvm.assume(i1) 111; FNATTR: define i8* @test10 112; FIXME: missing nonnull 113; ATTRIBUTOR: define i8* @test10 114define 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 128define 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 143declare void @test12_helper(i8*) 144define 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 153declare i8* @unknown() 154define 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} 161define 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 166declare 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 180define 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 184bb: 185 %tmp = icmp eq i32* %arg, null 186 br i1 %tmp, label %bb9, label %bb1 187 188bb1: ; 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 193bb4: ; 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 199bb6: ; 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 205bb9: ; preds = %bb4, %bb 206 %tmp10 = phi i32* [ %tmp5, %bb4 ], [ inttoptr (i64 4 to i32*), %bb ] 207 ret i32* %tmp10 208} 209 210define 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) 213bb: 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 221define 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* readonly %arg) 224bb: 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 232define 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 239declare void @fun0() #1 240declare void @fun1(i8*) #1 241declare void @fun2(i8*, i8*) #1 242declare 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. 249define 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 254if.then: 255 tail call void @fun2(i8* nonnull %a, i8* nonnull %b) 256 ret void 257if.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 268define 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 273if.then: 274 tail call void @fun0() 275 br label %cont 276if.else: 277 tail call void @fun0() 278 br label %cont 279cont: 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 294define 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 299if.then: 300 tail call void @fun0() 301 br label %cont 302if.else: 303 tail call void @fun0() 304 br label %cont 305cont: 306 %cmp2 = icmp eq i8 %c, 1 307 br i1 %cmp2, label %cont.then, label %cont.else 308cont.then: 309 tail call void @fun1(i8* nonnull %b) 310 br label %cont2 311cont.else: 312 tail call void @fun0() 313 br label %cont2 314cont2: 315 tail call void @fun1(i8* nonnull %a) 316 ret void 317} 318 319; TEST 19: Loop 320 321define 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 325loop.header: 326 %cmp2 = icmp eq i8 %c, 0 327 br i1 %cmp2, label %loop.body, label %loop.exit 328loop.body: 329 tail call void @fun1(i8* nonnull %b) 330 tail call void @fun1(i8* nonnull %a) 331 br label %loop.header 332loop.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 339declare void @use1(i8* %x) 340declare void @use2(i8* %x, i8* %y); 341declare void @use3(i8* %x, i8* %y, i8* %z); 342 343declare void @use1nonnull(i8* nonnull %x); 344declare void @use2nonnull(i8* nonnull %x, i8* nonnull %y); 345declare void @use3nonnull(i8* nonnull %x, i8* nonnull %y, i8* nonnull %z); 346 347declare 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 351define 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 364define 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 381define 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 399define 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 422define 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 433t: 434 call void @use1nonnull(i8* %a) 435 ret void 436f: 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 443define 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 458define 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 477declare i32 @esfp(...) 478 479define 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 493entry: 494 invoke void @use2nonnull(i8* %a, i8* %b) 495 to label %cont unwind label %exc 496 497cont: 498 %null_check = icmp eq i8* %b, null 499 ret i1 %null_check 500 501exc: 502 %lp = landingpad { i8*, i32 } 503 filter [0 x i8*] zeroinitializer 504 unreachable 505} 506 507; BOTH: define nonnull i32* @gep1( 508define i32* @gep1(i32* %p) { 509 %q = getelementptr inbounds i32, i32* %p, i32 1 510 ret i32* %q 511} 512 513define 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( 521define 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) 529define 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() 534define internal i32* @g2() { 535 ret i32* inttoptr (i64 4 to i32*) 536} 537 538define i32* @g1() { 539 %c = call i32* @g2() 540 ret i32* %c 541} 542 543declare void @use_i32_ptr(i32*) readnone nounwind 544; ATTRIBUTOR: define internal void @called_by_weak(i32* nocapture nonnull readnone %a) 545define 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) 552define 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) 559define 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) 565define 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) 571define internal void @optnone(i32* dereferenceable(4) %a) optnone noinline { 572 call void @use_i32_ptr(i32* %a) 573 ret void 574} 575define 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 582attributes #0 = { "null-pointer-is-valid"="true" } 583attributes #1 = { nounwind willreturn} 584