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