1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
2; This testcase tests for various features the basicaa test should be able to
3; determine, as noted in the comments.
4
5; RUN: opt < %s -basic-aa -gvn -instcombine -dce -S | FileCheck %s --check-prefixes=CHECK,NO_ASSUME
6; RUN: opt < %s -basic-aa -gvn -instcombine -dce --enable-knowledge-retention -S | FileCheck %s --check-prefixes=CHECK,USE_ASSUME
7target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
8
9@Global = external global { i32 }
10
11declare void @external(i32*)
12declare void @llvm.assume(i1)
13
14; Array test:  Test that operations on one local array do not invalidate
15; operations on another array.  Important for scientific codes.
16;
17define i32 @different_array_test(i64 %A, i64 %B) {
18; CHECK-LABEL: @different_array_test(
19; CHECK-NEXT:    [[ARRAY11:%.*]] = alloca [100 x i32], align 4
20; CHECK-NEXT:    [[ARRAY22:%.*]] = alloca [200 x i32], align 4
21; CHECK-NEXT:    [[ARRAY22_SUB:%.*]] = getelementptr inbounds [200 x i32], [200 x i32]* [[ARRAY22]], i64 0, i64 0
22; CHECK-NEXT:    [[ARRAY11_SUB:%.*]] = getelementptr inbounds [100 x i32], [100 x i32]* [[ARRAY11]], i64 0, i64 0
23; CHECK-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[ARRAY11_SUB]], i32 4) ]
24; CHECK-NEXT:    call void @external(i32* nonnull [[ARRAY11_SUB]])
25; CHECK-NEXT:    call void @external(i32* nonnull [[ARRAY22_SUB]])
26; CHECK-NEXT:    [[POINTER2:%.*]] = getelementptr [200 x i32], [200 x i32]* [[ARRAY22]], i64 0, i64 [[B:%.*]]
27; CHECK-NEXT:    store i32 7, i32* [[POINTER2]], align 4
28; CHECK-NEXT:    ret i32 0
29;
30  %Array1 = alloca i32, i32 100
31  %Array2 = alloca i32, i32 200
32  call void @llvm.assume(i1 true) ["align"(i32* %Array1, i32 4)]
33
34  call void @external(i32* %Array1)
35  call void @external(i32* %Array2)
36
37  %pointer = getelementptr i32, i32* %Array1, i64 %A
38  %val = load i32, i32* %pointer
39
40  %pointer2 = getelementptr i32, i32* %Array2, i64 %B
41  store i32 7, i32* %pointer2
42
43  %REMOVE = load i32, i32* %pointer ; redundant with above load
44  %retval = sub i32 %REMOVE, %val
45  ret i32 %retval
46}
47
48; Constant index test: Constant indexes into the same array should not
49; interfere with each other.  Again, important for scientific codes.
50;
51define i32 @constant_array_index_test() {
52; CHECK-LABEL: @constant_array_index_test(
53; CHECK-NEXT:    [[ARRAY1:%.*]] = alloca [100 x i32], align 4
54; CHECK-NEXT:    [[ARRAY1_SUB:%.*]] = getelementptr inbounds [100 x i32], [100 x i32]* [[ARRAY1]], i64 0, i64 0
55; CHECK-NEXT:    call void @external(i32* nonnull [[ARRAY1_SUB]])
56; CHECK-NEXT:    [[P2:%.*]] = getelementptr inbounds [100 x i32], [100 x i32]* [[ARRAY1]], i64 0, i64 6
57; CHECK-NEXT:    store i32 1, i32* [[P2]], align 4
58; CHECK-NEXT:    ret i32 0
59;
60  %Array = alloca i32, i32 100
61  call void @external(i32* %Array)
62
63  %P1 = getelementptr i32, i32* %Array, i64 7
64  %P2 = getelementptr i32, i32* %Array, i64 6
65
66  %A = load i32, i32* %P1
67  store i32 1, i32* %P2   ; Should not invalidate load
68  %BREMOVE = load i32, i32* %P1
69  %Val = sub i32 %A, %BREMOVE
70  ret i32 %Val
71}
72
73; Test that if two pointers are spaced out by a constant getelementptr, that
74; they cannot alias.
75define i32 @gep_distance_test(i32* %A) {
76; NO_ASSUME-LABEL: @gep_distance_test(
77; NO_ASSUME-NEXT:    [[B:%.*]] = getelementptr i32, i32* [[A:%.*]], i64 2
78; NO_ASSUME-NEXT:    store i32 7, i32* [[B]], align 4
79; NO_ASSUME-NEXT:    ret i32 0
80;
81; USE_ASSUME-LABEL: @gep_distance_test(
82; USE_ASSUME-NEXT:    [[B:%.*]] = getelementptr i32, i32* [[A:%.*]], i64 2
83; USE_ASSUME-NEXT:    store i32 7, i32* [[B]], align 4
84; USE_ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[A]], i64 4), "nonnull"(i32* [[A]]), "align"(i32* [[A]], i64 4) ]
85; USE_ASSUME-NEXT:    ret i32 0
86;
87  %REMOVEu = load i32, i32* %A
88  %B = getelementptr i32, i32* %A, i64 2  ; Cannot alias A
89  store i32 7, i32* %B
90  %REMOVEv = load i32, i32* %A
91  %r = sub i32 %REMOVEu, %REMOVEv
92  ret i32 %r
93}
94
95; Test that if two pointers are spaced out by a constant offset, that they
96; cannot alias, even if there is a variable offset between them...
97define i32 @gep_distance_test2({i32,i32}* %A, i64 %distance) {
98; NO_ASSUME-LABEL: @gep_distance_test2(
99; NO_ASSUME-NEXT:    [[B:%.*]] = getelementptr { i32, i32 }, { i32, i32 }* [[A:%.*]], i64 [[DISTANCE:%.*]], i32 1
100; NO_ASSUME-NEXT:    store i32 7, i32* [[B]], align 4
101; NO_ASSUME-NEXT:    ret i32 0
102;
103; USE_ASSUME-LABEL: @gep_distance_test2(
104; USE_ASSUME-NEXT:    [[A1:%.*]] = getelementptr { i32, i32 }, { i32, i32 }* [[A:%.*]], i64 0, i32 0
105; USE_ASSUME-NEXT:    [[B:%.*]] = getelementptr { i32, i32 }, { i32, i32 }* [[A]], i64 [[DISTANCE:%.*]], i32 1
106; USE_ASSUME-NEXT:    store i32 7, i32* [[B]], align 4
107; USE_ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[A1]], i64 4), "nonnull"({ i32, i32 }* [[A]]), "align"(i32* [[A1]], i64 4) ]
108; USE_ASSUME-NEXT:    ret i32 0
109;
110  %A1 = getelementptr {i32,i32}, {i32,i32}* %A, i64 0, i32 0
111  %REMOVEu = load i32, i32* %A1
112  %B = getelementptr {i32,i32}, {i32,i32}* %A, i64 %distance, i32 1
113  store i32 7, i32* %B    ; B cannot alias A, it's at least 4 bytes away
114  %REMOVEv = load i32, i32* %A1
115  %r = sub i32 %REMOVEu, %REMOVEv
116  ret i32 %r
117}
118
119; Test that we can do funny pointer things and that distance calc will still
120; work.
121define i32 @gep_distance_test3(i32 * %A) {
122; NO_ASSUME-LABEL: @gep_distance_test3(
123; NO_ASSUME-NEXT:    [[C1:%.*]] = getelementptr i32, i32* [[A:%.*]], i64 1
124; NO_ASSUME-NEXT:    [[C:%.*]] = bitcast i32* [[C1]] to i8*
125; NO_ASSUME-NEXT:    store i8 42, i8* [[C]], align 1
126; NO_ASSUME-NEXT:    ret i32 0
127;
128; USE_ASSUME-LABEL: @gep_distance_test3(
129; USE_ASSUME-NEXT:    [[C1:%.*]] = getelementptr i32, i32* [[A:%.*]], i64 1
130; USE_ASSUME-NEXT:    [[C:%.*]] = bitcast i32* [[C1]] to i8*
131; USE_ASSUME-NEXT:    store i8 42, i8* [[C]], align 1
132; USE_ASSUME-NEXT:    call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[A]], i64 4), "nonnull"(i32* [[A]]), "align"(i32* [[A]], i64 4) ]
133; USE_ASSUME-NEXT:    ret i32 0
134;
135  %X = load i32, i32* %A
136  %B = bitcast i32* %A to i8*
137  %C = getelementptr i8, i8* %B, i64 4
138  store i8 42, i8* %C
139  %Y = load i32, i32* %A
140  %R = sub i32 %X, %Y
141  ret i32 %R
142}
143
144; Test that we can disambiguate globals reached through constantexpr geps
145define i32 @constexpr_test() {
146; CHECK-LABEL: @constexpr_test(
147; CHECK-NEXT:    [[X:%.*]] = alloca i32, align 4
148; CHECK-NEXT:    call void @external(i32* nonnull [[X]])
149; CHECK-NEXT:    store i32 5, i32* getelementptr inbounds ({ i32 }, { i32 }* @Global, i64 0, i32 0), align 4
150; CHECK-NEXT:    ret i32 0
151;
152  %X = alloca i32
153  call void @external(i32* %X)
154
155  %Y = load i32, i32* %X
156  store i32 5, i32* getelementptr ({ i32 }, { i32 }* @Global, i64 0, i32 0)
157  %REMOVE = load i32, i32* %X
158  %retval = sub i32 %Y, %REMOVE
159  ret i32 %retval
160}
161
162
163
164; PR7589
165; These two index expressions are different, this cannot be CSE'd.
166define i16 @zext_sext_confusion(i16* %row2col, i5 %j) nounwind{
167; CHECK-LABEL: @zext_sext_confusion(
168; CHECK-NEXT:  entry:
169; CHECK-NEXT:    [[SUM5_CAST:%.*]] = zext i5 [[J:%.*]] to i64
170; CHECK-NEXT:    [[P1:%.*]] = getelementptr i16, i16* [[ROW2COL:%.*]], i64 [[SUM5_CAST]]
171; CHECK-NEXT:    [[ROW2COL_LOAD_1_2:%.*]] = load i16, i16* [[P1]], align 1
172; CHECK-NEXT:    [[SUM13_CAST31:%.*]] = sext i5 [[J]] to i6
173; CHECK-NEXT:    [[SUM13_CAST:%.*]] = zext i6 [[SUM13_CAST31]] to i64
174; CHECK-NEXT:    [[P2:%.*]] = getelementptr i16, i16* [[ROW2COL]], i64 [[SUM13_CAST]]
175; CHECK-NEXT:    [[ROW2COL_LOAD_1_6:%.*]] = load i16, i16* [[P2]], align 1
176; CHECK-NEXT:    [[DOTRET:%.*]] = sub i16 [[ROW2COL_LOAD_1_6]], [[ROW2COL_LOAD_1_2]]
177; CHECK-NEXT:    ret i16 [[DOTRET]]
178;
179entry:
180  %sum5.cast = zext i5 %j to i64             ; <i64> [#uses=1]
181  %P1 = getelementptr i16, i16* %row2col, i64 %sum5.cast
182  %row2col.load.1.2 = load i16, i16* %P1, align 1 ; <i16> [#uses=1]
183
184  %sum13.cast31 = sext i5 %j to i6          ; <i6> [#uses=1]
185  %sum13.cast = zext i6 %sum13.cast31 to i64      ; <i64> [#uses=1]
186  %P2 = getelementptr i16, i16* %row2col, i64 %sum13.cast
187  %row2col.load.1.6 = load i16, i16* %P2, align 1 ; <i16> [#uses=1]
188
189  %.ret = sub i16 %row2col.load.1.6, %row2col.load.1.2 ; <i16> [#uses=1]
190  ret i16 %.ret
191}
192