← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to test/Analysis/BasicAA/gep-alias.ll

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/Analysis/BasicAA/gep-alias.ll
 
1
; RUN: opt < %s -basicaa -gvn -instcombine -S 2>&1 | FileCheck %s
 
2
 
 
3
target datalayout = "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-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 
4
 
 
5
; Make sure that basicaa thinks R and r are must aliases.
 
6
define i32 @test1(i8 * %P) {
 
7
entry:
 
8
        %Q = bitcast i8* %P to {i32, i32}*
 
9
        %R = getelementptr {i32, i32}, {i32, i32}* %Q, i32 0, i32 1
 
10
        %S = load i32, i32* %R
 
11
 
 
12
        %q = bitcast i8* %P to {i32, i32}*
 
13
        %r = getelementptr {i32, i32}, {i32, i32}* %q, i32 0, i32 1
 
14
        %s = load i32, i32* %r
 
15
 
 
16
        %t = sub i32 %S, %s
 
17
        ret i32 %t
 
18
; CHECK-LABEL: @test1(
 
19
; CHECK: ret i32 0
 
20
}
 
21
 
 
22
define i32 @test2(i8 * %P) {
 
23
entry:
 
24
        %Q = bitcast i8* %P to {i32, i32, i32}*
 
25
        %R = getelementptr {i32, i32, i32}, {i32, i32, i32}* %Q, i32 0, i32 1
 
26
        %S = load i32, i32* %R
 
27
 
 
28
        %r = getelementptr {i32, i32, i32}, {i32, i32, i32}* %Q, i32 0, i32 2
 
29
  store i32 42, i32* %r
 
30
 
 
31
        %s = load i32, i32* %R
 
32
 
 
33
        %t = sub i32 %S, %s
 
34
        ret i32 %t
 
35
; CHECK-LABEL: @test2(
 
36
; CHECK: ret i32 0
 
37
}
 
38
 
 
39
 
 
40
; This was a miscompilation.
 
41
define i32 @test3({float, {i32, i32, i32}}* %P) {
 
42
entry:
 
43
  %P2 = getelementptr {float, {i32, i32, i32}}, {float, {i32, i32, i32}}* %P, i32 0, i32 1
 
44
        %R = getelementptr {i32, i32, i32}, {i32, i32, i32}* %P2, i32 0, i32 1
 
45
        %S = load i32, i32* %R
 
46
 
 
47
        %r = getelementptr {i32, i32, i32}, {i32, i32, i32}* %P2, i32 0, i32 2
 
48
  store i32 42, i32* %r
 
49
 
 
50
        %s = load i32, i32* %R
 
51
 
 
52
        %t = sub i32 %S, %s
 
53
        ret i32 %t
 
54
; CHECK-LABEL: @test3(
 
55
; CHECK: ret i32 0
 
56
}
 
57
 
 
58
 
 
59
;; This is reduced from the SmallPtrSet constructor.
 
60
%SmallPtrSetImpl = type { i8**, i32, i32, i32, [1 x i8*] }
 
61
%SmallPtrSet64 = type { %SmallPtrSetImpl, [64 x i8*] }
 
62
 
 
63
define i32 @test4(%SmallPtrSet64* %P) {
 
64
entry:
 
65
  %tmp2 = getelementptr inbounds %SmallPtrSet64, %SmallPtrSet64* %P, i64 0, i32 0, i32 1
 
66
  store i32 64, i32* %tmp2, align 8
 
67
  %tmp3 = getelementptr inbounds %SmallPtrSet64, %SmallPtrSet64* %P, i64 0, i32 0, i32 4, i64 64
 
68
  store i8* null, i8** %tmp3, align 8
 
69
  %tmp4 = load i32, i32* %tmp2, align 8
 
70
        ret i32 %tmp4
 
71
; CHECK-LABEL: @test4(
 
72
; CHECK: ret i32 64
 
73
}
 
74
 
 
75
; P[i] != p[i+1]
 
76
define i32 @test5(i32* %p, i64 %i) {
 
77
  %pi = getelementptr i32, i32* %p, i64 %i
 
78
  %i.next = add i64 %i, 1
 
79
  %pi.next = getelementptr i32, i32* %p, i64 %i.next
 
80
  %x = load i32, i32* %pi
 
81
  store i32 42, i32* %pi.next
 
82
  %y = load i32, i32* %pi
 
83
  %z = sub i32 %x, %y
 
84
  ret i32 %z
 
85
; CHECK-LABEL: @test5(
 
86
; CHECK: ret i32 0
 
87
}
 
88
 
 
89
define i32 @test5_as1_smaller_size(i32 addrspace(1)* %p, i8 %i) {
 
90
  %pi = getelementptr i32, i32 addrspace(1)* %p, i8 %i
 
91
  %i.next = add i8 %i, 1
 
92
  %pi.next = getelementptr i32, i32 addrspace(1)* %p, i8 %i.next
 
93
  %x = load i32, i32 addrspace(1)* %pi
 
94
  store i32 42, i32 addrspace(1)* %pi.next
 
95
  %y = load i32, i32 addrspace(1)* %pi
 
96
  %z = sub i32 %x, %y
 
97
  ret i32 %z
 
98
; CHECK-LABEL: @test5_as1_smaller_size(
 
99
; CHECK: sext
 
100
; CHECK: ret i32 0
 
101
}
 
102
 
 
103
define i32 @test5_as1_same_size(i32 addrspace(1)* %p, i16 %i) {
 
104
  %pi = getelementptr i32, i32 addrspace(1)* %p, i16 %i
 
105
  %i.next = add i16 %i, 1
 
106
  %pi.next = getelementptr i32, i32 addrspace(1)* %p, i16 %i.next
 
107
  %x = load i32, i32 addrspace(1)* %pi
 
108
  store i32 42, i32 addrspace(1)* %pi.next
 
109
  %y = load i32, i32 addrspace(1)* %pi
 
110
  %z = sub i32 %x, %y
 
111
  ret i32 %z
 
112
; CHECK-LABEL: @test5_as1_same_size(
 
113
; CHECK: ret i32 0
 
114
}
 
115
 
 
116
; P[i] != p[(i*4)|1]
 
117
define i32 @test6(i32* %p, i64 %i1) {
 
118
  %i = shl i64 %i1, 2
 
119
  %pi = getelementptr i32, i32* %p, i64 %i
 
120
  %i.next = or i64 %i, 1
 
121
  %pi.next = getelementptr i32, i32* %p, i64 %i.next
 
122
  %x = load i32, i32* %pi
 
123
  store i32 42, i32* %pi.next
 
124
  %y = load i32, i32* %pi
 
125
  %z = sub i32 %x, %y
 
126
  ret i32 %z
 
127
; CHECK-LABEL: @test6(
 
128
; CHECK: ret i32 0
 
129
}
 
130
 
 
131
; P[1] != P[i*4]
 
132
define i32 @test7(i32* %p, i64 %i) {
 
133
  %pi = getelementptr i32, i32* %p, i64 1
 
134
  %i.next = shl i64 %i, 2
 
135
  %pi.next = getelementptr i32, i32* %p, i64 %i.next
 
136
  %x = load i32, i32* %pi
 
137
  store i32 42, i32* %pi.next
 
138
  %y = load i32, i32* %pi
 
139
  %z = sub i32 %x, %y
 
140
  ret i32 %z
 
141
; CHECK-LABEL: @test7(
 
142
; CHECK: ret i32 0
 
143
}
 
144
 
 
145
; P[zext(i)] != p[zext(i+1)]
 
146
; PR1143
 
147
define i32 @test8(i32* %p, i16 %i) {
 
148
  %i1 = zext i16 %i to i32
 
149
  %pi = getelementptr i32, i32* %p, i32 %i1
 
150
  %i.next = add i16 %i, 1
 
151
  %i.next2 = zext i16 %i.next to i32
 
152
  %pi.next = getelementptr i32, i32* %p, i32 %i.next2
 
153
  %x = load i32, i32* %pi
 
154
  store i32 42, i32* %pi.next
 
155
  %y = load i32, i32* %pi
 
156
  %z = sub i32 %x, %y
 
157
  ret i32 %z
 
158
; CHECK-LABEL: @test8(
 
159
; CHECK: ret i32 0
 
160
}
 
161
 
 
162
define i8 @test9([4 x i8] *%P, i32 %i, i32 %j) {
 
163
  %i2 = shl i32 %i, 2
 
164
  %i3 = add i32 %i2, 1
 
165
  ; P2 = P + 1 + 4*i
 
166
  %P2 = getelementptr [4 x i8], [4 x i8] *%P, i32 0, i32 %i3
 
167
 
 
168
  %j2 = shl i32 %j, 2
 
169
 
 
170
  ; P4 = P + 4*j
 
171
  %P4 = getelementptr [4 x i8], [4 x i8]* %P, i32 0, i32 %j2
 
172
 
 
173
  %x = load i8, i8* %P2
 
174
  store i8 42, i8* %P4
 
175
  %y = load i8, i8* %P2
 
176
  %z = sub i8 %x, %y
 
177
  ret i8 %z
 
178
; CHECK-LABEL: @test9(
 
179
; CHECK: ret i8 0
 
180
}
 
181
 
 
182
define i8 @test10([4 x i8] *%P, i32 %i) {
 
183
  %i2 = shl i32 %i, 2
 
184
  %i3 = add i32 %i2, 4
 
185
  ; P2 = P + 4 + 4*i
 
186
  %P2 = getelementptr [4 x i8], [4 x i8] *%P, i32 0, i32 %i3
 
187
 
 
188
  ; P4 = P + 4*i
 
189
  %P4 = getelementptr [4 x i8], [4 x i8]* %P, i32 0, i32 %i2
 
190
 
 
191
  %x = load i8, i8* %P2
 
192
  store i8 42, i8* %P4
 
193
  %y = load i8, i8* %P2
 
194
  %z = sub i8 %x, %y
 
195
  ret i8 %z
 
196
; CHECK-LABEL: @test10(
 
197
; CHECK: ret i8 0
 
198
}
 
199
 
 
200
; (This was a miscompilation.)
 
201
define float @test11(i32 %indvar, [4 x [2 x float]]* %q) nounwind ssp {
 
202
  %tmp = mul i32 %indvar, -1
 
203
  %dec = add i32 %tmp, 3
 
204
  %scevgep = getelementptr [4 x [2 x float]], [4 x [2 x float]]* %q, i32 0, i32 %dec
 
205
  %scevgep35 = bitcast [2 x float]* %scevgep to i64*
 
206
  %arrayidx28 = getelementptr inbounds [4 x [2 x float]], [4 x [2 x float]]* %q, i32 0, i32 0
 
207
  %y29 = getelementptr inbounds [2 x float], [2 x float]* %arrayidx28, i32 0, i32 1
 
208
  store float 1.0, float* %y29, align 4
 
209
  store i64 0, i64* %scevgep35, align 4
 
210
  %tmp30 = load float, float* %y29, align 4
 
211
  ret float %tmp30
 
212
; CHECK-LABEL: @test11(
 
213
; CHECK: ret float %tmp30
 
214
}
 
215
 
 
216
; (This was a miscompilation.)
 
217
define i32 @test12(i32 %x, i32 %y, i8* %p) nounwind {
 
218
  %a = bitcast i8* %p to [13 x i8]*
 
219
  %b = getelementptr [13 x i8], [13 x i8]* %a, i32 %x
 
220
  %c = bitcast [13 x i8]* %b to [15 x i8]*
 
221
  %d = getelementptr [15 x i8], [15 x i8]* %c, i32 %y, i32 8
 
222
  %castd = bitcast i8* %d to i32*
 
223
  %castp = bitcast i8* %p to i32*
 
224
  store i32 1, i32* %castp
 
225
  store i32 0, i32* %castd
 
226
  %r = load i32, i32* %castp
 
227
  ret i32 %r
 
228
; CHECK-LABEL: @test12(
 
229
; CHECK: ret i32 %r
 
230
}