1; RUN: opt < %s -default-data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basicaa -gvn -S -die | FileCheck %s 2; RUN: opt < %s -default-data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -basicaa -gvn -S -die | FileCheck %s 3 4;; Trivial RLE test. 5define i32 @test0(i32 %V, i32* %P) { 6 store i32 %V, i32* %P 7 8 %A = load i32, i32* %P 9 ret i32 %A 10; CHECK-LABEL: @test0( 11; CHECK: ret i32 %V 12} 13 14 15;;===----------------------------------------------------------------------===;; 16;; Tests for crashers 17;;===----------------------------------------------------------------------===;; 18 19;; PR5016 20define i8 @crash0({i32, i32} %A, {i32, i32}* %P) { 21 store {i32, i32} %A, {i32, i32}* %P 22 %X = bitcast {i32, i32}* %P to i8* 23 %Y = load i8, i8* %X 24 ret i8 %Y 25} 26 27;; No PR filed, crashed in CaptureTracker. 28declare void @helper() 29define void @crash1() { 30 tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* undef, i8* undef, i64 undef, i32 1, i1 false) nounwind 31 %tmp = load i8, i8* bitcast (void ()* @helper to i8*) 32 %x = icmp eq i8 %tmp, 15 33 ret void 34} 35 36 37;;===----------------------------------------------------------------------===;; 38;; Store -> Load and Load -> Load forwarding where src and dst are different 39;; types, but where the base pointer is a must alias. 40;;===----------------------------------------------------------------------===;; 41 42;; i32 -> f32 forwarding. 43define float @coerce_mustalias1(i32 %V, i32* %P) { 44 store i32 %V, i32* %P 45 46 %P2 = bitcast i32* %P to float* 47 48 %A = load float, float* %P2 49 ret float %A 50; CHECK-LABEL: @coerce_mustalias1( 51; CHECK-NOT: load 52; CHECK: ret float 53} 54 55;; i32* -> float forwarding. 56define float @coerce_mustalias2(i32* %V, i32** %P) { 57 store i32* %V, i32** %P 58 59 %P2 = bitcast i32** %P to float* 60 61 %A = load float, float* %P2 62 ret float %A 63; CHECK-LABEL: @coerce_mustalias2( 64; CHECK-NOT: load 65; CHECK: ret float 66} 67 68;; float -> i32* forwarding. 69define i32* @coerce_mustalias3(float %V, float* %P) { 70 store float %V, float* %P 71 72 %P2 = bitcast float* %P to i32** 73 74 %A = load i32*, i32** %P2 75 ret i32* %A 76; CHECK-LABEL: @coerce_mustalias3( 77; CHECK-NOT: load 78; CHECK: ret i32* 79} 80 81;; i32 -> f32 load forwarding. 82define float @coerce_mustalias4(i32* %P, i1 %cond) { 83 %A = load i32, i32* %P 84 85 %P2 = bitcast i32* %P to float* 86 %B = load float, float* %P2 87 br i1 %cond, label %T, label %F 88T: 89 ret float %B 90 91F: 92 %X = bitcast i32 %A to float 93 ret float %X 94 95; CHECK-LABEL: @coerce_mustalias4( 96; CHECK: %A = load i32, i32* %P 97; CHECK-NOT: load 98; CHECK: ret float 99; CHECK: F: 100} 101 102;; i32 -> i8 forwarding 103define i8 @coerce_mustalias5(i32 %V, i32* %P) { 104 store i32 %V, i32* %P 105 106 %P2 = bitcast i32* %P to i8* 107 108 %A = load i8, i8* %P2 109 ret i8 %A 110; CHECK-LABEL: @coerce_mustalias5( 111; CHECK-NOT: load 112; CHECK: ret i8 113} 114 115;; i64 -> float forwarding 116define float @coerce_mustalias6(i64 %V, i64* %P) { 117 store i64 %V, i64* %P 118 119 %P2 = bitcast i64* %P to float* 120 121 %A = load float, float* %P2 122 ret float %A 123; CHECK-LABEL: @coerce_mustalias6( 124; CHECK-NOT: load 125; CHECK: ret float 126} 127 128;; i64 -> i8* (32-bit) forwarding 129define i8* @coerce_mustalias7(i64 %V, i64* %P) { 130 store i64 %V, i64* %P 131 132 %P2 = bitcast i64* %P to i8** 133 134 %A = load i8*, i8** %P2 135 ret i8* %A 136; CHECK-LABEL: @coerce_mustalias7( 137; CHECK-NOT: load 138; CHECK: ret i8* 139} 140 141; memset -> i16 forwarding. 142define signext i16 @memset_to_i16_local(i16* %A) nounwind ssp { 143entry: 144 %conv = bitcast i16* %A to i8* 145 tail call void @llvm.memset.p0i8.i64(i8* %conv, i8 1, i64 200, i32 1, i1 false) 146 %arrayidx = getelementptr inbounds i16, i16* %A, i64 42 147 %tmp2 = load i16, i16* %arrayidx 148 ret i16 %tmp2 149; CHECK-LABEL: @memset_to_i16_local( 150; CHECK-NOT: load 151; CHECK: ret i16 257 152} 153 154; memset -> float forwarding. 155define float @memset_to_float_local(float* %A, i8 %Val) nounwind ssp { 156entry: 157 %conv = bitcast float* %A to i8* ; <i8*> [#uses=1] 158 tail call void @llvm.memset.p0i8.i64(i8* %conv, i8 %Val, i64 400, i32 1, i1 false) 159 %arrayidx = getelementptr inbounds float, float* %A, i64 42 ; <float*> [#uses=1] 160 %tmp2 = load float, float* %arrayidx ; <float> [#uses=1] 161 ret float %tmp2 162; CHECK-LABEL: @memset_to_float_local( 163; CHECK-NOT: load 164; CHECK: zext 165; CHECK-NEXT: shl 166; CHECK-NEXT: or 167; CHECK-NEXT: shl 168; CHECK-NEXT: or 169; CHECK-NEXT: bitcast 170; CHECK-NEXT: ret float 171} 172 173;; non-local memset -> i16 load forwarding. 174define i16 @memset_to_i16_nonlocal0(i16* %P, i1 %cond) { 175 %P3 = bitcast i16* %P to i8* 176 br i1 %cond, label %T, label %F 177T: 178 tail call void @llvm.memset.p0i8.i64(i8* %P3, i8 1, i64 400, i32 1, i1 false) 179 br label %Cont 180 181F: 182 tail call void @llvm.memset.p0i8.i64(i8* %P3, i8 2, i64 400, i32 1, i1 false) 183 br label %Cont 184 185Cont: 186 %P2 = getelementptr i16, i16* %P, i32 4 187 %A = load i16, i16* %P2 188 ret i16 %A 189 190; CHECK-LABEL: @memset_to_i16_nonlocal0( 191; CHECK: Cont: 192; CHECK-NEXT: %A = phi i16 [ 514, %F ], [ 257, %T ] 193; CHECK-NOT: load 194; CHECK: ret i16 %A 195} 196 197@GCst = constant {i32, float, i32 } { i32 42, float 14., i32 97 } 198@GCst_as1 = addrspace(1) constant {i32, float, i32 } { i32 42, float 14., i32 97 } 199 200; memset -> float forwarding. 201define float @memcpy_to_float_local(float* %A) nounwind ssp { 202entry: 203 %conv = bitcast float* %A to i8* ; <i8*> [#uses=1] 204 tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %conv, i8* bitcast ({i32, float, i32 }* @GCst to i8*), i64 12, i32 1, i1 false) 205 %arrayidx = getelementptr inbounds float, float* %A, i64 1 ; <float*> [#uses=1] 206 %tmp2 = load float, float* %arrayidx ; <float> [#uses=1] 207 ret float %tmp2 208; CHECK-LABEL: @memcpy_to_float_local( 209; CHECK-NOT: load 210; CHECK: ret float 1.400000e+01 211} 212 213; memcpy from address space 1 214define float @memcpy_to_float_local_as1(float* %A) nounwind ssp { 215entry: 216 %conv = bitcast float* %A to i8* ; <i8*> [#uses=1] 217 tail call void @llvm.memcpy.p0i8.p1i8.i64(i8* %conv, i8 addrspace(1)* bitcast ({i32, float, i32 } addrspace(1)* @GCst_as1 to i8 addrspace(1)*), i64 12, i32 1, i1 false) 218 %arrayidx = getelementptr inbounds float, float* %A, i64 1 ; <float*> [#uses=1] 219 %tmp2 = load float, float* %arrayidx ; <float> [#uses=1] 220 ret float %tmp2 221; CHECK-LABEL: @memcpy_to_float_local_as1( 222; CHECK-NOT: load 223; CHECK: ret float 1.400000e+01 224} 225 226;; non-local i32/float -> i8 load forwarding. 227define i8 @coerce_mustalias_nonlocal0(i32* %P, i1 %cond) { 228 %P2 = bitcast i32* %P to float* 229 %P3 = bitcast i32* %P to i8* 230 br i1 %cond, label %T, label %F 231T: 232 store i32 42, i32* %P 233 br label %Cont 234 235F: 236 store float 1.0, float* %P2 237 br label %Cont 238 239Cont: 240 %A = load i8, i8* %P3 241 ret i8 %A 242 243; CHECK-LABEL: @coerce_mustalias_nonlocal0( 244; CHECK: Cont: 245; CHECK: %A = phi i8 [ 246; CHECK-NOT: load 247; CHECK: ret i8 %A 248} 249 250 251;; non-local i32/float -> i8 load forwarding. This also tests that the "P3" 252;; bitcast equivalence can be properly phi translated. 253define i8 @coerce_mustalias_nonlocal1(i32* %P, i1 %cond) { 254 %P2 = bitcast i32* %P to float* 255 br i1 %cond, label %T, label %F 256T: 257 store i32 42, i32* %P 258 br label %Cont 259 260F: 261 store float 1.0, float* %P2 262 br label %Cont 263 264Cont: 265 %P3 = bitcast i32* %P to i8* 266 %A = load i8, i8* %P3 267 ret i8 %A 268 269; CHECK-LABEL: @coerce_mustalias_nonlocal1( 270; CHECK: Cont: 271; CHECK: %A = phi i8 [ 272; CHECK-NOT: load 273; CHECK: ret i8 %A 274} 275 276 277;; non-local i32 -> i8 partial redundancy load forwarding. 278define i8 @coerce_mustalias_pre0(i32* %P, i1 %cond) { 279 %P3 = bitcast i32* %P to i8* 280 br i1 %cond, label %T, label %F 281T: 282 store i32 42, i32* %P 283 br label %Cont 284 285F: 286 br label %Cont 287 288Cont: 289 %A = load i8, i8* %P3 290 ret i8 %A 291 292; CHECK-LABEL: @coerce_mustalias_pre0( 293; CHECK: F: 294; CHECK: load i8, i8* %P3 295; CHECK: Cont: 296; CHECK: %A = phi i8 [ 297; CHECK-NOT: load 298; CHECK: ret i8 %A 299} 300 301;;===----------------------------------------------------------------------===;; 302;; Store -> Load and Load -> Load forwarding where src and dst are different 303;; types, and the reload is an offset from the store pointer. 304;;===----------------------------------------------------------------------===;; 305 306;; i32 -> i8 forwarding. 307;; PR4216 308define i8 @coerce_offset0(i32 %V, i32* %P) { 309 store i32 %V, i32* %P 310 311 %P2 = bitcast i32* %P to i8* 312 %P3 = getelementptr i8, i8* %P2, i32 2 313 314 %A = load i8, i8* %P3 315 ret i8 %A 316; CHECK-LABEL: @coerce_offset0( 317; CHECK-NOT: load 318; CHECK: ret i8 319} 320 321define i8 @coerce_offset0_addrspacecast(i32 %V, i32* %P) { 322 store i32 %V, i32* %P 323 324 %P2 = addrspacecast i32* %P to i8 addrspace(1)* 325 %P3 = getelementptr i8, i8 addrspace(1)* %P2, i32 2 326 327 %A = load i8, i8 addrspace(1)* %P3 328 ret i8 %A 329; CHECK-LABEL: @coerce_offset0_addrspacecast( 330; CHECK-NOT: load 331; CHECK: ret i8 332} 333 334;; non-local i32/float -> i8 load forwarding. 335define i8 @coerce_offset_nonlocal0(i32* %P, i1 %cond) { 336 %P2 = bitcast i32* %P to float* 337 %P3 = bitcast i32* %P to i8* 338 %P4 = getelementptr i8, i8* %P3, i32 2 339 br i1 %cond, label %T, label %F 340T: 341 store i32 57005, i32* %P 342 br label %Cont 343 344F: 345 store float 1.0, float* %P2 346 br label %Cont 347 348Cont: 349 %A = load i8, i8* %P4 350 ret i8 %A 351 352; CHECK-LABEL: @coerce_offset_nonlocal0( 353; CHECK: Cont: 354; CHECK: %A = phi i8 [ 355; CHECK-NOT: load 356; CHECK: ret i8 %A 357} 358 359 360;; non-local i32 -> i8 partial redundancy load forwarding. 361define i8 @coerce_offset_pre0(i32* %P, i1 %cond) { 362 %P3 = bitcast i32* %P to i8* 363 %P4 = getelementptr i8, i8* %P3, i32 2 364 br i1 %cond, label %T, label %F 365T: 366 store i32 42, i32* %P 367 br label %Cont 368 369F: 370 br label %Cont 371 372Cont: 373 %A = load i8, i8* %P4 374 ret i8 %A 375 376; CHECK-LABEL: @coerce_offset_pre0( 377; CHECK: F: 378; CHECK: load i8, i8* %P4 379; CHECK: Cont: 380; CHECK: %A = phi i8 [ 381; CHECK-NOT: load 382; CHECK: ret i8 %A 383} 384 385define i32 @chained_load(i32** %p, i32 %x, i32 %y) { 386block1: 387 %A = alloca i32* 388 389 %z = load i32*, i32** %p 390 store i32* %z, i32** %A 391 %cmp = icmp eq i32 %x, %y 392 br i1 %cmp, label %block2, label %block3 393 394block2: 395 %a = load i32*, i32** %p 396 br label %block4 397 398block3: 399 %b = load i32*, i32** %p 400 br label %block4 401 402block4: 403 %c = load i32*, i32** %p 404 %d = load i32, i32* %c 405 ret i32 %d 406 407; CHECK-LABEL: @chained_load( 408; CHECK: %z = load i32*, i32** %p 409; CHECK-NOT: load 410; CHECK: %d = load i32, i32* %z 411; CHECK-NEXT: ret i32 %d 412} 413 414 415declare i1 @cond() readonly 416declare i1 @cond2() readonly 417 418define i32 @phi_trans2() { 419; CHECK-LABEL: @phi_trans2( 420entry: 421 %P = alloca i32, i32 400 422 br label %F1 423 424F1: 425 %A = phi i32 [1, %entry], [2, %F] 426 %cond2 = call i1 @cond() 427 br i1 %cond2, label %T1, label %TY 428 429T1: 430 %P2 = getelementptr i32, i32* %P, i32 %A 431 %x = load i32, i32* %P2 432 %cond = call i1 @cond2() 433 br i1 %cond, label %TX, label %F 434 435F: 436 %P3 = getelementptr i32, i32* %P, i32 2 437 store i32 17, i32* %P3 438 439 store i32 42, i32* %P2 ; Provides "P[A]". 440 br label %F1 441 442TX: 443 ; This load should not be compiled to 'ret i32 42'. An overly clever 444 ; implementation of GVN would see that we're returning 17 if the loop 445 ; executes once or 42 if it executes more than that, but we'd have to do 446 ; loop restructuring to expose this, and GVN shouldn't do this sort of CFG 447 ; transformation. 448 449; CHECK: TX: 450; CHECK: ret i32 %x 451 ret i32 %x 452TY: 453 ret i32 0 454} 455 456define i32 @phi_trans3(i32* %p, i32 %x, i32 %y, i32 %z) { 457; CHECK-LABEL: @phi_trans3( 458block1: 459 %cmpxy = icmp eq i32 %x, %y 460 br i1 %cmpxy, label %block2, label %block3 461 462block2: 463 store i32 87, i32* %p 464 br label %block4 465 466block3: 467 %p2 = getelementptr i32, i32* %p, i32 43 468 store i32 97, i32* %p2 469 br label %block4 470 471block4: 472 %A = phi i32 [-1, %block2], [42, %block3] 473 br i1 %cmpxy, label %block5, label %exit 474 475; CHECK: block4: 476; CHECK-NEXT: %D = phi i32 [ 87, %block2 ], [ 97, %block3 ] 477; CHECK-NOT: load 478 479block5: 480 %B = add i32 %A, 1 481 br i1 %cmpxy, label %block6, label %exit 482 483block6: 484 %C = getelementptr i32, i32* %p, i32 %B 485 br i1 %cmpxy, label %block7, label %exit 486 487block7: 488 %D = load i32, i32* %C 489 ret i32 %D 490 491; CHECK: block7: 492; CHECK-NEXT: ret i32 %D 493 494exit: 495 ret i32 -1 496} 497 498define i8 @phi_trans4(i8* %p) { 499; CHECK-LABEL: @phi_trans4( 500entry: 501 %X3 = getelementptr i8, i8* %p, i32 192 502 store i8 192, i8* %X3 503 504 %X = getelementptr i8, i8* %p, i32 4 505 %Y = load i8, i8* %X 506 br label %loop 507 508loop: 509 %i = phi i32 [4, %entry], [192, %loop] 510 %X2 = getelementptr i8, i8* %p, i32 %i 511 %Y2 = load i8, i8* %X2 512 513; CHECK: loop: 514; CHECK-NEXT: %Y2 = phi i8 [ %Y, %entry ], [ 0, %loop ] 515; CHECK-NOT: load i8 516 517 %cond = call i1 @cond2() 518 519 %Z = bitcast i8 *%X3 to i32* 520 store i32 0, i32* %Z 521 br i1 %cond, label %loop, label %out 522 523out: 524 %R = add i8 %Y, %Y2 525 ret i8 %R 526} 527 528define i8 @phi_trans5(i8* %p) { 529; CHECK-LABEL: @phi_trans5( 530entry: 531 532 %X4 = getelementptr i8, i8* %p, i32 2 533 store i8 19, i8* %X4 534 535 %X = getelementptr i8, i8* %p, i32 4 536 %Y = load i8, i8* %X 537 br label %loop 538 539loop: 540 %i = phi i32 [4, %entry], [3, %cont] 541 %X2 = getelementptr i8, i8* %p, i32 %i 542 %Y2 = load i8, i8* %X2 ; Ensure this load is not being incorrectly replaced. 543 %cond = call i1 @cond2() 544 br i1 %cond, label %cont, label %out 545 546cont: 547 %Z = getelementptr i8, i8* %X2, i32 -1 548 %Z2 = bitcast i8 *%Z to i32* 549 store i32 50462976, i32* %Z2 ;; (1 << 8) | (2 << 16) | (3 << 24) 550 551 552; CHECK: store i32 553; CHECK-NEXT: getelementptr i8, i8* %p, i32 3 554; CHECK-NEXT: load i8, i8* 555 br label %loop 556 557out: 558 %R = add i8 %Y, %Y2 559 ret i8 %R 560} 561 562 563; PR6642 564define i32 @memset_to_load() nounwind readnone { 565entry: 566 %x = alloca [256 x i32], align 4 ; <[256 x i32]*> [#uses=2] 567 %tmp = bitcast [256 x i32]* %x to i8* ; <i8*> [#uses=1] 568 call void @llvm.memset.p0i8.i64(i8* %tmp, i8 0, i64 1024, i32 4, i1 false) 569 %arraydecay = getelementptr inbounds [256 x i32], [256 x i32]* %x, i32 0, i32 0 ; <i32*> 570 %tmp1 = load i32, i32* %arraydecay ; <i32> [#uses=1] 571 ret i32 %tmp1 572; CHECK-LABEL: @memset_to_load( 573; CHECK: ret i32 0 574} 575 576 577;;===----------------------------------------------------------------------===;; 578;; Load -> Load forwarding in partial alias case. 579;;===----------------------------------------------------------------------===;; 580 581define i32 @load_load_partial_alias(i8* %P) nounwind ssp { 582entry: 583 %0 = bitcast i8* %P to i32* 584 %tmp2 = load i32, i32* %0 585 %add.ptr = getelementptr inbounds i8, i8* %P, i64 1 586 %tmp5 = load i8, i8* %add.ptr 587 %conv = zext i8 %tmp5 to i32 588 %add = add nsw i32 %tmp2, %conv 589 ret i32 %add 590 591; TEMPORARILYDISABLED-LABEL: @load_load_partial_alias( 592; TEMPORARILYDISABLED: load i32, i32* 593; TEMPORARILYDISABLED-NOT: load 594; TEMPORARILYDISABLED: lshr i32 {{.*}}, 8 595; TEMPORARILYDISABLED-NOT: load 596; TEMPORARILYDISABLED: trunc i32 {{.*}} to i8 597; TEMPORARILYDISABLED-NOT: load 598; TEMPORARILYDISABLED: ret i32 599} 600 601 602; Cross block partial alias case. 603define i32 @load_load_partial_alias_cross_block(i8* %P) nounwind ssp { 604entry: 605 %xx = bitcast i8* %P to i32* 606 %x1 = load i32, i32* %xx, align 4 607 %cmp = icmp eq i32 %x1, 127 608 br i1 %cmp, label %land.lhs.true, label %if.end 609 610land.lhs.true: ; preds = %entry 611 %arrayidx4 = getelementptr inbounds i8, i8* %P, i64 1 612 %tmp5 = load i8, i8* %arrayidx4, align 1 613 %conv6 = zext i8 %tmp5 to i32 614 ret i32 %conv6 615 616if.end: 617 ret i32 52 618; TEMPORARILY_DISABLED-LABEL: @load_load_partial_alias_cross_block( 619; TEMPORARILY_DISABLED: land.lhs.true: 620; TEMPORARILY_DISABLED-NOT: load i8 621; TEMPORARILY_DISABLED: ret i32 %conv6 622} 623 624 625;;===----------------------------------------------------------------------===;; 626;; Load Widening 627;;===----------------------------------------------------------------------===;; 628 629%widening1 = type { i32, i8, i8, i8, i8 } 630 631@f = global %widening1 zeroinitializer, align 4 632 633define i32 @test_widening1(i8* %P) nounwind ssp noredzone { 634entry: 635 %tmp = load i8, i8* getelementptr inbounds (%widening1, %widening1* @f, i64 0, i32 1), align 4 636 %conv = zext i8 %tmp to i32 637 %tmp1 = load i8, i8* getelementptr inbounds (%widening1, %widening1* @f, i64 0, i32 2), align 1 638 %conv2 = zext i8 %tmp1 to i32 639 %add = add nsw i32 %conv, %conv2 640 ret i32 %add 641; CHECK-LABEL: @test_widening1( 642; CHECK-NOT: load 643; CHECK: load i16, i16* 644; CHECK-NOT: load 645; CHECK: ret i32 646} 647 648define i32 @test_widening2() nounwind ssp noredzone { 649entry: 650 %tmp = load i8, i8* getelementptr inbounds (%widening1, %widening1* @f, i64 0, i32 1), align 4 651 %conv = zext i8 %tmp to i32 652 %tmp1 = load i8, i8* getelementptr inbounds (%widening1, %widening1* @f, i64 0, i32 2), align 1 653 %conv2 = zext i8 %tmp1 to i32 654 %add = add nsw i32 %conv, %conv2 655 656 %tmp2 = load i8, i8* getelementptr inbounds (%widening1, %widening1* @f, i64 0, i32 3), align 2 657 %conv3 = zext i8 %tmp2 to i32 658 %add2 = add nsw i32 %add, %conv3 659 660 %tmp3 = load i8, i8* getelementptr inbounds (%widening1, %widening1* @f, i64 0, i32 4), align 1 661 %conv4 = zext i8 %tmp3 to i32 662 %add3 = add nsw i32 %add2, %conv3 663 664 ret i32 %add3 665; CHECK-LABEL: @test_widening2( 666; CHECK-NOT: load 667; CHECK: load i32, i32* 668; CHECK-NOT: load 669; CHECK: ret i32 670} 671 672declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind 673 674declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind 675declare void @llvm.memcpy.p0i8.p1i8.i64(i8* nocapture, i8 addrspace(1)* nocapture, i64, i32, i1) nounwind 676 677 678;;===----------------------------------------------------------------------===;; 679;; Load -> Store dependency which isn't interfered with by a call that happens 680;; before the pointer was captured. 681;;===----------------------------------------------------------------------===;; 682 683%class.X = type { [8 x i8] } 684 685@_ZTV1X = weak_odr constant [5 x i8*] zeroinitializer 686@_ZTV1Y = weak_odr constant [5 x i8*] zeroinitializer 687 688declare void @use() 689declare void @use3(i8***, i8**) 690 691; PR8908 692define void @test_escape1() nounwind { 693 %x = alloca i8**, align 8 694 store i8** getelementptr inbounds ([5 x i8*], [5 x i8*]* @_ZTV1X, i64 0, i64 2), i8*** %x, align 8 695 call void @use() nounwind 696 %DEAD = load i8**, i8*** %x, align 8 697 call void @use3(i8*** %x, i8** %DEAD) nounwind 698 ret void 699; CHECK: test_escape1 700; CHECK-NOT: DEAD 701; CHECK: ret 702} 703