xref: /llvm-project/llvm/test/Analysis/LoopAccessAnalysis/invariant-dependence-before.ll (revision 8fe7860610e3ff699831e11e4d57e38a198c40e8) 
1; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 3
2; RUN: opt -passes='print<access-info>' -disable-output %s 2>&1 | FileCheck %s
3
4define void @test_invar_dependence_before_positive_strided_access_1(ptr %a) {
5; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_1'
6; CHECK-NEXT:    loop:
7; CHECK-NEXT:      Memory dependences are safe
8; CHECK-NEXT:      Dependences:
9; CHECK-NEXT:      Run-time memory checks:
10; CHECK-NEXT:      Grouped accesses:
11; CHECK-EMPTY:
12; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
13; CHECK-NEXT:      SCEV assumptions:
14; CHECK-EMPTY:
15; CHECK-NEXT:      Expressions re-written:
16;
17entry:
18  %gep.off = getelementptr i8, ptr %a, i32 4
19  br label %loop
20
21loop:
22  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
23  %gep = getelementptr i32, ptr %gep.off, i32 %iv
24  %l = load i32, ptr %a
25  store i32 %l, ptr %gep
26  %iv.next = add i32 %iv, 1
27  %ec = icmp eq i32 %iv.next, 100
28  br i1 %ec, label %exit, label %loop
29
30exit:
31  ret void
32}
33
34define void @test_invar_dependence_before_positive_strided_access_2(ptr %a) {
35; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_2'
36; CHECK-NEXT:    loop:
37; CHECK-NEXT:      Memory dependences are safe
38; CHECK-NEXT:      Dependences:
39; CHECK-NEXT:      Run-time memory checks:
40; CHECK-NEXT:      Grouped accesses:
41; CHECK-EMPTY:
42; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
43; CHECK-NEXT:      SCEV assumptions:
44; CHECK-EMPTY:
45; CHECK-NEXT:      Expressions re-written:
46;
47entry:
48  %gep.off = getelementptr i8, ptr %a, i32 4
49  br label %loop
50
51loop:
52  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
53  %gep = getelementptr i32, ptr %gep.off, i32 %iv
54  %l = load i32, ptr %gep
55  store i32 %l, ptr %a
56  %iv.next = add i32 %iv, 1
57  %ec = icmp eq i32 %iv.next, 100
58  br i1 %ec, label %exit, label %loop
59
60exit:
61  ret void
62}
63
64define void @test_invar_dependence_not_before_positive_strided_access_1(ptr %a) {
65; CHECK-LABEL: 'test_invar_dependence_not_before_positive_strided_access_1'
66; CHECK-NEXT:    loop:
67; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
68; CHECK-NEXT:  Unknown data dependence.
69; CHECK-NEXT:      Dependences:
70; CHECK-NEXT:        Unknown:
71; CHECK-NEXT:            %l = load i32, ptr %a, align 4 ->
72; CHECK-NEXT:            store i32 %l, ptr %gep, align 4
73; CHECK-EMPTY:
74; CHECK-NEXT:      Run-time memory checks:
75; CHECK-NEXT:      Grouped accesses:
76; CHECK-EMPTY:
77; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
78; CHECK-NEXT:      SCEV assumptions:
79; CHECK-EMPTY:
80; CHECK-NEXT:      Expressions re-written:
81;
82entry:
83  %gep.off = getelementptr i8, ptr %a, i32 3
84  br label %loop
85
86loop:
87  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
88  %gep = getelementptr i32, ptr %gep.off, i32 %iv
89  %l = load i32, ptr %a
90  store i32 %l, ptr %gep
91  %iv.next = add i32 %iv, 1
92  %ec = icmp eq i32 %iv.next, 100
93  br i1 %ec, label %exit, label %loop
94
95exit:
96  ret void
97}
98
99define void @test_invar_dependence_not_before_positive_strided_access_2(ptr %a) {
100; CHECK-LABEL: 'test_invar_dependence_not_before_positive_strided_access_2'
101; CHECK-NEXT:    loop:
102; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
103; CHECK-NEXT:  Unknown data dependence.
104; CHECK-NEXT:      Dependences:
105; CHECK-NEXT:        Unknown:
106; CHECK-NEXT:            %l = load i32, ptr %gep, align 4 ->
107; CHECK-NEXT:            store i32 %l, ptr %a, align 4
108; CHECK-EMPTY:
109; CHECK-NEXT:      Run-time memory checks:
110; CHECK-NEXT:      Grouped accesses:
111; CHECK-EMPTY:
112; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
113; CHECK-NEXT:      SCEV assumptions:
114; CHECK-EMPTY:
115; CHECK-NEXT:      Expressions re-written:
116;
117entry:
118  %gep.off = getelementptr i8, ptr %a, i32 3
119  br label %loop
120
121loop:
122  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
123  %gep = getelementptr i32, ptr %gep.off, i32 %iv
124  %l = load i32, ptr %gep
125  store i32 %l, ptr %a
126  %iv.next = add i32 %iv, 1
127  %ec = icmp eq i32 %iv.next, 100
128  br i1 %ec, label %exit, label %loop
129
130exit:
131  ret void
132}
133
134define void @test_invar_dependence_before_positive_strided_access_1_different_access_sizes(ptr %a) {
135; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_1_different_access_sizes'
136; CHECK-NEXT:    loop:
137; CHECK-NEXT:      Memory dependences are safe
138; CHECK-NEXT:      Dependences:
139; CHECK-NEXT:      Run-time memory checks:
140; CHECK-NEXT:      Grouped accesses:
141; CHECK-EMPTY:
142; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
143; CHECK-NEXT:      SCEV assumptions:
144; CHECK-EMPTY:
145; CHECK-NEXT:      Expressions re-written:
146;
147entry:
148  %gep.off = getelementptr i8, ptr %a, i32 4
149  br label %loop
150
151loop:
152  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
153  %gep = getelementptr i32, ptr %gep.off, i32 %iv
154  %l = load i32, ptr %a
155  %t = trunc i32 %l to i8
156  store i8 %t, ptr %gep
157  %iv.next = add i32 %iv, 1
158  %ec = icmp eq i32 %iv.next, 100
159  br i1 %ec, label %exit, label %loop
160
161exit:
162  ret void
163}
164
165define void @test_invar_dependence_not_before_positive_strided_access_1_different_access_sizes(ptr %a) {
166; CHECK-LABEL: 'test_invar_dependence_not_before_positive_strided_access_1_different_access_sizes'
167; CHECK-NEXT:    loop:
168; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
169; CHECK-NEXT:  Unknown data dependence.
170; CHECK-NEXT:      Dependences:
171; CHECK-NEXT:        Unknown:
172; CHECK-NEXT:            %l = load i64, ptr %a, align 4 ->
173; CHECK-NEXT:            store i32 %t, ptr %gep, align 4
174; CHECK-EMPTY:
175; CHECK-NEXT:      Run-time memory checks:
176; CHECK-NEXT:      Grouped accesses:
177; CHECK-EMPTY:
178; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
179; CHECK-NEXT:      SCEV assumptions:
180; CHECK-EMPTY:
181; CHECK-NEXT:      Expressions re-written:
182;
183entry:
184  %gep.off = getelementptr i8, ptr %a, i32 4
185  br label %loop
186
187loop:
188  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
189  %gep = getelementptr i32, ptr %gep.off, i32 %iv
190  %l = load i64, ptr %a
191  %t = trunc i64 %l to i32
192  store i32 %t, ptr %gep
193  %iv.next = add i32 %iv, 1
194  %ec = icmp eq i32 %iv.next, 100
195  br i1 %ec, label %exit, label %loop
196
197exit:
198  ret void
199}
200
201define void @test_invar_dependence_before_negative_strided_access_1(ptr %a) {
202; CHECK-LABEL: 'test_invar_dependence_before_negative_strided_access_1'
203; CHECK-NEXT:    loop:
204; CHECK-NEXT:      Memory dependences are safe
205; CHECK-NEXT:      Dependences:
206; CHECK-NEXT:      Run-time memory checks:
207; CHECK-NEXT:      Grouped accesses:
208; CHECK-EMPTY:
209; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
210; CHECK-NEXT:      SCEV assumptions:
211; CHECK-EMPTY:
212; CHECK-NEXT:      Expressions re-written:
213;
214entry:
215  %gep.off = getelementptr i32, ptr %a, i32 100
216  br label %loop
217
218loop:
219  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
220  %gep = getelementptr i32, ptr %gep.off, i32 %iv
221  %l = load i32, ptr %a
222  store i32 %l, ptr %gep
223  %iv.next = sub i32 %iv, 1
224  %ec = icmp eq i32 %iv.next, -100
225  br i1 %ec, label %exit, label %loop
226
227exit:
228  ret void
229}
230
231define void @test_invar_dependence_before_negative_strided_access_2(ptr %a) {
232; CHECK-LABEL: 'test_invar_dependence_before_negative_strided_access_2'
233; CHECK-NEXT:    loop:
234; CHECK-NEXT:      Memory dependences are safe
235; CHECK-NEXT:      Dependences:
236; CHECK-NEXT:      Run-time memory checks:
237; CHECK-NEXT:      Grouped accesses:
238; CHECK-EMPTY:
239; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
240; CHECK-NEXT:      SCEV assumptions:
241; CHECK-EMPTY:
242; CHECK-NEXT:      Expressions re-written:
243;
244entry:
245  %gep.off = getelementptr i32, ptr %a, i32 100
246  br label %loop
247
248loop:
249  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
250  %gep = getelementptr i32, ptr %gep.off, i32 %iv
251  %l = load i32, ptr %gep
252  store i32 %l, ptr %a
253  %iv.next = sub i32 %iv, 1
254  %ec = icmp eq i32 %iv.next, -100
255  br i1 %ec, label %exit, label %loop
256
257exit:
258  ret void
259}
260
261
262define void @test_invar_dependence_not_before_negative_strided_access_1(ptr %a) {
263; CHECK-LABEL: 'test_invar_dependence_not_before_negative_strided_access_1'
264; CHECK-NEXT:    loop:
265; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
266; CHECK-NEXT:  Unknown data dependence.
267; CHECK-NEXT:      Dependences:
268; CHECK-NEXT:        Unknown:
269; CHECK-NEXT:            %l = load i32, ptr %a, align 4 ->
270; CHECK-NEXT:            store i32 %l, ptr %gep, align 4
271; CHECK-EMPTY:
272; CHECK-NEXT:      Run-time memory checks:
273; CHECK-NEXT:      Grouped accesses:
274; CHECK-EMPTY:
275; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
276; CHECK-NEXT:      SCEV assumptions:
277; CHECK-EMPTY:
278; CHECK-NEXT:      Expressions re-written:
279;
280entry:
281  %gep.off = getelementptr i32, ptr %a, i32 99
282  br label %loop
283
284loop:
285  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
286  %gep = getelementptr i32, ptr %gep.off, i32 %iv
287  %l = load i32, ptr %a
288  store i32 %l, ptr %gep
289  %iv.next = sub i32 %iv, 1
290  %ec = icmp eq i32 %iv.next, -100
291  br i1 %ec, label %exit, label %loop
292
293exit:
294  ret void
295}
296
297define void @test_invar_dependence_not_before_negative_strided_access_2(ptr %a) {
298; CHECK-LABEL: 'test_invar_dependence_not_before_negative_strided_access_2'
299; CHECK-NEXT:    loop:
300; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
301; CHECK-NEXT:  Unknown data dependence.
302; CHECK-NEXT:      Dependences:
303; CHECK-NEXT:        Unknown:
304; CHECK-NEXT:            %l = load i32, ptr %gep, align 4 ->
305; CHECK-NEXT:            store i32 %l, ptr %a, align 4
306; CHECK-EMPTY:
307; CHECK-NEXT:      Run-time memory checks:
308; CHECK-NEXT:      Grouped accesses:
309; CHECK-EMPTY:
310; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
311; CHECK-NEXT:      SCEV assumptions:
312; CHECK-EMPTY:
313; CHECK-NEXT:      Expressions re-written:
314;
315entry:
316  %gep.off = getelementptr i32, ptr %a, i32 99
317  br label %loop
318
319loop:
320  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
321  %gep = getelementptr i32, ptr %gep.off, i32 %iv
322  %l = load i32, ptr %gep
323  store i32 %l, ptr %a
324  %iv.next = sub i32 %iv, 1
325  %ec = icmp eq i32 %iv.next, -100
326  br i1 %ec, label %exit, label %loop
327
328exit:
329  ret void
330}
331
332define void @test_both_invar_before_1(ptr %a) {
333; CHECK-LABEL: 'test_both_invar_before_1'
334; CHECK-NEXT:    loop:
335; CHECK-NEXT:      Memory dependences are safe
336; CHECK-NEXT:      Dependences:
337; CHECK-NEXT:      Run-time memory checks:
338; CHECK-NEXT:      Grouped accesses:
339; CHECK-EMPTY:
340; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
341; CHECK-NEXT:      SCEV assumptions:
342; CHECK-EMPTY:
343; CHECK-NEXT:      Expressions re-written:
344;
345entry:
346  %gep.off = getelementptr i8, ptr %a, i32 4
347  br label %loop
348
349loop:
350  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
351  %l = load i32, ptr %a
352  store i32 %l, ptr %gep.off
353  %iv.next = add i32 %iv, 1
354  %ec = icmp eq i32 %iv.next, 100
355  br i1 %ec, label %exit, label %loop
356
357exit:
358  ret void
359}
360
361define void @test_both_invar_before_2(ptr %a) {
362; CHECK-LABEL: 'test_both_invar_before_2'
363; CHECK-NEXT:    loop:
364; CHECK-NEXT:      Memory dependences are safe
365; CHECK-NEXT:      Dependences:
366; CHECK-NEXT:      Run-time memory checks:
367; CHECK-NEXT:      Grouped accesses:
368; CHECK-EMPTY:
369; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
370; CHECK-NEXT:      SCEV assumptions:
371; CHECK-EMPTY:
372; CHECK-NEXT:      Expressions re-written:
373;
374entry:
375  %gep.off = getelementptr i8, ptr %a, i32 4
376  br label %loop
377
378loop:
379  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
380  %l = load i32, ptr %gep.off
381  store i32 %l, ptr %a
382  %iv.next = add i32 %iv, 1
383  %ec = icmp eq i32 %iv.next, 100
384  br i1 %ec, label %exit, label %loop
385
386exit:
387  ret void
388}
389
390define void @test_both_invar_not_before_1(ptr %a) {
391; CHECK-LABEL: 'test_both_invar_not_before_1'
392; CHECK-NEXT:    loop:
393; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
394; CHECK-NEXT:  Unknown data dependence.
395; CHECK-NEXT:      Dependences:
396; CHECK-NEXT:        Unknown:
397; CHECK-NEXT:            %l = load i32, ptr %a, align 4 ->
398; CHECK-NEXT:            store i32 %l, ptr %gep.off, align 4
399; CHECK-EMPTY:
400; CHECK-NEXT:      Run-time memory checks:
401; CHECK-NEXT:      Grouped accesses:
402; CHECK-EMPTY:
403; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
404; CHECK-NEXT:      SCEV assumptions:
405; CHECK-EMPTY:
406; CHECK-NEXT:      Expressions re-written:
407;
408entry:
409  %gep.off = getelementptr i8, ptr %a, i32 3
410  br label %loop
411
412loop:
413  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
414  %l = load i32, ptr %a
415  store i32 %l, ptr %gep.off
416  %iv.next = add i32 %iv, 1
417  %ec = icmp eq i32 %iv.next, 100
418  br i1 %ec, label %exit, label %loop
419
420exit:
421  ret void
422}
423
424define void @test_both_invar_not_before_2(ptr %a) {
425; CHECK-LABEL: 'test_both_invar_not_before_2'
426; CHECK-NEXT:    loop:
427; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
428; CHECK-NEXT:  Unknown data dependence.
429; CHECK-NEXT:      Dependences:
430; CHECK-NEXT:        Unknown:
431; CHECK-NEXT:            %l = load i32, ptr %gep.off, align 4 ->
432; CHECK-NEXT:            store i32 %l, ptr %a, align 4
433; CHECK-EMPTY:
434; CHECK-NEXT:      Run-time memory checks:
435; CHECK-NEXT:      Grouped accesses:
436; CHECK-EMPTY:
437; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
438; CHECK-NEXT:      SCEV assumptions:
439; CHECK-EMPTY:
440; CHECK-NEXT:      Expressions re-written:
441;
442entry:
443  %gep.off = getelementptr i8, ptr %a, i32 3
444  br label %loop
445
446loop:
447  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
448  %l = load i32, ptr %gep.off
449  store i32 %l, ptr %a
450  %iv.next = add i32 %iv, 1
451  %ec = icmp eq i32 %iv.next, 100
452  br i1 %ec, label %exit, label %loop
453
454exit:
455  ret void
456}
457
458define void @test_invar_dependence_before_via_loop_guard_positive_strided_access_1(ptr %a, i32 %off) {
459; CHECK-LABEL: 'test_invar_dependence_before_via_loop_guard_positive_strided_access_1'
460; CHECK-NEXT:    loop:
461; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
462; CHECK-NEXT:  Unknown data dependence.
463; CHECK-NEXT:      Dependences:
464; CHECK-NEXT:        Unknown:
465; CHECK-NEXT:            %l = load i32, ptr %a, align 4 ->
466; CHECK-NEXT:            store i32 %l, ptr %gep, align 4
467; CHECK-EMPTY:
468; CHECK-NEXT:      Run-time memory checks:
469; CHECK-NEXT:      Grouped accesses:
470; CHECK-EMPTY:
471; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
472; CHECK-NEXT:      SCEV assumptions:
473; CHECK-EMPTY:
474; CHECK-NEXT:      Expressions re-written:
475;
476entry:
477  %gep.off = getelementptr i8, ptr %a, i32 %off
478  %c = icmp sge i32 %off, 4
479  br i1 %c, label %loop, label %exit
480
481loop:
482  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
483  %gep = getelementptr i32, ptr %gep.off, i32 %iv
484  %l = load i32, ptr %a
485  store i32 %l, ptr %gep
486  %iv.next = add i32 %iv, 1
487  %ec = icmp eq i32 %iv.next, 100
488  br i1 %ec, label %exit, label %loop
489
490exit:
491  ret void
492}
493
494define void @test_invar_dependence_before_via_loop_guard_positive_strided_access_2(ptr %a, i32 %off) {
495; CHECK-LABEL: 'test_invar_dependence_before_via_loop_guard_positive_strided_access_2'
496; CHECK-NEXT:    loop:
497; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
498; CHECK-NEXT:  Unknown data dependence.
499; CHECK-NEXT:      Dependences:
500; CHECK-NEXT:        Unknown:
501; CHECK-NEXT:            %l = load i32, ptr %gep, align 4 ->
502; CHECK-NEXT:            store i32 %l, ptr %a, align 4
503; CHECK-EMPTY:
504; CHECK-NEXT:      Run-time memory checks:
505; CHECK-NEXT:      Grouped accesses:
506; CHECK-EMPTY:
507; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
508; CHECK-NEXT:      SCEV assumptions:
509; CHECK-EMPTY:
510; CHECK-NEXT:      Expressions re-written:
511;
512entry:
513  %gep.off = getelementptr i8, ptr %a, i32 %off
514  %c = icmp sge i32 %off, 4
515  br i1 %c, label %loop, label %exit
516
517loop:
518  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
519  %gep = getelementptr i32, ptr %gep.off, i32 %iv
520  %l = load i32, ptr %gep
521  store i32 %l, ptr %a
522  %iv.next = add i32 %iv, 1
523  %ec = icmp eq i32 %iv.next, 100
524  br i1 %ec, label %exit, label %loop
525
526exit:
527  ret void
528}
529define void @test_invar_dependence_not_before_via_loop_guard_positive_strided_access_1(ptr %a, i32 %off) {
530; CHECK-LABEL: 'test_invar_dependence_not_before_via_loop_guard_positive_strided_access_1'
531; CHECK-NEXT:    loop:
532; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
533; CHECK-NEXT:  Unknown data dependence.
534; CHECK-NEXT:      Dependences:
535; CHECK-NEXT:        Unknown:
536; CHECK-NEXT:            %l = load i32, ptr %a, align 4 ->
537; CHECK-NEXT:            store i32 %l, ptr %gep, align 4
538; CHECK-EMPTY:
539; CHECK-NEXT:      Run-time memory checks:
540; CHECK-NEXT:      Grouped accesses:
541; CHECK-EMPTY:
542; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
543; CHECK-NEXT:      SCEV assumptions:
544; CHECK-EMPTY:
545; CHECK-NEXT:      Expressions re-written:
546;
547entry:
548  %gep.off = getelementptr i8, ptr %a, i32 %off
549  %c = icmp sge i32 %off, 3
550  br i1 %c, label %loop, label %exit
551
552loop:
553  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
554  %gep = getelementptr i32, ptr %gep.off, i32 %iv
555  %l = load i32, ptr %a
556  store i32 %l, ptr %gep
557  %iv.next = add i32 %iv, 1
558  %ec = icmp eq i32 %iv.next, 100
559  br i1 %ec, label %exit, label %loop
560
561exit:
562  ret void
563}
564
565define void @test_invar_dependence_not_before_via_loop_guard_positive_strided_access_2(ptr %a, i32 %off) {
566; CHECK-LABEL: 'test_invar_dependence_not_before_via_loop_guard_positive_strided_access_2'
567; CHECK-NEXT:    loop:
568; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
569; CHECK-NEXT:  Unknown data dependence.
570; CHECK-NEXT:      Dependences:
571; CHECK-NEXT:        Unknown:
572; CHECK-NEXT:            %l = load i32, ptr %gep, align 4 ->
573; CHECK-NEXT:            store i32 %l, ptr %a, align 4
574; CHECK-EMPTY:
575; CHECK-NEXT:      Run-time memory checks:
576; CHECK-NEXT:      Grouped accesses:
577; CHECK-EMPTY:
578; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
579; CHECK-NEXT:      SCEV assumptions:
580; CHECK-EMPTY:
581; CHECK-NEXT:      Expressions re-written:
582;
583entry:
584  %gep.off = getelementptr i8, ptr %a, i32 %off
585  %c = icmp sge i32 %off, 3
586  br i1 %c, label %loop, label %exit
587
588loop:
589  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
590  %gep = getelementptr i32, ptr %gep.off, i32 %iv
591  %l = load i32, ptr %gep
592  store i32 %l, ptr %a
593  %iv.next = add i32 %iv, 1
594  %ec = icmp eq i32 %iv.next, 100
595  br i1 %ec, label %exit, label %loop
596
597exit:
598  ret void
599}
600
601define void @test_invar_dependence_before_positive_strided_access_via_loop_guard_1(ptr %a, i32 %off) {
602; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_via_loop_guard_1'
603; CHECK-NEXT:    loop:
604; CHECK-NEXT:      Report: could not determine number of loop iterations
605; CHECK-NEXT:      Dependences:
606; CHECK-NEXT:      Run-time memory checks:
607; CHECK-NEXT:      Grouped accesses:
608; CHECK-EMPTY:
609; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
610; CHECK-NEXT:      SCEV assumptions:
611; CHECK-EMPTY:
612; CHECK-NEXT:      Expressions re-written:
613;
614entry:
615  %gep.off = getelementptr i8, ptr %a, i32 4
616  %c = icmp sge i32 %off, 0
617  br i1 %c, label %loop, label %exit
618
619loop:
620  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
621  %gep = getelementptr i32, ptr %gep.off, i32 %iv
622  %l = load i32, ptr %gep
623  store i32 %l, ptr %a
624  %iv.next = add i32 %iv, %off
625  %ec = icmp eq i32 %iv.next, 100
626  br i1 %ec, label %exit, label %loop
627
628exit:
629  ret void
630}
631
632define void @test_invar_dependence_before_positive_strided_access_via_loop_guard_2(ptr %a, i32 %off) {
633; CHECK-LABEL: 'test_invar_dependence_before_positive_strided_access_via_loop_guard_2'
634; CHECK-NEXT:    loop:
635; CHECK-NEXT:      Report: could not determine number of loop iterations
636; CHECK-NEXT:      Dependences:
637; CHECK-NEXT:      Run-time memory checks:
638; CHECK-NEXT:      Grouped accesses:
639; CHECK-EMPTY:
640; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
641; CHECK-NEXT:      SCEV assumptions:
642; CHECK-EMPTY:
643; CHECK-NEXT:      Expressions re-written:
644;
645entry:
646  %gep.off = getelementptr i8, ptr %a, i32 4
647  %c = icmp sge i32 %off, 0
648  br i1 %c, label %loop, label %exit
649
650loop:
651  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
652  %gep = getelementptr i32, ptr %gep.off, i32 %iv
653  %l = load i32, ptr %a
654  store i32 %l, ptr %gep
655  %iv.next = add i32 %iv, %off
656  %ec = icmp eq i32 %iv.next, 100
657  br i1 %ec, label %exit, label %loop
658
659exit:
660  ret void
661}
662
663define void @test_invar_dependence_not_known_beforepositive_strided_access_not_known_via_loop_guard_1(ptr %a, i32 %off) {
664; CHECK-LABEL: 'test_invar_dependence_not_known_beforepositive_strided_access_not_known_via_loop_guard_1'
665; CHECK-NEXT:    loop:
666; CHECK-NEXT:      Report: could not determine number of loop iterations
667; CHECK-NEXT:      Dependences:
668; CHECK-NEXT:      Run-time memory checks:
669; CHECK-NEXT:      Grouped accesses:
670; CHECK-EMPTY:
671; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
672; CHECK-NEXT:      SCEV assumptions:
673; CHECK-EMPTY:
674; CHECK-NEXT:      Expressions re-written:
675;
676entry:
677  %gep.off = getelementptr i8, ptr %a, i32 4
678  br label %loop
679
680loop:
681  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
682  %gep = getelementptr i32, ptr %gep.off, i32 %iv
683  %l = load i32, ptr %a
684  store i32 %l, ptr %gep
685  %iv.next = add i32 %iv, %off
686  %ec = icmp eq i32 %iv.next, 100
687  br i1 %ec, label %exit, label %loop
688
689exit:
690  ret void
691}
692
693define void @test_invar_dependence_not_known_beforepositive_strided_access_not_known_via_loop_guard_2(ptr %a, i32 %off) {
694; CHECK-LABEL: 'test_invar_dependence_not_known_beforepositive_strided_access_not_known_via_loop_guard_2'
695; CHECK-NEXT:    loop:
696; CHECK-NEXT:      Report: could not determine number of loop iterations
697; CHECK-NEXT:      Dependences:
698; CHECK-NEXT:      Run-time memory checks:
699; CHECK-NEXT:      Grouped accesses:
700; CHECK-EMPTY:
701; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
702; CHECK-NEXT:      SCEV assumptions:
703; CHECK-EMPTY:
704; CHECK-NEXT:      Expressions re-written:
705;
706entry:
707  %gep.off = getelementptr i8, ptr %a, i32 4
708  br label %loop
709
710loop:
711  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
712  %gep = getelementptr i32, ptr %gep.off, i32 %iv
713  %l = load i32, ptr %gep
714  store i32 %l, ptr %a
715  %iv.next = add i32 %iv, %off
716  %ec = icmp eq i32 %iv.next, 100
717  br i1 %ec, label %exit, label %loop
718
719exit:
720  ret void
721}
722
723define void @test_invar_vector_dependence_before_positive_strided_access_1(ptr %a) {
724; CHECK-LABEL: 'test_invar_vector_dependence_before_positive_strided_access_1'
725; CHECK-NEXT:    loop:
726; CHECK-NEXT:      Memory dependences are safe
727; CHECK-NEXT:      Dependences:
728; CHECK-NEXT:      Run-time memory checks:
729; CHECK-NEXT:      Grouped accesses:
730; CHECK-EMPTY:
731; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
732; CHECK-NEXT:      SCEV assumptions:
733; CHECK-EMPTY:
734; CHECK-NEXT:      Expressions re-written:
735;
736entry:
737  %gep.off = getelementptr i8, ptr %a, i32 4
738  br label %loop
739
740loop:
741  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
742  %gep = getelementptr i32, ptr %gep.off, i32 %iv
743  %l = load <4 x i8>, ptr %a
744  store i32 0, ptr %gep
745  %iv.next = add i32 %iv, 1
746  %ec = icmp eq i32 %iv.next, 100
747  br i1 %ec, label %exit, label %loop
748
749exit:
750  ret void
751}
752
753define void @test_invar_scalable_dependence_before_positive_strided_access_1(ptr %a) {
754; CHECK-LABEL: 'test_invar_scalable_dependence_before_positive_strided_access_1'
755; CHECK-NEXT:    loop:
756; CHECK-NEXT:      Report: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
757; CHECK-NEXT:  Unknown data dependence.
758; CHECK-NEXT:      Dependences:
759; CHECK-NEXT:        Unknown:
760; CHECK-NEXT:            %l = load <vscale x 4 x i8>, ptr %a, align 4 ->
761; CHECK-NEXT:            store i32 0, ptr %gep, align 4
762; CHECK-EMPTY:
763; CHECK-NEXT:      Run-time memory checks:
764; CHECK-NEXT:      Grouped accesses:
765; CHECK-EMPTY:
766; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
767; CHECK-NEXT:      SCEV assumptions:
768; CHECK-EMPTY:
769; CHECK-NEXT:      Expressions re-written:
770;
771entry:
772  %gep.off = getelementptr i8, ptr %a, i32 4
773  br label %loop
774
775loop:
776  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]
777  %gep = getelementptr i32, ptr %gep.off, i32 %iv
778  %l = load <vscale x 4 x i8>, ptr %a
779  store i32 0, ptr %gep
780  %iv.next = add i32 %iv, 1
781  %ec = icmp eq i32 %iv.next, 100
782  br i1 %ec, label %exit, label %loop
783
784exit:
785  ret void
786}
787
788define void @invariant_stores_unit_stride(i32 %offset, ptr noalias %dst.1, ptr %dst.2) {
789; CHECK-LABEL: 'invariant_stores_unit_stride'
790; CHECK-NEXT:    loop:
791; CHECK-NEXT:      Memory dependences are safe
792; CHECK-NEXT:      Dependences:
793; CHECK-NEXT:      Run-time memory checks:
794; CHECK-NEXT:      Grouped accesses:
795; CHECK-EMPTY:
796; CHECK-NEXT:      Non vectorizable stores to invariant address were not found in loop.
797; CHECK-NEXT:      SCEV assumptions:
798; CHECK-EMPTY:
799; CHECK-NEXT:      Expressions re-written:
800;
801entry:
802  %add = add i32 %offset, 3
803  br label %loop
804
805loop:
806  %iv.2 = phi i32 [ 0, %entry ], [ %iv.2.next, %loop ]
807  %iv.3 = phi i32 [ 0, %entry ], [ %iv.3.next, %loop ]
808  %iv.mul  = mul i32 %iv.3, %add
809  %gep.mul = getelementptr i8, ptr %dst.1, i32 %iv.mul
810  store i32 0, ptr %gep.mul, align 8
811  %iv.2.mul  = mul i32 %iv.2, %offset
812  %gep = getelementptr i32, ptr %dst.2, i32 %iv.2.mul
813  store i32 0, ptr %gep, align 8
814  %iv.2.next = add i32 %iv.2, 1
815  %iv.3.next = add i32 %iv.3, 1
816  %ec = icmp eq i32 %iv.3, 200
817  br i1 %ec, label %exit, label %loop
818
819exit:
820  ret void
821}
822