Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(10)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: test/Transforms/NaCl/vector-canonicalization-loads.ll

Issue 1423873002: PNaCl: Add a vector type legalization pass. Base URL: https://chromium.googlesource.com/native_client/pnacl-llvm.git@master
Patch Set: Created 5 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « test/Transforms/NaCl/vector-canonicalization-inserts.ll ('k') | test/Transforms/NaCl/vector-canonicalization-phis.ll » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 ; RUN: opt -S -pnacl-vector-canonicalization %s | FileCheck %s
2
3 ; Auto-generated tests for load instructions.
4
5 target datalayout = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64 :64:64-p:32:32:32-v128:32:128"
6
7 define i32 @load_from_2xi8_unaligned(<2 x i8>*) {
8 entry:
9 %1 = load <2 x i8>, <2 x i8>* %0
10 ret i32 0
11 }
12 ; CHECK-LABEL: define i32 @load_from_2xi8_unaligned(<2 x i8>*) {
13 ; CHECK: entry:
14 ; CHECK-NEXT: %1 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 0
15 ; CHECK-NEXT: %2 = load i8, i8* %1
16 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
17 ; CHECK-NEXT: %4 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 1
18 ; CHECK-NEXT: %5 = load i8, i8* %4
19 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
20 ; CHECK-NEXT: ret i32 0
21 ; CHECK-NEXT: }
22
23 define i32 @load_from_2xi16_unaligned(<2 x i16>*) {
24 entry:
25 %1 = load <2 x i16>, <2 x i16>* %0
26 ret i32 0
27 }
28 ; CHECK-LABEL: define i32 @load_from_2xi16_unaligned(<2 x i16>*) {
29 ; CHECK: entry:
30 ; CHECK-NEXT: %1 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 0
31 ; CHECK-NEXT: %2 = load i16, i16* %1
32 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
33 ; CHECK-NEXT: %4 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 1
34 ; CHECK-NEXT: %5 = load i16, i16* %4
35 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
36 ; CHECK-NEXT: ret i32 0
37 ; CHECK-NEXT: }
38
39 define i32 @load_from_2xi32_unaligned(<2 x i32>*) {
40 entry:
41 %1 = load <2 x i32>, <2 x i32>* %0
42 ret i32 0
43 }
44 ; CHECK-LABEL: define i32 @load_from_2xi32_unaligned(<2 x i32>*) {
45 ; CHECK: entry:
46 ; CHECK-NEXT: %1 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 0
47 ; CHECK-NEXT: %2 = load i32, i32* %1
48 ; CHECK-NEXT: %3 = insertelement <4 x i32> undef, i32 %2, i32 0
49 ; CHECK-NEXT: %4 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 1
50 ; CHECK-NEXT: %5 = load i32, i32* %4
51 ; CHECK-NEXT: %6 = insertelement <4 x i32> %3, i32 %5, i32 1
52 ; CHECK-NEXT: ret i32 0
53 ; CHECK-NEXT: }
54
55 define i32 @load_from_2xi64_unaligned(<2 x i64>*) {
56 entry:
57 %1 = load <2 x i64>, <2 x i64>* %0
58 ret i32 0
59 }
60 ; CHECK-LABEL: define i32 @load_from_2xi64_unaligned(<2 x i64>*) {
61 ; CHECK: entry:
62 ; CHECK-NEXT: %1 = load <2 x i64>, <2 x i64>* %0
63 ; CHECK-NEXT: ret i32 0
64 ; CHECK-NEXT: }
65
66 define i32 @load_from_2xi8ptr_unaligned(<2 x i8*>*) {
67 entry:
68 %1 = load <2 x i8*>, <2 x i8*>* %0
69 ret i32 0
70 }
71 ; CHECK-LABEL: define i32 @load_from_2xi8ptr_unaligned(<2 x i8*>*) {
72 ; CHECK: entry:
73 ; CHECK-NEXT: %1 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 0
74 ; CHECK-NEXT: %2 = load i8*, i8** %1
75 ; CHECK-NEXT: %3 = insertelement <4 x i8*> undef, i8* %2, i32 0
76 ; CHECK-NEXT: %4 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 1
77 ; CHECK-NEXT: %5 = load i8*, i8** %4
78 ; CHECK-NEXT: %6 = insertelement <4 x i8*> %3, i8* %5, i32 1
79 ; CHECK-NEXT: ret i32 0
80 ; CHECK-NEXT: }
81
82 define i32 @load_from_2xfloat_unaligned(<2 x float>*) {
83 entry:
84 %1 = load <2 x float>, <2 x float>* %0
85 ret i32 0
86 }
87 ; CHECK-LABEL: define i32 @load_from_2xfloat_unaligned(<2 x float>*) {
88 ; CHECK: entry:
89 ; CHECK-NEXT: %1 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 0
90 ; CHECK-NEXT: %2 = load float, float* %1
91 ; CHECK-NEXT: %3 = insertelement <4 x float> undef, float %2, i32 0
92 ; CHECK-NEXT: %4 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 1
93 ; CHECK-NEXT: %5 = load float, float* %4
94 ; CHECK-NEXT: %6 = insertelement <4 x float> %3, float %5, i32 1
95 ; CHECK-NEXT: ret i32 0
96 ; CHECK-NEXT: }
97
98 define i32 @load_from_2xdouble_unaligned(<2 x double>*) {
99 entry:
100 %1 = load <2 x double>, <2 x double>* %0
101 ret i32 0
102 }
103 ; CHECK-LABEL: define i32 @load_from_2xdouble_unaligned(<2 x double>*) {
104 ; CHECK: entry:
105 ; CHECK-NEXT: %1 = load <2 x double>, <2 x double>* %0
106 ; CHECK-NEXT: ret i32 0
107 ; CHECK-NEXT: }
108
109 define i32 @load_from_4xi8_unaligned(<4 x i8>*) {
110 entry:
111 %1 = load <4 x i8>, <4 x i8>* %0
112 ret i32 0
113 }
114 ; CHECK-LABEL: define i32 @load_from_4xi8_unaligned(<4 x i8>*) {
115 ; CHECK: entry:
116 ; CHECK-NEXT: %1 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 0
117 ; CHECK-NEXT: %2 = load i8, i8* %1
118 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
119 ; CHECK-NEXT: %4 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 1
120 ; CHECK-NEXT: %5 = load i8, i8* %4
121 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
122 ; CHECK-NEXT: %7 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 2
123 ; CHECK-NEXT: %8 = load i8, i8* %7
124 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
125 ; CHECK-NEXT: %10 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 3
126 ; CHECK-NEXT: %11 = load i8, i8* %10
127 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
128 ; CHECK-NEXT: ret i32 0
129 ; CHECK-NEXT: }
130
131 define i32 @load_from_4xi16_unaligned(<4 x i16>*) {
132 entry:
133 %1 = load <4 x i16>, <4 x i16>* %0
134 ret i32 0
135 }
136 ; CHECK-LABEL: define i32 @load_from_4xi16_unaligned(<4 x i16>*) {
137 ; CHECK: entry:
138 ; CHECK-NEXT: %1 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 0
139 ; CHECK-NEXT: %2 = load i16, i16* %1
140 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
141 ; CHECK-NEXT: %4 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 1
142 ; CHECK-NEXT: %5 = load i16, i16* %4
143 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
144 ; CHECK-NEXT: %7 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 2
145 ; CHECK-NEXT: %8 = load i16, i16* %7
146 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
147 ; CHECK-NEXT: %10 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 3
148 ; CHECK-NEXT: %11 = load i16, i16* %10
149 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
150 ; CHECK-NEXT: ret i32 0
151 ; CHECK-NEXT: }
152
153 define i32 @load_from_4xi32_unaligned(<4 x i32>*) {
154 entry:
155 %1 = load <4 x i32>, <4 x i32>* %0
156 ret i32 0
157 }
158 ; CHECK-LABEL: define i32 @load_from_4xi32_unaligned(<4 x i32>*) {
159 ; CHECK: entry:
160 ; CHECK-NEXT: %1 = load <4 x i32>, <4 x i32>* %0
161 ; CHECK-NEXT: ret i32 0
162 ; CHECK-NEXT: }
163
164 define i32 @load_from_4xi64_unaligned(<4 x i64>*) {
165 entry:
166 %1 = load <4 x i64>, <4 x i64>* %0
167 ret i32 0
168 }
169 ; CHECK-LABEL: define i32 @load_from_4xi64_unaligned(<4 x i64>*) {
170 ; CHECK: entry:
171 ; CHECK-NEXT: %1 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 0
172 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
173 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
174 ; CHECK-NEXT: %4 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 2
175 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
176 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
177 ; CHECK-NEXT: ret i32 0
178 ; CHECK-NEXT: }
179
180 define i32 @load_from_4xi8ptr_unaligned(<4 x i8*>*) {
181 entry:
182 %1 = load <4 x i8*>, <4 x i8*>* %0
183 ret i32 0
184 }
185 ; CHECK-LABEL: define i32 @load_from_4xi8ptr_unaligned(<4 x i8*>*) {
186 ; CHECK: entry:
187 ; CHECK-NEXT: %1 = load <4 x i8*>, <4 x i8*>* %0
188 ; CHECK-NEXT: ret i32 0
189 ; CHECK-NEXT: }
190
191 define i32 @load_from_4xfloat_unaligned(<4 x float>*) {
192 entry:
193 %1 = load <4 x float>, <4 x float>* %0
194 ret i32 0
195 }
196 ; CHECK-LABEL: define i32 @load_from_4xfloat_unaligned(<4 x float>*) {
197 ; CHECK: entry:
198 ; CHECK-NEXT: %1 = load <4 x float>, <4 x float>* %0
199 ; CHECK-NEXT: ret i32 0
200 ; CHECK-NEXT: }
201
202 define i32 @load_from_4xdouble_unaligned(<4 x double>*) {
203 entry:
204 %1 = load <4 x double>, <4 x double>* %0
205 ret i32 0
206 }
207 ; CHECK-LABEL: define i32 @load_from_4xdouble_unaligned(<4 x double>*) {
208 ; CHECK: entry:
209 ; CHECK-NEXT: %1 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 0
210 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
211 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
212 ; CHECK-NEXT: %4 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 2
213 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
214 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
215 ; CHECK-NEXT: ret i32 0
216 ; CHECK-NEXT: }
217
218 define i32 @load_from_6xi8_unaligned(<6 x i8>*) {
219 entry:
220 %1 = load <6 x i8>, <6 x i8>* %0
221 ret i32 0
222 }
223 ; CHECK-LABEL: define i32 @load_from_6xi8_unaligned(<6 x i8>*) {
224 ; CHECK: entry:
225 ; CHECK-NEXT: %1 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 0
226 ; CHECK-NEXT: %2 = load i8, i8* %1
227 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
228 ; CHECK-NEXT: %4 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 1
229 ; CHECK-NEXT: %5 = load i8, i8* %4
230 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
231 ; CHECK-NEXT: %7 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 2
232 ; CHECK-NEXT: %8 = load i8, i8* %7
233 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
234 ; CHECK-NEXT: %10 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 3
235 ; CHECK-NEXT: %11 = load i8, i8* %10
236 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
237 ; CHECK-NEXT: %13 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 4
238 ; CHECK-NEXT: %14 = load i8, i8* %13
239 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
240 ; CHECK-NEXT: %16 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 5
241 ; CHECK-NEXT: %17 = load i8, i8* %16
242 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
243 ; CHECK-NEXT: ret i32 0
244 ; CHECK-NEXT: }
245
246 define i32 @load_from_6xi16_unaligned(<6 x i16>*) {
247 entry:
248 %1 = load <6 x i16>, <6 x i16>* %0
249 ret i32 0
250 }
251 ; CHECK-LABEL: define i32 @load_from_6xi16_unaligned(<6 x i16>*) {
252 ; CHECK: entry:
253 ; CHECK-NEXT: %1 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 0
254 ; CHECK-NEXT: %2 = load i16, i16* %1
255 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
256 ; CHECK-NEXT: %4 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 1
257 ; CHECK-NEXT: %5 = load i16, i16* %4
258 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
259 ; CHECK-NEXT: %7 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 2
260 ; CHECK-NEXT: %8 = load i16, i16* %7
261 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
262 ; CHECK-NEXT: %10 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 3
263 ; CHECK-NEXT: %11 = load i16, i16* %10
264 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
265 ; CHECK-NEXT: %13 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 4
266 ; CHECK-NEXT: %14 = load i16, i16* %13
267 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 4
268 ; CHECK-NEXT: %16 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 5
269 ; CHECK-NEXT: %17 = load i16, i16* %16
270 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 5
271 ; CHECK-NEXT: ret i32 0
272 ; CHECK-NEXT: }
273
274 define i32 @load_from_6xi32_unaligned(<6 x i32>*) {
275 entry:
276 %1 = load <6 x i32>, <6 x i32>* %0
277 ret i32 0
278 }
279 ; CHECK-LABEL: define i32 @load_from_6xi32_unaligned(<6 x i32>*) {
280 ; CHECK: entry:
281 ; CHECK-NEXT: %1 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 0
282 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
283 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2
284 ; CHECK-NEXT: %4 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 4
285 ; CHECK-NEXT: %5 = load i32, i32* %4
286 ; CHECK-NEXT: %6 = insertelement <4 x i32> undef, i32 %5, i32 0
287 ; CHECK-NEXT: %7 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 5
288 ; CHECK-NEXT: %8 = load i32, i32* %7
289 ; CHECK-NEXT: %9 = insertelement <4 x i32> %6, i32 %8, i32 1
290 ; CHECK-NEXT: ret i32 0
291 ; CHECK-NEXT: }
292
293 define i32 @load_from_6xi64_unaligned(<6 x i64>*) {
294 entry:
295 %1 = load <6 x i64>, <6 x i64>* %0
296 ret i32 0
297 }
298 ; CHECK-LABEL: define i32 @load_from_6xi64_unaligned(<6 x i64>*) {
299 ; CHECK: entry:
300 ; CHECK-NEXT: %1 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 0
301 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
302 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
303 ; CHECK-NEXT: %4 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 2
304 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
305 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
306 ; CHECK-NEXT: %7 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 4
307 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
308 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8
309 ; CHECK-NEXT: ret i32 0
310 ; CHECK-NEXT: }
311
312 define i32 @load_from_6xi8ptr_unaligned(<6 x i8*>*) {
313 entry:
314 %1 = load <6 x i8*>, <6 x i8*>* %0
315 ret i32 0
316 }
317 ; CHECK-LABEL: define i32 @load_from_6xi8ptr_unaligned(<6 x i8*>*) {
318 ; CHECK: entry:
319 ; CHECK-NEXT: %1 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 0
320 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
321 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2
322 ; CHECK-NEXT: %4 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 4
323 ; CHECK-NEXT: %5 = load i8*, i8** %4
324 ; CHECK-NEXT: %6 = insertelement <4 x i8*> undef, i8* %5, i32 0
325 ; CHECK-NEXT: %7 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 5
326 ; CHECK-NEXT: %8 = load i8*, i8** %7
327 ; CHECK-NEXT: %9 = insertelement <4 x i8*> %6, i8* %8, i32 1
328 ; CHECK-NEXT: ret i32 0
329 ; CHECK-NEXT: }
330
331 define i32 @load_from_6xfloat_unaligned(<6 x float>*) {
332 entry:
333 %1 = load <6 x float>, <6 x float>* %0
334 ret i32 0
335 }
336 ; CHECK-LABEL: define i32 @load_from_6xfloat_unaligned(<6 x float>*) {
337 ; CHECK: entry:
338 ; CHECK-NEXT: %1 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 0
339 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
340 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2
341 ; CHECK-NEXT: %4 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 4
342 ; CHECK-NEXT: %5 = load float, float* %4
343 ; CHECK-NEXT: %6 = insertelement <4 x float> undef, float %5, i32 0
344 ; CHECK-NEXT: %7 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 5
345 ; CHECK-NEXT: %8 = load float, float* %7
346 ; CHECK-NEXT: %9 = insertelement <4 x float> %6, float %8, i32 1
347 ; CHECK-NEXT: ret i32 0
348 ; CHECK-NEXT: }
349
350 define i32 @load_from_6xdouble_unaligned(<6 x double>*) {
351 entry:
352 %1 = load <6 x double>, <6 x double>* %0
353 ret i32 0
354 }
355 ; CHECK-LABEL: define i32 @load_from_6xdouble_unaligned(<6 x double>*) {
356 ; CHECK: entry:
357 ; CHECK-NEXT: %1 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 0
358 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
359 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
360 ; CHECK-NEXT: %4 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 2
361 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
362 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
363 ; CHECK-NEXT: %7 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 4
364 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
365 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8
366 ; CHECK-NEXT: ret i32 0
367 ; CHECK-NEXT: }
368
369 define i32 @load_from_8xi8_unaligned(<8 x i8>*) {
370 entry:
371 %1 = load <8 x i8>, <8 x i8>* %0
372 ret i32 0
373 }
374 ; CHECK-LABEL: define i32 @load_from_8xi8_unaligned(<8 x i8>*) {
375 ; CHECK: entry:
376 ; CHECK-NEXT: %1 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 0
377 ; CHECK-NEXT: %2 = load i8, i8* %1
378 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
379 ; CHECK-NEXT: %4 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 1
380 ; CHECK-NEXT: %5 = load i8, i8* %4
381 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
382 ; CHECK-NEXT: %7 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 2
383 ; CHECK-NEXT: %8 = load i8, i8* %7
384 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
385 ; CHECK-NEXT: %10 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 3
386 ; CHECK-NEXT: %11 = load i8, i8* %10
387 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
388 ; CHECK-NEXT: %13 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 4
389 ; CHECK-NEXT: %14 = load i8, i8* %13
390 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
391 ; CHECK-NEXT: %16 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 5
392 ; CHECK-NEXT: %17 = load i8, i8* %16
393 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
394 ; CHECK-NEXT: %19 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 6
395 ; CHECK-NEXT: %20 = load i8, i8* %19
396 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
397 ; CHECK-NEXT: %22 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 7
398 ; CHECK-NEXT: %23 = load i8, i8* %22
399 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
400 ; CHECK-NEXT: ret i32 0
401 ; CHECK-NEXT: }
402
403 define i32 @load_from_8xi16_unaligned(<8 x i16>*) {
404 entry:
405 %1 = load <8 x i16>, <8 x i16>* %0
406 ret i32 0
407 }
408 ; CHECK-LABEL: define i32 @load_from_8xi16_unaligned(<8 x i16>*) {
409 ; CHECK: entry:
410 ; CHECK-NEXT: %1 = load <8 x i16>, <8 x i16>* %0
411 ; CHECK-NEXT: ret i32 0
412 ; CHECK-NEXT: }
413
414 define i32 @load_from_8xi32_unaligned(<8 x i32>*) {
415 entry:
416 %1 = load <8 x i32>, <8 x i32>* %0
417 ret i32 0
418 }
419 ; CHECK-LABEL: define i32 @load_from_8xi32_unaligned(<8 x i32>*) {
420 ; CHECK: entry:
421 ; CHECK-NEXT: %1 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 0
422 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
423 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2
424 ; CHECK-NEXT: %4 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 4
425 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
426 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5
427 ; CHECK-NEXT: ret i32 0
428 ; CHECK-NEXT: }
429
430 define i32 @load_from_8xi64_unaligned(<8 x i64>*) {
431 entry:
432 %1 = load <8 x i64>, <8 x i64>* %0
433 ret i32 0
434 }
435 ; CHECK-LABEL: define i32 @load_from_8xi64_unaligned(<8 x i64>*) {
436 ; CHECK: entry:
437 ; CHECK-NEXT: %1 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 0
438 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
439 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
440 ; CHECK-NEXT: %4 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 2
441 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
442 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
443 ; CHECK-NEXT: %7 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 4
444 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
445 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8
446 ; CHECK-NEXT: %10 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 6
447 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
448 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11
449 ; CHECK-NEXT: ret i32 0
450 ; CHECK-NEXT: }
451
452 define i32 @load_from_8xi8ptr_unaligned(<8 x i8*>*) {
453 entry:
454 %1 = load <8 x i8*>, <8 x i8*>* %0
455 ret i32 0
456 }
457 ; CHECK-LABEL: define i32 @load_from_8xi8ptr_unaligned(<8 x i8*>*) {
458 ; CHECK: entry:
459 ; CHECK-NEXT: %1 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 0
460 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
461 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2
462 ; CHECK-NEXT: %4 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 4
463 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
464 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5
465 ; CHECK-NEXT: ret i32 0
466 ; CHECK-NEXT: }
467
468 define i32 @load_from_8xfloat_unaligned(<8 x float>*) {
469 entry:
470 %1 = load <8 x float>, <8 x float>* %0
471 ret i32 0
472 }
473 ; CHECK-LABEL: define i32 @load_from_8xfloat_unaligned(<8 x float>*) {
474 ; CHECK: entry:
475 ; CHECK-NEXT: %1 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 0
476 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
477 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2
478 ; CHECK-NEXT: %4 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 4
479 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
480 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5
481 ; CHECK-NEXT: ret i32 0
482 ; CHECK-NEXT: }
483
484 define i32 @load_from_8xdouble_unaligned(<8 x double>*) {
485 entry:
486 %1 = load <8 x double>, <8 x double>* %0
487 ret i32 0
488 }
489 ; CHECK-LABEL: define i32 @load_from_8xdouble_unaligned(<8 x double>*) {
490 ; CHECK: entry:
491 ; CHECK-NEXT: %1 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 0
492 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
493 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
494 ; CHECK-NEXT: %4 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 2
495 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
496 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
497 ; CHECK-NEXT: %7 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 4
498 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
499 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8
500 ; CHECK-NEXT: %10 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 6
501 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
502 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11
503 ; CHECK-NEXT: ret i32 0
504 ; CHECK-NEXT: }
505
506 define i32 @load_from_12xi8_unaligned(<12 x i8>*) {
507 entry:
508 %1 = load <12 x i8>, <12 x i8>* %0
509 ret i32 0
510 }
511 ; CHECK-LABEL: define i32 @load_from_12xi8_unaligned(<12 x i8>*) {
512 ; CHECK: entry:
513 ; CHECK-NEXT: %1 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 0
514 ; CHECK-NEXT: %2 = load i8, i8* %1
515 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
516 ; CHECK-NEXT: %4 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 1
517 ; CHECK-NEXT: %5 = load i8, i8* %4
518 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
519 ; CHECK-NEXT: %7 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 2
520 ; CHECK-NEXT: %8 = load i8, i8* %7
521 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
522 ; CHECK-NEXT: %10 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 3
523 ; CHECK-NEXT: %11 = load i8, i8* %10
524 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
525 ; CHECK-NEXT: %13 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 4
526 ; CHECK-NEXT: %14 = load i8, i8* %13
527 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
528 ; CHECK-NEXT: %16 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 5
529 ; CHECK-NEXT: %17 = load i8, i8* %16
530 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
531 ; CHECK-NEXT: %19 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 6
532 ; CHECK-NEXT: %20 = load i8, i8* %19
533 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
534 ; CHECK-NEXT: %22 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 7
535 ; CHECK-NEXT: %23 = load i8, i8* %22
536 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
537 ; CHECK-NEXT: %25 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 8
538 ; CHECK-NEXT: %26 = load i8, i8* %25
539 ; CHECK-NEXT: %27 = insertelement <16 x i8> %24, i8 %26, i32 8
540 ; CHECK-NEXT: %28 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 9
541 ; CHECK-NEXT: %29 = load i8, i8* %28
542 ; CHECK-NEXT: %30 = insertelement <16 x i8> %27, i8 %29, i32 9
543 ; CHECK-NEXT: %31 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 10
544 ; CHECK-NEXT: %32 = load i8, i8* %31
545 ; CHECK-NEXT: %33 = insertelement <16 x i8> %30, i8 %32, i32 10
546 ; CHECK-NEXT: %34 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 11
547 ; CHECK-NEXT: %35 = load i8, i8* %34
548 ; CHECK-NEXT: %36 = insertelement <16 x i8> %33, i8 %35, i32 11
549 ; CHECK-NEXT: ret i32 0
550 ; CHECK-NEXT: }
551
552 define i32 @load_from_12xi16_unaligned(<12 x i16>*) {
553 entry:
554 %1 = load <12 x i16>, <12 x i16>* %0
555 ret i32 0
556 }
557 ; CHECK-LABEL: define i32 @load_from_12xi16_unaligned(<12 x i16>*) {
558 ; CHECK: entry:
559 ; CHECK-NEXT: %1 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 0
560 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
561 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2
562 ; CHECK-NEXT: %4 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 8
563 ; CHECK-NEXT: %5 = load i16, i16* %4
564 ; CHECK-NEXT: %6 = insertelement <8 x i16> undef, i16 %5, i32 0
565 ; CHECK-NEXT: %7 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 9
566 ; CHECK-NEXT: %8 = load i16, i16* %7
567 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 1
568 ; CHECK-NEXT: %10 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 10
569 ; CHECK-NEXT: %11 = load i16, i16* %10
570 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 2
571 ; CHECK-NEXT: %13 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 11
572 ; CHECK-NEXT: %14 = load i16, i16* %13
573 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 3
574 ; CHECK-NEXT: ret i32 0
575 ; CHECK-NEXT: }
576
577 define i32 @load_from_12xi32_unaligned(<12 x i32>*) {
578 entry:
579 %1 = load <12 x i32>, <12 x i32>* %0
580 ret i32 0
581 }
582 ; CHECK-LABEL: define i32 @load_from_12xi32_unaligned(<12 x i32>*) {
583 ; CHECK: entry:
584 ; CHECK-NEXT: %1 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 0
585 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
586 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2
587 ; CHECK-NEXT: %4 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 4
588 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
589 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5
590 ; CHECK-NEXT: %7 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 8
591 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
592 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8
593 ; CHECK-NEXT: ret i32 0
594 ; CHECK-NEXT: }
595
596 define i32 @load_from_12xi64_unaligned(<12 x i64>*) {
597 entry:
598 %1 = load <12 x i64>, <12 x i64>* %0
599 ret i32 0
600 }
601 ; CHECK-LABEL: define i32 @load_from_12xi64_unaligned(<12 x i64>*) {
602 ; CHECK: entry:
603 ; CHECK-NEXT: %1 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 0
604 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
605 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
606 ; CHECK-NEXT: %4 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 2
607 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
608 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
609 ; CHECK-NEXT: %7 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 4
610 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
611 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8
612 ; CHECK-NEXT: %10 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 6
613 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
614 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11
615 ; CHECK-NEXT: %13 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 8
616 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
617 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14
618 ; CHECK-NEXT: %16 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 10
619 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
620 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17
621 ; CHECK-NEXT: ret i32 0
622 ; CHECK-NEXT: }
623
624 define i32 @load_from_12xi8ptr_unaligned(<12 x i8*>*) {
625 entry:
626 %1 = load <12 x i8*>, <12 x i8*>* %0
627 ret i32 0
628 }
629 ; CHECK-LABEL: define i32 @load_from_12xi8ptr_unaligned(<12 x i8*>*) {
630 ; CHECK: entry:
631 ; CHECK-NEXT: %1 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 0
632 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
633 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2
634 ; CHECK-NEXT: %4 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 4
635 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
636 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5
637 ; CHECK-NEXT: %7 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 8
638 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
639 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8
640 ; CHECK-NEXT: ret i32 0
641 ; CHECK-NEXT: }
642
643 define i32 @load_from_12xfloat_unaligned(<12 x float>*) {
644 entry:
645 %1 = load <12 x float>, <12 x float>* %0
646 ret i32 0
647 }
648 ; CHECK-LABEL: define i32 @load_from_12xfloat_unaligned(<12 x float>*) {
649 ; CHECK: entry:
650 ; CHECK-NEXT: %1 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 0
651 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
652 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2
653 ; CHECK-NEXT: %4 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 4
654 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
655 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5
656 ; CHECK-NEXT: %7 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 8
657 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
658 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8
659 ; CHECK-NEXT: ret i32 0
660 ; CHECK-NEXT: }
661
662 define i32 @load_from_12xdouble_unaligned(<12 x double>*) {
663 entry:
664 %1 = load <12 x double>, <12 x double>* %0
665 ret i32 0
666 }
667 ; CHECK-LABEL: define i32 @load_from_12xdouble_unaligned(<12 x double>*) {
668 ; CHECK: entry:
669 ; CHECK-NEXT: %1 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 0
670 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
671 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
672 ; CHECK-NEXT: %4 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 2
673 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
674 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
675 ; CHECK-NEXT: %7 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 4
676 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
677 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8
678 ; CHECK-NEXT: %10 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 6
679 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
680 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11
681 ; CHECK-NEXT: %13 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 8
682 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
683 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14
684 ; CHECK-NEXT: %16 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 10
685 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
686 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17
687 ; CHECK-NEXT: ret i32 0
688 ; CHECK-NEXT: }
689
690 define i32 @load_from_16xi8_unaligned(<16 x i8>*) {
691 entry:
692 %1 = load <16 x i8>, <16 x i8>* %0
693 ret i32 0
694 }
695 ; CHECK-LABEL: define i32 @load_from_16xi8_unaligned(<16 x i8>*) {
696 ; CHECK: entry:
697 ; CHECK-NEXT: %1 = load <16 x i8>, <16 x i8>* %0
698 ; CHECK-NEXT: ret i32 0
699 ; CHECK-NEXT: }
700
701 define i32 @load_from_16xi16_unaligned(<16 x i16>*) {
702 entry:
703 %1 = load <16 x i16>, <16 x i16>* %0
704 ret i32 0
705 }
706 ; CHECK-LABEL: define i32 @load_from_16xi16_unaligned(<16 x i16>*) {
707 ; CHECK: entry:
708 ; CHECK-NEXT: %1 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 0
709 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
710 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2
711 ; CHECK-NEXT: %4 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 8
712 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
713 ; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5
714 ; CHECK-NEXT: ret i32 0
715 ; CHECK-NEXT: }
716
717 define i32 @load_from_16xi32_unaligned(<16 x i32>*) {
718 entry:
719 %1 = load <16 x i32>, <16 x i32>* %0
720 ret i32 0
721 }
722 ; CHECK-LABEL: define i32 @load_from_16xi32_unaligned(<16 x i32>*) {
723 ; CHECK: entry:
724 ; CHECK-NEXT: %1 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 0
725 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
726 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2
727 ; CHECK-NEXT: %4 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 4
728 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
729 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5
730 ; CHECK-NEXT: %7 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 8
731 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
732 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8
733 ; CHECK-NEXT: %10 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 12
734 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
735 ; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11
736 ; CHECK-NEXT: ret i32 0
737 ; CHECK-NEXT: }
738
739 define i32 @load_from_16xi64_unaligned(<16 x i64>*) {
740 entry:
741 %1 = load <16 x i64>, <16 x i64>* %0
742 ret i32 0
743 }
744 ; CHECK-LABEL: define i32 @load_from_16xi64_unaligned(<16 x i64>*) {
745 ; CHECK: entry:
746 ; CHECK-NEXT: %1 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 0
747 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
748 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
749 ; CHECK-NEXT: %4 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 2
750 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
751 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
752 ; CHECK-NEXT: %7 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 4
753 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
754 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8
755 ; CHECK-NEXT: %10 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 6
756 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
757 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11
758 ; CHECK-NEXT: %13 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 8
759 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
760 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14
761 ; CHECK-NEXT: %16 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 10
762 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
763 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17
764 ; CHECK-NEXT: %19 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 12
765 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
766 ; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20
767 ; CHECK-NEXT: %22 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 14
768 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
769 ; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23
770 ; CHECK-NEXT: ret i32 0
771 ; CHECK-NEXT: }
772
773 define i32 @load_from_16xi8ptr_unaligned(<16 x i8*>*) {
774 entry:
775 %1 = load <16 x i8*>, <16 x i8*>* %0
776 ret i32 0
777 }
778 ; CHECK-LABEL: define i32 @load_from_16xi8ptr_unaligned(<16 x i8*>*) {
779 ; CHECK: entry:
780 ; CHECK-NEXT: %1 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 0
781 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
782 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2
783 ; CHECK-NEXT: %4 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 4
784 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
785 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5
786 ; CHECK-NEXT: %7 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 8
787 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
788 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8
789 ; CHECK-NEXT: %10 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 12
790 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
791 ; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11
792 ; CHECK-NEXT: ret i32 0
793 ; CHECK-NEXT: }
794
795 define i32 @load_from_16xfloat_unaligned(<16 x float>*) {
796 entry:
797 %1 = load <16 x float>, <16 x float>* %0
798 ret i32 0
799 }
800 ; CHECK-LABEL: define i32 @load_from_16xfloat_unaligned(<16 x float>*) {
801 ; CHECK: entry:
802 ; CHECK-NEXT: %1 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 0
803 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
804 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2
805 ; CHECK-NEXT: %4 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 4
806 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
807 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5
808 ; CHECK-NEXT: %7 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 8
809 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
810 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8
811 ; CHECK-NEXT: %10 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 12
812 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
813 ; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11
814 ; CHECK-NEXT: ret i32 0
815 ; CHECK-NEXT: }
816
817 define i32 @load_from_16xdouble_unaligned(<16 x double>*) {
818 entry:
819 %1 = load <16 x double>, <16 x double>* %0
820 ret i32 0
821 }
822 ; CHECK-LABEL: define i32 @load_from_16xdouble_unaligned(<16 x double>*) {
823 ; CHECK: entry:
824 ; CHECK-NEXT: %1 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 0
825 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
826 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
827 ; CHECK-NEXT: %4 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 2
828 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
829 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
830 ; CHECK-NEXT: %7 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 4
831 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
832 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8
833 ; CHECK-NEXT: %10 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 6
834 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
835 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11
836 ; CHECK-NEXT: %13 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 8
837 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
838 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14
839 ; CHECK-NEXT: %16 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 10
840 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
841 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17
842 ; CHECK-NEXT: %19 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 12
843 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
844 ; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20
845 ; CHECK-NEXT: %22 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 14
846 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
847 ; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23
848 ; CHECK-NEXT: ret i32 0
849 ; CHECK-NEXT: }
850
851 define i32 @load_from_20xi8_unaligned(<20 x i8>*) {
852 entry:
853 %1 = load <20 x i8>, <20 x i8>* %0
854 ret i32 0
855 }
856 ; CHECK-LABEL: define i32 @load_from_20xi8_unaligned(<20 x i8>*) {
857 ; CHECK: entry:
858 ; CHECK-NEXT: %1 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 0
859 ; CHECK-NEXT: %2 = bitcast i8* %1 to <16 x i8>*
860 ; CHECK-NEXT: %3 = load <16 x i8>, <16 x i8>* %2
861 ; CHECK-NEXT: %4 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 16
862 ; CHECK-NEXT: %5 = load i8, i8* %4
863 ; CHECK-NEXT: %6 = insertelement <16 x i8> undef, i8 %5, i32 0
864 ; CHECK-NEXT: %7 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 17
865 ; CHECK-NEXT: %8 = load i8, i8* %7
866 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 1
867 ; CHECK-NEXT: %10 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 18
868 ; CHECK-NEXT: %11 = load i8, i8* %10
869 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 2
870 ; CHECK-NEXT: %13 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 19
871 ; CHECK-NEXT: %14 = load i8, i8* %13
872 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 3
873 ; CHECK-NEXT: ret i32 0
874 ; CHECK-NEXT: }
875
876 define i32 @load_from_20xi16_unaligned(<20 x i16>*) {
877 entry:
878 %1 = load <20 x i16>, <20 x i16>* %0
879 ret i32 0
880 }
881 ; CHECK-LABEL: define i32 @load_from_20xi16_unaligned(<20 x i16>*) {
882 ; CHECK: entry:
883 ; CHECK-NEXT: %1 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 0
884 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
885 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2
886 ; CHECK-NEXT: %4 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 8
887 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
888 ; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5
889 ; CHECK-NEXT: %7 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 16
890 ; CHECK-NEXT: %8 = load i16, i16* %7
891 ; CHECK-NEXT: %9 = insertelement <8 x i16> undef, i16 %8, i32 0
892 ; CHECK-NEXT: %10 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 17
893 ; CHECK-NEXT: %11 = load i16, i16* %10
894 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 1
895 ; CHECK-NEXT: %13 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 18
896 ; CHECK-NEXT: %14 = load i16, i16* %13
897 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 2
898 ; CHECK-NEXT: %16 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 19
899 ; CHECK-NEXT: %17 = load i16, i16* %16
900 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 3
901 ; CHECK-NEXT: ret i32 0
902 ; CHECK-NEXT: }
903
904 define i32 @load_from_20xi32_unaligned(<20 x i32>*) {
905 entry:
906 %1 = load <20 x i32>, <20 x i32>* %0
907 ret i32 0
908 }
909 ; CHECK-LABEL: define i32 @load_from_20xi32_unaligned(<20 x i32>*) {
910 ; CHECK: entry:
911 ; CHECK-NEXT: %1 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 0
912 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
913 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2
914 ; CHECK-NEXT: %4 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 4
915 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
916 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5
917 ; CHECK-NEXT: %7 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 8
918 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
919 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8
920 ; CHECK-NEXT: %10 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 12
921 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
922 ; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11
923 ; CHECK-NEXT: %13 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 16
924 ; CHECK-NEXT: %14 = bitcast i32* %13 to <4 x i32>*
925 ; CHECK-NEXT: %15 = load <4 x i32>, <4 x i32>* %14
926 ; CHECK-NEXT: ret i32 0
927 ; CHECK-NEXT: }
928
929 define i32 @load_from_20xi64_unaligned(<20 x i64>*) {
930 entry:
931 %1 = load <20 x i64>, <20 x i64>* %0
932 ret i32 0
933 }
934 ; CHECK-LABEL: define i32 @load_from_20xi64_unaligned(<20 x i64>*) {
935 ; CHECK: entry:
936 ; CHECK-NEXT: %1 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 0
937 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
938 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2
939 ; CHECK-NEXT: %4 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 2
940 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
941 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5
942 ; CHECK-NEXT: %7 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 4
943 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
944 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8
945 ; CHECK-NEXT: %10 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 6
946 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
947 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11
948 ; CHECK-NEXT: %13 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 8
949 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
950 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14
951 ; CHECK-NEXT: %16 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 10
952 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
953 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17
954 ; CHECK-NEXT: %19 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 12
955 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
956 ; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20
957 ; CHECK-NEXT: %22 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 14
958 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
959 ; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23
960 ; CHECK-NEXT: %25 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 16
961 ; CHECK-NEXT: %26 = bitcast i64* %25 to <2 x i64>*
962 ; CHECK-NEXT: %27 = load <2 x i64>, <2 x i64>* %26
963 ; CHECK-NEXT: %28 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 18
964 ; CHECK-NEXT: %29 = bitcast i64* %28 to <2 x i64>*
965 ; CHECK-NEXT: %30 = load <2 x i64>, <2 x i64>* %29
966 ; CHECK-NEXT: ret i32 0
967 ; CHECK-NEXT: }
968
969 define i32 @load_from_20xi8ptr_unaligned(<20 x i8*>*) {
970 entry:
971 %1 = load <20 x i8*>, <20 x i8*>* %0
972 ret i32 0
973 }
974 ; CHECK-LABEL: define i32 @load_from_20xi8ptr_unaligned(<20 x i8*>*) {
975 ; CHECK: entry:
976 ; CHECK-NEXT: %1 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 0
977 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
978 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2
979 ; CHECK-NEXT: %4 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 4
980 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
981 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5
982 ; CHECK-NEXT: %7 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 8
983 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
984 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8
985 ; CHECK-NEXT: %10 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 12
986 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
987 ; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11
988 ; CHECK-NEXT: %13 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 16
989 ; CHECK-NEXT: %14 = bitcast i8** %13 to <4 x i8*>*
990 ; CHECK-NEXT: %15 = load <4 x i8*>, <4 x i8*>* %14
991 ; CHECK-NEXT: ret i32 0
992 ; CHECK-NEXT: }
993
994 define i32 @load_from_20xfloat_unaligned(<20 x float>*) {
995 entry:
996 %1 = load <20 x float>, <20 x float>* %0
997 ret i32 0
998 }
999 ; CHECK-LABEL: define i32 @load_from_20xfloat_unaligned(<20 x float>*) {
1000 ; CHECK: entry:
1001 ; CHECK-NEXT: %1 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 0
1002 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
1003 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2
1004 ; CHECK-NEXT: %4 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 4
1005 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
1006 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5
1007 ; CHECK-NEXT: %7 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 8
1008 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
1009 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8
1010 ; CHECK-NEXT: %10 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 12
1011 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
1012 ; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11
1013 ; CHECK-NEXT: %13 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 16
1014 ; CHECK-NEXT: %14 = bitcast float* %13 to <4 x float>*
1015 ; CHECK-NEXT: %15 = load <4 x float>, <4 x float>* %14
1016 ; CHECK-NEXT: ret i32 0
1017 ; CHECK-NEXT: }
1018
1019 define i32 @load_from_20xdouble_unaligned(<20 x double>*) {
1020 entry:
1021 %1 = load <20 x double>, <20 x double>* %0
1022 ret i32 0
1023 }
1024 ; CHECK-LABEL: define i32 @load_from_20xdouble_unaligned(<20 x double>*) {
1025 ; CHECK: entry:
1026 ; CHECK-NEXT: %1 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 0
1027 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
1028 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2
1029 ; CHECK-NEXT: %4 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 2
1030 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
1031 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5
1032 ; CHECK-NEXT: %7 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 4
1033 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
1034 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8
1035 ; CHECK-NEXT: %10 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 6
1036 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
1037 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11
1038 ; CHECK-NEXT: %13 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 8
1039 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
1040 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14
1041 ; CHECK-NEXT: %16 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 10
1042 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
1043 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17
1044 ; CHECK-NEXT: %19 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 12
1045 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
1046 ; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20
1047 ; CHECK-NEXT: %22 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 14
1048 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
1049 ; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23
1050 ; CHECK-NEXT: %25 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 16
1051 ; CHECK-NEXT: %26 = bitcast double* %25 to <2 x double>*
1052 ; CHECK-NEXT: %27 = load <2 x double>, <2 x double>* %26
1053 ; CHECK-NEXT: %28 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 18
1054 ; CHECK-NEXT: %29 = bitcast double* %28 to <2 x double>*
1055 ; CHECK-NEXT: %30 = load <2 x double>, <2 x double>* %29
1056 ; CHECK-NEXT: ret i32 0
1057 ; CHECK-NEXT: }
1058
1059 define i32 @load_from_2xi8_align_1(<2 x i8>*) {
1060 entry:
1061 %1 = load <2 x i8>, <2 x i8>* %0, align 1
1062 ret i32 0
1063 }
1064 ; CHECK-LABEL: define i32 @load_from_2xi8_align_1(<2 x i8>*) {
1065 ; CHECK: entry:
1066 ; CHECK-NEXT: %1 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 0
1067 ; CHECK-NEXT: %2 = load i8, i8* %1, align 1
1068 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
1069 ; CHECK-NEXT: %4 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 1
1070 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
1071 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
1072 ; CHECK-NEXT: ret i32 0
1073 ; CHECK-NEXT: }
1074
1075 define i32 @load_from_2xi16_align_1(<2 x i16>*) {
1076 entry:
1077 %1 = load <2 x i16>, <2 x i16>* %0, align 1
1078 ret i32 0
1079 }
1080 ; CHECK-LABEL: define i32 @load_from_2xi16_align_1(<2 x i16>*) {
1081 ; CHECK: entry:
1082 ; CHECK-NEXT: %1 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 0
1083 ; CHECK-NEXT: %2 = load i16, i16* %1, align 1
1084 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
1085 ; CHECK-NEXT: %4 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 1
1086 ; CHECK-NEXT: %5 = load i16, i16* %4, align 1
1087 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
1088 ; CHECK-NEXT: ret i32 0
1089 ; CHECK-NEXT: }
1090
1091 define i32 @load_from_2xi32_align_1(<2 x i32>*) {
1092 entry:
1093 %1 = load <2 x i32>, <2 x i32>* %0, align 1
1094 ret i32 0
1095 }
1096 ; CHECK-LABEL: define i32 @load_from_2xi32_align_1(<2 x i32>*) {
1097 ; CHECK: entry:
1098 ; CHECK-NEXT: %1 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 0
1099 ; CHECK-NEXT: %2 = load i32, i32* %1, align 1
1100 ; CHECK-NEXT: %3 = insertelement <4 x i32> undef, i32 %2, i32 0
1101 ; CHECK-NEXT: %4 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 1
1102 ; CHECK-NEXT: %5 = load i32, i32* %4, align 1
1103 ; CHECK-NEXT: %6 = insertelement <4 x i32> %3, i32 %5, i32 1
1104 ; CHECK-NEXT: ret i32 0
1105 ; CHECK-NEXT: }
1106
1107 define i32 @load_from_2xi64_align_1(<2 x i64>*) {
1108 entry:
1109 %1 = load <2 x i64>, <2 x i64>* %0, align 1
1110 ret i32 0
1111 }
1112 ; CHECK-LABEL: define i32 @load_from_2xi64_align_1(<2 x i64>*) {
1113 ; CHECK: entry:
1114 ; CHECK-NEXT: %1 = load <2 x i64>, <2 x i64>* %0, align 1
1115 ; CHECK-NEXT: ret i32 0
1116 ; CHECK-NEXT: }
1117
1118 define i32 @load_from_2xi8ptr_align_1(<2 x i8*>*) {
1119 entry:
1120 %1 = load <2 x i8*>, <2 x i8*>* %0, align 1
1121 ret i32 0
1122 }
1123 ; CHECK-LABEL: define i32 @load_from_2xi8ptr_align_1(<2 x i8*>*) {
1124 ; CHECK: entry:
1125 ; CHECK-NEXT: %1 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 0
1126 ; CHECK-NEXT: %2 = load i8*, i8** %1, align 1
1127 ; CHECK-NEXT: %3 = insertelement <4 x i8*> undef, i8* %2, i32 0
1128 ; CHECK-NEXT: %4 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 1
1129 ; CHECK-NEXT: %5 = load i8*, i8** %4, align 1
1130 ; CHECK-NEXT: %6 = insertelement <4 x i8*> %3, i8* %5, i32 1
1131 ; CHECK-NEXT: ret i32 0
1132 ; CHECK-NEXT: }
1133
1134 define i32 @load_from_2xfloat_align_1(<2 x float>*) {
1135 entry:
1136 %1 = load <2 x float>, <2 x float>* %0, align 1
1137 ret i32 0
1138 }
1139 ; CHECK-LABEL: define i32 @load_from_2xfloat_align_1(<2 x float>*) {
1140 ; CHECK: entry:
1141 ; CHECK-NEXT: %1 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 0
1142 ; CHECK-NEXT: %2 = load float, float* %1, align 1
1143 ; CHECK-NEXT: %3 = insertelement <4 x float> undef, float %2, i32 0
1144 ; CHECK-NEXT: %4 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 1
1145 ; CHECK-NEXT: %5 = load float, float* %4, align 1
1146 ; CHECK-NEXT: %6 = insertelement <4 x float> %3, float %5, i32 1
1147 ; CHECK-NEXT: ret i32 0
1148 ; CHECK-NEXT: }
1149
1150 define i32 @load_from_2xdouble_align_1(<2 x double>*) {
1151 entry:
1152 %1 = load <2 x double>, <2 x double>* %0, align 1
1153 ret i32 0
1154 }
1155 ; CHECK-LABEL: define i32 @load_from_2xdouble_align_1(<2 x double>*) {
1156 ; CHECK: entry:
1157 ; CHECK-NEXT: %1 = load <2 x double>, <2 x double>* %0, align 1
1158 ; CHECK-NEXT: ret i32 0
1159 ; CHECK-NEXT: }
1160
1161 define i32 @load_from_4xi8_align_1(<4 x i8>*) {
1162 entry:
1163 %1 = load <4 x i8>, <4 x i8>* %0, align 1
1164 ret i32 0
1165 }
1166 ; CHECK-LABEL: define i32 @load_from_4xi8_align_1(<4 x i8>*) {
1167 ; CHECK: entry:
1168 ; CHECK-NEXT: %1 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 0
1169 ; CHECK-NEXT: %2 = load i8, i8* %1, align 1
1170 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
1171 ; CHECK-NEXT: %4 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 1
1172 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
1173 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
1174 ; CHECK-NEXT: %7 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 2
1175 ; CHECK-NEXT: %8 = load i8, i8* %7, align 1
1176 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
1177 ; CHECK-NEXT: %10 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 3
1178 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
1179 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
1180 ; CHECK-NEXT: ret i32 0
1181 ; CHECK-NEXT: }
1182
1183 define i32 @load_from_4xi16_align_1(<4 x i16>*) {
1184 entry:
1185 %1 = load <4 x i16>, <4 x i16>* %0, align 1
1186 ret i32 0
1187 }
1188 ; CHECK-LABEL: define i32 @load_from_4xi16_align_1(<4 x i16>*) {
1189 ; CHECK: entry:
1190 ; CHECK-NEXT: %1 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 0
1191 ; CHECK-NEXT: %2 = load i16, i16* %1, align 1
1192 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
1193 ; CHECK-NEXT: %4 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 1
1194 ; CHECK-NEXT: %5 = load i16, i16* %4, align 1
1195 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
1196 ; CHECK-NEXT: %7 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 2
1197 ; CHECK-NEXT: %8 = load i16, i16* %7, align 1
1198 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
1199 ; CHECK-NEXT: %10 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 3
1200 ; CHECK-NEXT: %11 = load i16, i16* %10, align 1
1201 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
1202 ; CHECK-NEXT: ret i32 0
1203 ; CHECK-NEXT: }
1204
1205 define i32 @load_from_4xi32_align_1(<4 x i32>*) {
1206 entry:
1207 %1 = load <4 x i32>, <4 x i32>* %0, align 1
1208 ret i32 0
1209 }
1210 ; CHECK-LABEL: define i32 @load_from_4xi32_align_1(<4 x i32>*) {
1211 ; CHECK: entry:
1212 ; CHECK-NEXT: %1 = load <4 x i32>, <4 x i32>* %0, align 1
1213 ; CHECK-NEXT: ret i32 0
1214 ; CHECK-NEXT: }
1215
1216 define i32 @load_from_4xi64_align_1(<4 x i64>*) {
1217 entry:
1218 %1 = load <4 x i64>, <4 x i64>* %0, align 1
1219 ret i32 0
1220 }
1221 ; CHECK-LABEL: define i32 @load_from_4xi64_align_1(<4 x i64>*) {
1222 ; CHECK: entry:
1223 ; CHECK-NEXT: %1 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 0
1224 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
1225 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 1
1226 ; CHECK-NEXT: %4 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 2
1227 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
1228 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 1
1229 ; CHECK-NEXT: ret i32 0
1230 ; CHECK-NEXT: }
1231
1232 define i32 @load_from_4xi8ptr_align_1(<4 x i8*>*) {
1233 entry:
1234 %1 = load <4 x i8*>, <4 x i8*>* %0, align 1
1235 ret i32 0
1236 }
1237 ; CHECK-LABEL: define i32 @load_from_4xi8ptr_align_1(<4 x i8*>*) {
1238 ; CHECK: entry:
1239 ; CHECK-NEXT: %1 = load <4 x i8*>, <4 x i8*>* %0, align 1
1240 ; CHECK-NEXT: ret i32 0
1241 ; CHECK-NEXT: }
1242
1243 define i32 @load_from_4xfloat_align_1(<4 x float>*) {
1244 entry:
1245 %1 = load <4 x float>, <4 x float>* %0, align 1
1246 ret i32 0
1247 }
1248 ; CHECK-LABEL: define i32 @load_from_4xfloat_align_1(<4 x float>*) {
1249 ; CHECK: entry:
1250 ; CHECK-NEXT: %1 = load <4 x float>, <4 x float>* %0, align 1
1251 ; CHECK-NEXT: ret i32 0
1252 ; CHECK-NEXT: }
1253
1254 define i32 @load_from_4xdouble_align_1(<4 x double>*) {
1255 entry:
1256 %1 = load <4 x double>, <4 x double>* %0, align 1
1257 ret i32 0
1258 }
1259 ; CHECK-LABEL: define i32 @load_from_4xdouble_align_1(<4 x double>*) {
1260 ; CHECK: entry:
1261 ; CHECK-NEXT: %1 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 0
1262 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
1263 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 1
1264 ; CHECK-NEXT: %4 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 2
1265 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
1266 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 1
1267 ; CHECK-NEXT: ret i32 0
1268 ; CHECK-NEXT: }
1269
1270 define i32 @load_from_6xi8_align_1(<6 x i8>*) {
1271 entry:
1272 %1 = load <6 x i8>, <6 x i8>* %0, align 1
1273 ret i32 0
1274 }
1275 ; CHECK-LABEL: define i32 @load_from_6xi8_align_1(<6 x i8>*) {
1276 ; CHECK: entry:
1277 ; CHECK-NEXT: %1 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 0
1278 ; CHECK-NEXT: %2 = load i8, i8* %1, align 1
1279 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
1280 ; CHECK-NEXT: %4 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 1
1281 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
1282 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
1283 ; CHECK-NEXT: %7 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 2
1284 ; CHECK-NEXT: %8 = load i8, i8* %7, align 1
1285 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
1286 ; CHECK-NEXT: %10 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 3
1287 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
1288 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
1289 ; CHECK-NEXT: %13 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 4
1290 ; CHECK-NEXT: %14 = load i8, i8* %13, align 1
1291 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
1292 ; CHECK-NEXT: %16 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 5
1293 ; CHECK-NEXT: %17 = load i8, i8* %16, align 1
1294 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
1295 ; CHECK-NEXT: ret i32 0
1296 ; CHECK-NEXT: }
1297
1298 define i32 @load_from_6xi16_align_1(<6 x i16>*) {
1299 entry:
1300 %1 = load <6 x i16>, <6 x i16>* %0, align 1
1301 ret i32 0
1302 }
1303 ; CHECK-LABEL: define i32 @load_from_6xi16_align_1(<6 x i16>*) {
1304 ; CHECK: entry:
1305 ; CHECK-NEXT: %1 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 0
1306 ; CHECK-NEXT: %2 = load i16, i16* %1, align 1
1307 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
1308 ; CHECK-NEXT: %4 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 1
1309 ; CHECK-NEXT: %5 = load i16, i16* %4, align 1
1310 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
1311 ; CHECK-NEXT: %7 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 2
1312 ; CHECK-NEXT: %8 = load i16, i16* %7, align 1
1313 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
1314 ; CHECK-NEXT: %10 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 3
1315 ; CHECK-NEXT: %11 = load i16, i16* %10, align 1
1316 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
1317 ; CHECK-NEXT: %13 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 4
1318 ; CHECK-NEXT: %14 = load i16, i16* %13, align 1
1319 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 4
1320 ; CHECK-NEXT: %16 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 5
1321 ; CHECK-NEXT: %17 = load i16, i16* %16, align 1
1322 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 5
1323 ; CHECK-NEXT: ret i32 0
1324 ; CHECK-NEXT: }
1325
1326 define i32 @load_from_6xi32_align_1(<6 x i32>*) {
1327 entry:
1328 %1 = load <6 x i32>, <6 x i32>* %0, align 1
1329 ret i32 0
1330 }
1331 ; CHECK-LABEL: define i32 @load_from_6xi32_align_1(<6 x i32>*) {
1332 ; CHECK: entry:
1333 ; CHECK-NEXT: %1 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 0
1334 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
1335 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 1
1336 ; CHECK-NEXT: %4 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 4
1337 ; CHECK-NEXT: %5 = load i32, i32* %4, align 1
1338 ; CHECK-NEXT: %6 = insertelement <4 x i32> undef, i32 %5, i32 0
1339 ; CHECK-NEXT: %7 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 5
1340 ; CHECK-NEXT: %8 = load i32, i32* %7, align 1
1341 ; CHECK-NEXT: %9 = insertelement <4 x i32> %6, i32 %8, i32 1
1342 ; CHECK-NEXT: ret i32 0
1343 ; CHECK-NEXT: }
1344
1345 define i32 @load_from_6xi64_align_1(<6 x i64>*) {
1346 entry:
1347 %1 = load <6 x i64>, <6 x i64>* %0, align 1
1348 ret i32 0
1349 }
1350 ; CHECK-LABEL: define i32 @load_from_6xi64_align_1(<6 x i64>*) {
1351 ; CHECK: entry:
1352 ; CHECK-NEXT: %1 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 0
1353 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
1354 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 1
1355 ; CHECK-NEXT: %4 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 2
1356 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
1357 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 1
1358 ; CHECK-NEXT: %7 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 4
1359 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
1360 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 1
1361 ; CHECK-NEXT: ret i32 0
1362 ; CHECK-NEXT: }
1363
1364 define i32 @load_from_6xi8ptr_align_1(<6 x i8*>*) {
1365 entry:
1366 %1 = load <6 x i8*>, <6 x i8*>* %0, align 1
1367 ret i32 0
1368 }
1369 ; CHECK-LABEL: define i32 @load_from_6xi8ptr_align_1(<6 x i8*>*) {
1370 ; CHECK: entry:
1371 ; CHECK-NEXT: %1 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 0
1372 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
1373 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 1
1374 ; CHECK-NEXT: %4 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 4
1375 ; CHECK-NEXT: %5 = load i8*, i8** %4, align 1
1376 ; CHECK-NEXT: %6 = insertelement <4 x i8*> undef, i8* %5, i32 0
1377 ; CHECK-NEXT: %7 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 5
1378 ; CHECK-NEXT: %8 = load i8*, i8** %7, align 1
1379 ; CHECK-NEXT: %9 = insertelement <4 x i8*> %6, i8* %8, i32 1
1380 ; CHECK-NEXT: ret i32 0
1381 ; CHECK-NEXT: }
1382
1383 define i32 @load_from_6xfloat_align_1(<6 x float>*) {
1384 entry:
1385 %1 = load <6 x float>, <6 x float>* %0, align 1
1386 ret i32 0
1387 }
1388 ; CHECK-LABEL: define i32 @load_from_6xfloat_align_1(<6 x float>*) {
1389 ; CHECK: entry:
1390 ; CHECK-NEXT: %1 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 0
1391 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
1392 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 1
1393 ; CHECK-NEXT: %4 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 4
1394 ; CHECK-NEXT: %5 = load float, float* %4, align 1
1395 ; CHECK-NEXT: %6 = insertelement <4 x float> undef, float %5, i32 0
1396 ; CHECK-NEXT: %7 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 5
1397 ; CHECK-NEXT: %8 = load float, float* %7, align 1
1398 ; CHECK-NEXT: %9 = insertelement <4 x float> %6, float %8, i32 1
1399 ; CHECK-NEXT: ret i32 0
1400 ; CHECK-NEXT: }
1401
1402 define i32 @load_from_6xdouble_align_1(<6 x double>*) {
1403 entry:
1404 %1 = load <6 x double>, <6 x double>* %0, align 1
1405 ret i32 0
1406 }
1407 ; CHECK-LABEL: define i32 @load_from_6xdouble_align_1(<6 x double>*) {
1408 ; CHECK: entry:
1409 ; CHECK-NEXT: %1 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 0
1410 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
1411 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 1
1412 ; CHECK-NEXT: %4 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 2
1413 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
1414 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 1
1415 ; CHECK-NEXT: %7 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 4
1416 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
1417 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 1
1418 ; CHECK-NEXT: ret i32 0
1419 ; CHECK-NEXT: }
1420
1421 define i32 @load_from_8xi8_align_1(<8 x i8>*) {
1422 entry:
1423 %1 = load <8 x i8>, <8 x i8>* %0, align 1
1424 ret i32 0
1425 }
1426 ; CHECK-LABEL: define i32 @load_from_8xi8_align_1(<8 x i8>*) {
1427 ; CHECK: entry:
1428 ; CHECK-NEXT: %1 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 0
1429 ; CHECK-NEXT: %2 = load i8, i8* %1, align 1
1430 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
1431 ; CHECK-NEXT: %4 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 1
1432 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
1433 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
1434 ; CHECK-NEXT: %7 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 2
1435 ; CHECK-NEXT: %8 = load i8, i8* %7, align 1
1436 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
1437 ; CHECK-NEXT: %10 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 3
1438 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
1439 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
1440 ; CHECK-NEXT: %13 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 4
1441 ; CHECK-NEXT: %14 = load i8, i8* %13, align 1
1442 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
1443 ; CHECK-NEXT: %16 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 5
1444 ; CHECK-NEXT: %17 = load i8, i8* %16, align 1
1445 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
1446 ; CHECK-NEXT: %19 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 6
1447 ; CHECK-NEXT: %20 = load i8, i8* %19, align 1
1448 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
1449 ; CHECK-NEXT: %22 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 7
1450 ; CHECK-NEXT: %23 = load i8, i8* %22, align 1
1451 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
1452 ; CHECK-NEXT: ret i32 0
1453 ; CHECK-NEXT: }
1454
1455 define i32 @load_from_8xi16_align_1(<8 x i16>*) {
1456 entry:
1457 %1 = load <8 x i16>, <8 x i16>* %0, align 1
1458 ret i32 0
1459 }
1460 ; CHECK-LABEL: define i32 @load_from_8xi16_align_1(<8 x i16>*) {
1461 ; CHECK: entry:
1462 ; CHECK-NEXT: %1 = load <8 x i16>, <8 x i16>* %0, align 1
1463 ; CHECK-NEXT: ret i32 0
1464 ; CHECK-NEXT: }
1465
1466 define i32 @load_from_8xi32_align_1(<8 x i32>*) {
1467 entry:
1468 %1 = load <8 x i32>, <8 x i32>* %0, align 1
1469 ret i32 0
1470 }
1471 ; CHECK-LABEL: define i32 @load_from_8xi32_align_1(<8 x i32>*) {
1472 ; CHECK: entry:
1473 ; CHECK-NEXT: %1 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 0
1474 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
1475 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 1
1476 ; CHECK-NEXT: %4 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 4
1477 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
1478 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 1
1479 ; CHECK-NEXT: ret i32 0
1480 ; CHECK-NEXT: }
1481
1482 define i32 @load_from_8xi64_align_1(<8 x i64>*) {
1483 entry:
1484 %1 = load <8 x i64>, <8 x i64>* %0, align 1
1485 ret i32 0
1486 }
1487 ; CHECK-LABEL: define i32 @load_from_8xi64_align_1(<8 x i64>*) {
1488 ; CHECK: entry:
1489 ; CHECK-NEXT: %1 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 0
1490 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
1491 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 1
1492 ; CHECK-NEXT: %4 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 2
1493 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
1494 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 1
1495 ; CHECK-NEXT: %7 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 4
1496 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
1497 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 1
1498 ; CHECK-NEXT: %10 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 6
1499 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
1500 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 1
1501 ; CHECK-NEXT: ret i32 0
1502 ; CHECK-NEXT: }
1503
1504 define i32 @load_from_8xi8ptr_align_1(<8 x i8*>*) {
1505 entry:
1506 %1 = load <8 x i8*>, <8 x i8*>* %0, align 1
1507 ret i32 0
1508 }
1509 ; CHECK-LABEL: define i32 @load_from_8xi8ptr_align_1(<8 x i8*>*) {
1510 ; CHECK: entry:
1511 ; CHECK-NEXT: %1 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 0
1512 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
1513 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 1
1514 ; CHECK-NEXT: %4 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 4
1515 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
1516 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 1
1517 ; CHECK-NEXT: ret i32 0
1518 ; CHECK-NEXT: }
1519
1520 define i32 @load_from_8xfloat_align_1(<8 x float>*) {
1521 entry:
1522 %1 = load <8 x float>, <8 x float>* %0, align 1
1523 ret i32 0
1524 }
1525 ; CHECK-LABEL: define i32 @load_from_8xfloat_align_1(<8 x float>*) {
1526 ; CHECK: entry:
1527 ; CHECK-NEXT: %1 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 0
1528 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
1529 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 1
1530 ; CHECK-NEXT: %4 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 4
1531 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
1532 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 1
1533 ; CHECK-NEXT: ret i32 0
1534 ; CHECK-NEXT: }
1535
1536 define i32 @load_from_8xdouble_align_1(<8 x double>*) {
1537 entry:
1538 %1 = load <8 x double>, <8 x double>* %0, align 1
1539 ret i32 0
1540 }
1541 ; CHECK-LABEL: define i32 @load_from_8xdouble_align_1(<8 x double>*) {
1542 ; CHECK: entry:
1543 ; CHECK-NEXT: %1 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 0
1544 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
1545 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 1
1546 ; CHECK-NEXT: %4 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 2
1547 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
1548 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 1
1549 ; CHECK-NEXT: %7 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 4
1550 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
1551 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 1
1552 ; CHECK-NEXT: %10 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 6
1553 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
1554 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 1
1555 ; CHECK-NEXT: ret i32 0
1556 ; CHECK-NEXT: }
1557
1558 define i32 @load_from_12xi8_align_1(<12 x i8>*) {
1559 entry:
1560 %1 = load <12 x i8>, <12 x i8>* %0, align 1
1561 ret i32 0
1562 }
1563 ; CHECK-LABEL: define i32 @load_from_12xi8_align_1(<12 x i8>*) {
1564 ; CHECK: entry:
1565 ; CHECK-NEXT: %1 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 0
1566 ; CHECK-NEXT: %2 = load i8, i8* %1, align 1
1567 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
1568 ; CHECK-NEXT: %4 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 1
1569 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
1570 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
1571 ; CHECK-NEXT: %7 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 2
1572 ; CHECK-NEXT: %8 = load i8, i8* %7, align 1
1573 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
1574 ; CHECK-NEXT: %10 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 3
1575 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
1576 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
1577 ; CHECK-NEXT: %13 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 4
1578 ; CHECK-NEXT: %14 = load i8, i8* %13, align 1
1579 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
1580 ; CHECK-NEXT: %16 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 5
1581 ; CHECK-NEXT: %17 = load i8, i8* %16, align 1
1582 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
1583 ; CHECK-NEXT: %19 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 6
1584 ; CHECK-NEXT: %20 = load i8, i8* %19, align 1
1585 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
1586 ; CHECK-NEXT: %22 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 7
1587 ; CHECK-NEXT: %23 = load i8, i8* %22, align 1
1588 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
1589 ; CHECK-NEXT: %25 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 8
1590 ; CHECK-NEXT: %26 = load i8, i8* %25, align 1
1591 ; CHECK-NEXT: %27 = insertelement <16 x i8> %24, i8 %26, i32 8
1592 ; CHECK-NEXT: %28 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 9
1593 ; CHECK-NEXT: %29 = load i8, i8* %28, align 1
1594 ; CHECK-NEXT: %30 = insertelement <16 x i8> %27, i8 %29, i32 9
1595 ; CHECK-NEXT: %31 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 10
1596 ; CHECK-NEXT: %32 = load i8, i8* %31, align 1
1597 ; CHECK-NEXT: %33 = insertelement <16 x i8> %30, i8 %32, i32 10
1598 ; CHECK-NEXT: %34 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 11
1599 ; CHECK-NEXT: %35 = load i8, i8* %34, align 1
1600 ; CHECK-NEXT: %36 = insertelement <16 x i8> %33, i8 %35, i32 11
1601 ; CHECK-NEXT: ret i32 0
1602 ; CHECK-NEXT: }
1603
1604 define i32 @load_from_12xi16_align_1(<12 x i16>*) {
1605 entry:
1606 %1 = load <12 x i16>, <12 x i16>* %0, align 1
1607 ret i32 0
1608 }
1609 ; CHECK-LABEL: define i32 @load_from_12xi16_align_1(<12 x i16>*) {
1610 ; CHECK: entry:
1611 ; CHECK-NEXT: %1 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 0
1612 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
1613 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2, align 1
1614 ; CHECK-NEXT: %4 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 8
1615 ; CHECK-NEXT: %5 = load i16, i16* %4, align 1
1616 ; CHECK-NEXT: %6 = insertelement <8 x i16> undef, i16 %5, i32 0
1617 ; CHECK-NEXT: %7 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 9
1618 ; CHECK-NEXT: %8 = load i16, i16* %7, align 1
1619 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 1
1620 ; CHECK-NEXT: %10 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 10
1621 ; CHECK-NEXT: %11 = load i16, i16* %10, align 1
1622 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 2
1623 ; CHECK-NEXT: %13 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 11
1624 ; CHECK-NEXT: %14 = load i16, i16* %13, align 1
1625 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 3
1626 ; CHECK-NEXT: ret i32 0
1627 ; CHECK-NEXT: }
1628
1629 define i32 @load_from_12xi32_align_1(<12 x i32>*) {
1630 entry:
1631 %1 = load <12 x i32>, <12 x i32>* %0, align 1
1632 ret i32 0
1633 }
1634 ; CHECK-LABEL: define i32 @load_from_12xi32_align_1(<12 x i32>*) {
1635 ; CHECK: entry:
1636 ; CHECK-NEXT: %1 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 0
1637 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
1638 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 1
1639 ; CHECK-NEXT: %4 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 4
1640 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
1641 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 1
1642 ; CHECK-NEXT: %7 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 8
1643 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
1644 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8, align 1
1645 ; CHECK-NEXT: ret i32 0
1646 ; CHECK-NEXT: }
1647
1648 define i32 @load_from_12xi64_align_1(<12 x i64>*) {
1649 entry:
1650 %1 = load <12 x i64>, <12 x i64>* %0, align 1
1651 ret i32 0
1652 }
1653 ; CHECK-LABEL: define i32 @load_from_12xi64_align_1(<12 x i64>*) {
1654 ; CHECK: entry:
1655 ; CHECK-NEXT: %1 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 0
1656 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
1657 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 1
1658 ; CHECK-NEXT: %4 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 2
1659 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
1660 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 1
1661 ; CHECK-NEXT: %7 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 4
1662 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
1663 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 1
1664 ; CHECK-NEXT: %10 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 6
1665 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
1666 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 1
1667 ; CHECK-NEXT: %13 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 8
1668 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
1669 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14, align 1
1670 ; CHECK-NEXT: %16 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 10
1671 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
1672 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17, align 1
1673 ; CHECK-NEXT: ret i32 0
1674 ; CHECK-NEXT: }
1675
1676 define i32 @load_from_12xi8ptr_align_1(<12 x i8*>*) {
1677 entry:
1678 %1 = load <12 x i8*>, <12 x i8*>* %0, align 1
1679 ret i32 0
1680 }
1681 ; CHECK-LABEL: define i32 @load_from_12xi8ptr_align_1(<12 x i8*>*) {
1682 ; CHECK: entry:
1683 ; CHECK-NEXT: %1 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 0
1684 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
1685 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 1
1686 ; CHECK-NEXT: %4 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 4
1687 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
1688 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 1
1689 ; CHECK-NEXT: %7 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 8
1690 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
1691 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8, align 1
1692 ; CHECK-NEXT: ret i32 0
1693 ; CHECK-NEXT: }
1694
1695 define i32 @load_from_12xfloat_align_1(<12 x float>*) {
1696 entry:
1697 %1 = load <12 x float>, <12 x float>* %0, align 1
1698 ret i32 0
1699 }
1700 ; CHECK-LABEL: define i32 @load_from_12xfloat_align_1(<12 x float>*) {
1701 ; CHECK: entry:
1702 ; CHECK-NEXT: %1 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 0
1703 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
1704 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 1
1705 ; CHECK-NEXT: %4 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 4
1706 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
1707 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 1
1708 ; CHECK-NEXT: %7 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 8
1709 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
1710 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8, align 1
1711 ; CHECK-NEXT: ret i32 0
1712 ; CHECK-NEXT: }
1713
1714 define i32 @load_from_12xdouble_align_1(<12 x double>*) {
1715 entry:
1716 %1 = load <12 x double>, <12 x double>* %0, align 1
1717 ret i32 0
1718 }
1719 ; CHECK-LABEL: define i32 @load_from_12xdouble_align_1(<12 x double>*) {
1720 ; CHECK: entry:
1721 ; CHECK-NEXT: %1 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 0
1722 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
1723 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 1
1724 ; CHECK-NEXT: %4 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 2
1725 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
1726 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 1
1727 ; CHECK-NEXT: %7 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 4
1728 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
1729 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 1
1730 ; CHECK-NEXT: %10 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 6
1731 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
1732 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 1
1733 ; CHECK-NEXT: %13 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 8
1734 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
1735 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14, align 1
1736 ; CHECK-NEXT: %16 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 10
1737 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
1738 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17, align 1
1739 ; CHECK-NEXT: ret i32 0
1740 ; CHECK-NEXT: }
1741
1742 define i32 @load_from_16xi8_align_1(<16 x i8>*) {
1743 entry:
1744 %1 = load <16 x i8>, <16 x i8>* %0, align 1
1745 ret i32 0
1746 }
1747 ; CHECK-LABEL: define i32 @load_from_16xi8_align_1(<16 x i8>*) {
1748 ; CHECK: entry:
1749 ; CHECK-NEXT: %1 = load <16 x i8>, <16 x i8>* %0, align 1
1750 ; CHECK-NEXT: ret i32 0
1751 ; CHECK-NEXT: }
1752
1753 define i32 @load_from_16xi16_align_1(<16 x i16>*) {
1754 entry:
1755 %1 = load <16 x i16>, <16 x i16>* %0, align 1
1756 ret i32 0
1757 }
1758 ; CHECK-LABEL: define i32 @load_from_16xi16_align_1(<16 x i16>*) {
1759 ; CHECK: entry:
1760 ; CHECK-NEXT: %1 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 0
1761 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
1762 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2, align 1
1763 ; CHECK-NEXT: %4 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 8
1764 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
1765 ; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5, align 1
1766 ; CHECK-NEXT: ret i32 0
1767 ; CHECK-NEXT: }
1768
1769 define i32 @load_from_16xi32_align_1(<16 x i32>*) {
1770 entry:
1771 %1 = load <16 x i32>, <16 x i32>* %0, align 1
1772 ret i32 0
1773 }
1774 ; CHECK-LABEL: define i32 @load_from_16xi32_align_1(<16 x i32>*) {
1775 ; CHECK: entry:
1776 ; CHECK-NEXT: %1 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 0
1777 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
1778 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 1
1779 ; CHECK-NEXT: %4 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 4
1780 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
1781 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 1
1782 ; CHECK-NEXT: %7 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 8
1783 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
1784 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8, align 1
1785 ; CHECK-NEXT: %10 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 12
1786 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
1787 ; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11, align 1
1788 ; CHECK-NEXT: ret i32 0
1789 ; CHECK-NEXT: }
1790
1791 define i32 @load_from_16xi64_align_1(<16 x i64>*) {
1792 entry:
1793 %1 = load <16 x i64>, <16 x i64>* %0, align 1
1794 ret i32 0
1795 }
1796 ; CHECK-LABEL: define i32 @load_from_16xi64_align_1(<16 x i64>*) {
1797 ; CHECK: entry:
1798 ; CHECK-NEXT: %1 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 0
1799 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
1800 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 1
1801 ; CHECK-NEXT: %4 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 2
1802 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
1803 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 1
1804 ; CHECK-NEXT: %7 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 4
1805 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
1806 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 1
1807 ; CHECK-NEXT: %10 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 6
1808 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
1809 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 1
1810 ; CHECK-NEXT: %13 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 8
1811 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
1812 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14, align 1
1813 ; CHECK-NEXT: %16 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 10
1814 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
1815 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17, align 1
1816 ; CHECK-NEXT: %19 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 12
1817 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
1818 ; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20, align 1
1819 ; CHECK-NEXT: %22 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 14
1820 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
1821 ; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23, align 1
1822 ; CHECK-NEXT: ret i32 0
1823 ; CHECK-NEXT: }
1824
1825 define i32 @load_from_16xi8ptr_align_1(<16 x i8*>*) {
1826 entry:
1827 %1 = load <16 x i8*>, <16 x i8*>* %0, align 1
1828 ret i32 0
1829 }
1830 ; CHECK-LABEL: define i32 @load_from_16xi8ptr_align_1(<16 x i8*>*) {
1831 ; CHECK: entry:
1832 ; CHECK-NEXT: %1 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 0
1833 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
1834 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 1
1835 ; CHECK-NEXT: %4 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 4
1836 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
1837 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 1
1838 ; CHECK-NEXT: %7 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 8
1839 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
1840 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8, align 1
1841 ; CHECK-NEXT: %10 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 12
1842 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
1843 ; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11, align 1
1844 ; CHECK-NEXT: ret i32 0
1845 ; CHECK-NEXT: }
1846
1847 define i32 @load_from_16xfloat_align_1(<16 x float>*) {
1848 entry:
1849 %1 = load <16 x float>, <16 x float>* %0, align 1
1850 ret i32 0
1851 }
1852 ; CHECK-LABEL: define i32 @load_from_16xfloat_align_1(<16 x float>*) {
1853 ; CHECK: entry:
1854 ; CHECK-NEXT: %1 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 0
1855 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
1856 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 1
1857 ; CHECK-NEXT: %4 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 4
1858 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
1859 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 1
1860 ; CHECK-NEXT: %7 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 8
1861 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
1862 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8, align 1
1863 ; CHECK-NEXT: %10 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 12
1864 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
1865 ; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11, align 1
1866 ; CHECK-NEXT: ret i32 0
1867 ; CHECK-NEXT: }
1868
1869 define i32 @load_from_16xdouble_align_1(<16 x double>*) {
1870 entry:
1871 %1 = load <16 x double>, <16 x double>* %0, align 1
1872 ret i32 0
1873 }
1874 ; CHECK-LABEL: define i32 @load_from_16xdouble_align_1(<16 x double>*) {
1875 ; CHECK: entry:
1876 ; CHECK-NEXT: %1 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 0
1877 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
1878 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 1
1879 ; CHECK-NEXT: %4 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 2
1880 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
1881 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 1
1882 ; CHECK-NEXT: %7 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 4
1883 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
1884 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 1
1885 ; CHECK-NEXT: %10 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 6
1886 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
1887 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 1
1888 ; CHECK-NEXT: %13 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 8
1889 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
1890 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14, align 1
1891 ; CHECK-NEXT: %16 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 10
1892 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
1893 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17, align 1
1894 ; CHECK-NEXT: %19 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 12
1895 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
1896 ; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20, align 1
1897 ; CHECK-NEXT: %22 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 14
1898 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
1899 ; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23, align 1
1900 ; CHECK-NEXT: ret i32 0
1901 ; CHECK-NEXT: }
1902
1903 define i32 @load_from_20xi8_align_1(<20 x i8>*) {
1904 entry:
1905 %1 = load <20 x i8>, <20 x i8>* %0, align 1
1906 ret i32 0
1907 }
1908 ; CHECK-LABEL: define i32 @load_from_20xi8_align_1(<20 x i8>*) {
1909 ; CHECK: entry:
1910 ; CHECK-NEXT: %1 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 0
1911 ; CHECK-NEXT: %2 = bitcast i8* %1 to <16 x i8>*
1912 ; CHECK-NEXT: %3 = load <16 x i8>, <16 x i8>* %2, align 1
1913 ; CHECK-NEXT: %4 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 16
1914 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
1915 ; CHECK-NEXT: %6 = insertelement <16 x i8> undef, i8 %5, i32 0
1916 ; CHECK-NEXT: %7 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 17
1917 ; CHECK-NEXT: %8 = load i8, i8* %7, align 1
1918 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 1
1919 ; CHECK-NEXT: %10 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 18
1920 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
1921 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 2
1922 ; CHECK-NEXT: %13 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 19
1923 ; CHECK-NEXT: %14 = load i8, i8* %13, align 1
1924 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 3
1925 ; CHECK-NEXT: ret i32 0
1926 ; CHECK-NEXT: }
1927
1928 define i32 @load_from_20xi16_align_1(<20 x i16>*) {
1929 entry:
1930 %1 = load <20 x i16>, <20 x i16>* %0, align 1
1931 ret i32 0
1932 }
1933 ; CHECK-LABEL: define i32 @load_from_20xi16_align_1(<20 x i16>*) {
1934 ; CHECK: entry:
1935 ; CHECK-NEXT: %1 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 0
1936 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
1937 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2, align 1
1938 ; CHECK-NEXT: %4 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 8
1939 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
1940 ; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5, align 1
1941 ; CHECK-NEXT: %7 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 16
1942 ; CHECK-NEXT: %8 = load i16, i16* %7, align 1
1943 ; CHECK-NEXT: %9 = insertelement <8 x i16> undef, i16 %8, i32 0
1944 ; CHECK-NEXT: %10 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 17
1945 ; CHECK-NEXT: %11 = load i16, i16* %10, align 1
1946 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 1
1947 ; CHECK-NEXT: %13 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 18
1948 ; CHECK-NEXT: %14 = load i16, i16* %13, align 1
1949 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 2
1950 ; CHECK-NEXT: %16 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 19
1951 ; CHECK-NEXT: %17 = load i16, i16* %16, align 1
1952 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 3
1953 ; CHECK-NEXT: ret i32 0
1954 ; CHECK-NEXT: }
1955
1956 define i32 @load_from_20xi32_align_1(<20 x i32>*) {
1957 entry:
1958 %1 = load <20 x i32>, <20 x i32>* %0, align 1
1959 ret i32 0
1960 }
1961 ; CHECK-LABEL: define i32 @load_from_20xi32_align_1(<20 x i32>*) {
1962 ; CHECK: entry:
1963 ; CHECK-NEXT: %1 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 0
1964 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
1965 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 1
1966 ; CHECK-NEXT: %4 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 4
1967 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
1968 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 1
1969 ; CHECK-NEXT: %7 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 8
1970 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
1971 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8, align 1
1972 ; CHECK-NEXT: %10 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 12
1973 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
1974 ; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11, align 1
1975 ; CHECK-NEXT: %13 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 16
1976 ; CHECK-NEXT: %14 = bitcast i32* %13 to <4 x i32>*
1977 ; CHECK-NEXT: %15 = load <4 x i32>, <4 x i32>* %14, align 1
1978 ; CHECK-NEXT: ret i32 0
1979 ; CHECK-NEXT: }
1980
1981 define i32 @load_from_20xi64_align_1(<20 x i64>*) {
1982 entry:
1983 %1 = load <20 x i64>, <20 x i64>* %0, align 1
1984 ret i32 0
1985 }
1986 ; CHECK-LABEL: define i32 @load_from_20xi64_align_1(<20 x i64>*) {
1987 ; CHECK: entry:
1988 ; CHECK-NEXT: %1 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 0
1989 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
1990 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 1
1991 ; CHECK-NEXT: %4 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 2
1992 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
1993 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 1
1994 ; CHECK-NEXT: %7 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 4
1995 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
1996 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 1
1997 ; CHECK-NEXT: %10 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 6
1998 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
1999 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 1
2000 ; CHECK-NEXT: %13 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 8
2001 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
2002 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14, align 1
2003 ; CHECK-NEXT: %16 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 10
2004 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
2005 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17, align 1
2006 ; CHECK-NEXT: %19 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 12
2007 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
2008 ; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20, align 1
2009 ; CHECK-NEXT: %22 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 14
2010 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
2011 ; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23, align 1
2012 ; CHECK-NEXT: %25 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 16
2013 ; CHECK-NEXT: %26 = bitcast i64* %25 to <2 x i64>*
2014 ; CHECK-NEXT: %27 = load <2 x i64>, <2 x i64>* %26, align 1
2015 ; CHECK-NEXT: %28 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 18
2016 ; CHECK-NEXT: %29 = bitcast i64* %28 to <2 x i64>*
2017 ; CHECK-NEXT: %30 = load <2 x i64>, <2 x i64>* %29, align 1
2018 ; CHECK-NEXT: ret i32 0
2019 ; CHECK-NEXT: }
2020
2021 define i32 @load_from_20xi8ptr_align_1(<20 x i8*>*) {
2022 entry:
2023 %1 = load <20 x i8*>, <20 x i8*>* %0, align 1
2024 ret i32 0
2025 }
2026 ; CHECK-LABEL: define i32 @load_from_20xi8ptr_align_1(<20 x i8*>*) {
2027 ; CHECK: entry:
2028 ; CHECK-NEXT: %1 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 0
2029 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
2030 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 1
2031 ; CHECK-NEXT: %4 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 4
2032 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
2033 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 1
2034 ; CHECK-NEXT: %7 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 8
2035 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
2036 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8, align 1
2037 ; CHECK-NEXT: %10 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 12
2038 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
2039 ; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11, align 1
2040 ; CHECK-NEXT: %13 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 16
2041 ; CHECK-NEXT: %14 = bitcast i8** %13 to <4 x i8*>*
2042 ; CHECK-NEXT: %15 = load <4 x i8*>, <4 x i8*>* %14, align 1
2043 ; CHECK-NEXT: ret i32 0
2044 ; CHECK-NEXT: }
2045
2046 define i32 @load_from_20xfloat_align_1(<20 x float>*) {
2047 entry:
2048 %1 = load <20 x float>, <20 x float>* %0, align 1
2049 ret i32 0
2050 }
2051 ; CHECK-LABEL: define i32 @load_from_20xfloat_align_1(<20 x float>*) {
2052 ; CHECK: entry:
2053 ; CHECK-NEXT: %1 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 0
2054 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
2055 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 1
2056 ; CHECK-NEXT: %4 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 4
2057 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
2058 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 1
2059 ; CHECK-NEXT: %7 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 8
2060 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
2061 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8, align 1
2062 ; CHECK-NEXT: %10 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 12
2063 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
2064 ; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11, align 1
2065 ; CHECK-NEXT: %13 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 16
2066 ; CHECK-NEXT: %14 = bitcast float* %13 to <4 x float>*
2067 ; CHECK-NEXT: %15 = load <4 x float>, <4 x float>* %14, align 1
2068 ; CHECK-NEXT: ret i32 0
2069 ; CHECK-NEXT: }
2070
2071 define i32 @load_from_20xdouble_align_1(<20 x double>*) {
2072 entry:
2073 %1 = load <20 x double>, <20 x double>* %0, align 1
2074 ret i32 0
2075 }
2076 ; CHECK-LABEL: define i32 @load_from_20xdouble_align_1(<20 x double>*) {
2077 ; CHECK: entry:
2078 ; CHECK-NEXT: %1 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 0
2079 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
2080 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 1
2081 ; CHECK-NEXT: %4 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 2
2082 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
2083 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 1
2084 ; CHECK-NEXT: %7 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 4
2085 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
2086 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 1
2087 ; CHECK-NEXT: %10 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 6
2088 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
2089 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 1
2090 ; CHECK-NEXT: %13 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 8
2091 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
2092 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14, align 1
2093 ; CHECK-NEXT: %16 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 10
2094 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
2095 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17, align 1
2096 ; CHECK-NEXT: %19 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 12
2097 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
2098 ; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20, align 1
2099 ; CHECK-NEXT: %22 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 14
2100 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
2101 ; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23, align 1
2102 ; CHECK-NEXT: %25 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 16
2103 ; CHECK-NEXT: %26 = bitcast double* %25 to <2 x double>*
2104 ; CHECK-NEXT: %27 = load <2 x double>, <2 x double>* %26, align 1
2105 ; CHECK-NEXT: %28 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 18
2106 ; CHECK-NEXT: %29 = bitcast double* %28 to <2 x double>*
2107 ; CHECK-NEXT: %30 = load <2 x double>, <2 x double>* %29, align 1
2108 ; CHECK-NEXT: ret i32 0
2109 ; CHECK-NEXT: }
2110
2111 define i32 @load_from_2xi8_align_8(<2 x i8>*) {
2112 entry:
2113 %1 = load <2 x i8>, <2 x i8>* %0, align 8
2114 ret i32 0
2115 }
2116 ; CHECK-LABEL: define i32 @load_from_2xi8_align_8(<2 x i8>*) {
2117 ; CHECK: entry:
2118 ; CHECK-NEXT: %1 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 0
2119 ; CHECK-NEXT: %2 = load i8, i8* %1, align 8
2120 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
2121 ; CHECK-NEXT: %4 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 1
2122 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
2123 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
2124 ; CHECK-NEXT: ret i32 0
2125 ; CHECK-NEXT: }
2126
2127 define i32 @load_from_2xi16_align_8(<2 x i16>*) {
2128 entry:
2129 %1 = load <2 x i16>, <2 x i16>* %0, align 8
2130 ret i32 0
2131 }
2132 ; CHECK-LABEL: define i32 @load_from_2xi16_align_8(<2 x i16>*) {
2133 ; CHECK: entry:
2134 ; CHECK-NEXT: %1 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 0
2135 ; CHECK-NEXT: %2 = load i16, i16* %1, align 8
2136 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
2137 ; CHECK-NEXT: %4 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 1
2138 ; CHECK-NEXT: %5 = load i16, i16* %4, align 2
2139 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
2140 ; CHECK-NEXT: ret i32 0
2141 ; CHECK-NEXT: }
2142
2143 define i32 @load_from_2xi32_align_8(<2 x i32>*) {
2144 entry:
2145 %1 = load <2 x i32>, <2 x i32>* %0, align 8
2146 ret i32 0
2147 }
2148 ; CHECK-LABEL: define i32 @load_from_2xi32_align_8(<2 x i32>*) {
2149 ; CHECK: entry:
2150 ; CHECK-NEXT: %1 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 0
2151 ; CHECK-NEXT: %2 = load i32, i32* %1, align 8
2152 ; CHECK-NEXT: %3 = insertelement <4 x i32> undef, i32 %2, i32 0
2153 ; CHECK-NEXT: %4 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 1
2154 ; CHECK-NEXT: %5 = load i32, i32* %4, align 4
2155 ; CHECK-NEXT: %6 = insertelement <4 x i32> %3, i32 %5, i32 1
2156 ; CHECK-NEXT: ret i32 0
2157 ; CHECK-NEXT: }
2158
2159 define i32 @load_from_2xi64_align_8(<2 x i64>*) {
2160 entry:
2161 %1 = load <2 x i64>, <2 x i64>* %0, align 8
2162 ret i32 0
2163 }
2164 ; CHECK-LABEL: define i32 @load_from_2xi64_align_8(<2 x i64>*) {
2165 ; CHECK: entry:
2166 ; CHECK-NEXT: %1 = load <2 x i64>, <2 x i64>* %0, align 8
2167 ; CHECK-NEXT: ret i32 0
2168 ; CHECK-NEXT: }
2169
2170 define i32 @load_from_2xi8ptr_align_8(<2 x i8*>*) {
2171 entry:
2172 %1 = load <2 x i8*>, <2 x i8*>* %0, align 8
2173 ret i32 0
2174 }
2175 ; CHECK-LABEL: define i32 @load_from_2xi8ptr_align_8(<2 x i8*>*) {
2176 ; CHECK: entry:
2177 ; CHECK-NEXT: %1 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 0
2178 ; CHECK-NEXT: %2 = load i8*, i8** %1, align 8
2179 ; CHECK-NEXT: %3 = insertelement <4 x i8*> undef, i8* %2, i32 0
2180 ; CHECK-NEXT: %4 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 1
2181 ; CHECK-NEXT: %5 = load i8*, i8** %4, align 4
2182 ; CHECK-NEXT: %6 = insertelement <4 x i8*> %3, i8* %5, i32 1
2183 ; CHECK-NEXT: ret i32 0
2184 ; CHECK-NEXT: }
2185
2186 define i32 @load_from_2xfloat_align_8(<2 x float>*) {
2187 entry:
2188 %1 = load <2 x float>, <2 x float>* %0, align 8
2189 ret i32 0
2190 }
2191 ; CHECK-LABEL: define i32 @load_from_2xfloat_align_8(<2 x float>*) {
2192 ; CHECK: entry:
2193 ; CHECK-NEXT: %1 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 0
2194 ; CHECK-NEXT: %2 = load float, float* %1, align 8
2195 ; CHECK-NEXT: %3 = insertelement <4 x float> undef, float %2, i32 0
2196 ; CHECK-NEXT: %4 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 1
2197 ; CHECK-NEXT: %5 = load float, float* %4, align 4
2198 ; CHECK-NEXT: %6 = insertelement <4 x float> %3, float %5, i32 1
2199 ; CHECK-NEXT: ret i32 0
2200 ; CHECK-NEXT: }
2201
2202 define i32 @load_from_2xdouble_align_8(<2 x double>*) {
2203 entry:
2204 %1 = load <2 x double>, <2 x double>* %0, align 8
2205 ret i32 0
2206 }
2207 ; CHECK-LABEL: define i32 @load_from_2xdouble_align_8(<2 x double>*) {
2208 ; CHECK: entry:
2209 ; CHECK-NEXT: %1 = load <2 x double>, <2 x double>* %0, align 8
2210 ; CHECK-NEXT: ret i32 0
2211 ; CHECK-NEXT: }
2212
2213 define i32 @load_from_4xi8_align_8(<4 x i8>*) {
2214 entry:
2215 %1 = load <4 x i8>, <4 x i8>* %0, align 8
2216 ret i32 0
2217 }
2218 ; CHECK-LABEL: define i32 @load_from_4xi8_align_8(<4 x i8>*) {
2219 ; CHECK: entry:
2220 ; CHECK-NEXT: %1 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 0
2221 ; CHECK-NEXT: %2 = load i8, i8* %1, align 8
2222 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
2223 ; CHECK-NEXT: %4 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 1
2224 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
2225 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
2226 ; CHECK-NEXT: %7 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 2
2227 ; CHECK-NEXT: %8 = load i8, i8* %7, align 2
2228 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
2229 ; CHECK-NEXT: %10 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 3
2230 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
2231 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
2232 ; CHECK-NEXT: ret i32 0
2233 ; CHECK-NEXT: }
2234
2235 define i32 @load_from_4xi16_align_8(<4 x i16>*) {
2236 entry:
2237 %1 = load <4 x i16>, <4 x i16>* %0, align 8
2238 ret i32 0
2239 }
2240 ; CHECK-LABEL: define i32 @load_from_4xi16_align_8(<4 x i16>*) {
2241 ; CHECK: entry:
2242 ; CHECK-NEXT: %1 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 0
2243 ; CHECK-NEXT: %2 = load i16, i16* %1, align 8
2244 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
2245 ; CHECK-NEXT: %4 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 1
2246 ; CHECK-NEXT: %5 = load i16, i16* %4, align 2
2247 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
2248 ; CHECK-NEXT: %7 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 2
2249 ; CHECK-NEXT: %8 = load i16, i16* %7, align 4
2250 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
2251 ; CHECK-NEXT: %10 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 3
2252 ; CHECK-NEXT: %11 = load i16, i16* %10, align 2
2253 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
2254 ; CHECK-NEXT: ret i32 0
2255 ; CHECK-NEXT: }
2256
2257 define i32 @load_from_4xi32_align_8(<4 x i32>*) {
2258 entry:
2259 %1 = load <4 x i32>, <4 x i32>* %0, align 8
2260 ret i32 0
2261 }
2262 ; CHECK-LABEL: define i32 @load_from_4xi32_align_8(<4 x i32>*) {
2263 ; CHECK: entry:
2264 ; CHECK-NEXT: %1 = load <4 x i32>, <4 x i32>* %0, align 8
2265 ; CHECK-NEXT: ret i32 0
2266 ; CHECK-NEXT: }
2267
2268 define i32 @load_from_4xi64_align_8(<4 x i64>*) {
2269 entry:
2270 %1 = load <4 x i64>, <4 x i64>* %0, align 8
2271 ret i32 0
2272 }
2273 ; CHECK-LABEL: define i32 @load_from_4xi64_align_8(<4 x i64>*) {
2274 ; CHECK: entry:
2275 ; CHECK-NEXT: %1 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 0
2276 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
2277 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 8
2278 ; CHECK-NEXT: %4 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 2
2279 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
2280 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 8
2281 ; CHECK-NEXT: ret i32 0
2282 ; CHECK-NEXT: }
2283
2284 define i32 @load_from_4xi8ptr_align_8(<4 x i8*>*) {
2285 entry:
2286 %1 = load <4 x i8*>, <4 x i8*>* %0, align 8
2287 ret i32 0
2288 }
2289 ; CHECK-LABEL: define i32 @load_from_4xi8ptr_align_8(<4 x i8*>*) {
2290 ; CHECK: entry:
2291 ; CHECK-NEXT: %1 = load <4 x i8*>, <4 x i8*>* %0, align 8
2292 ; CHECK-NEXT: ret i32 0
2293 ; CHECK-NEXT: }
2294
2295 define i32 @load_from_4xfloat_align_8(<4 x float>*) {
2296 entry:
2297 %1 = load <4 x float>, <4 x float>* %0, align 8
2298 ret i32 0
2299 }
2300 ; CHECK-LABEL: define i32 @load_from_4xfloat_align_8(<4 x float>*) {
2301 ; CHECK: entry:
2302 ; CHECK-NEXT: %1 = load <4 x float>, <4 x float>* %0, align 8
2303 ; CHECK-NEXT: ret i32 0
2304 ; CHECK-NEXT: }
2305
2306 define i32 @load_from_4xdouble_align_8(<4 x double>*) {
2307 entry:
2308 %1 = load <4 x double>, <4 x double>* %0, align 8
2309 ret i32 0
2310 }
2311 ; CHECK-LABEL: define i32 @load_from_4xdouble_align_8(<4 x double>*) {
2312 ; CHECK: entry:
2313 ; CHECK-NEXT: %1 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 0
2314 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
2315 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 8
2316 ; CHECK-NEXT: %4 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 2
2317 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
2318 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 8
2319 ; CHECK-NEXT: ret i32 0
2320 ; CHECK-NEXT: }
2321
2322 define i32 @load_from_6xi8_align_8(<6 x i8>*) {
2323 entry:
2324 %1 = load <6 x i8>, <6 x i8>* %0, align 8
2325 ret i32 0
2326 }
2327 ; CHECK-LABEL: define i32 @load_from_6xi8_align_8(<6 x i8>*) {
2328 ; CHECK: entry:
2329 ; CHECK-NEXT: %1 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 0
2330 ; CHECK-NEXT: %2 = load i8, i8* %1, align 8
2331 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
2332 ; CHECK-NEXT: %4 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 1
2333 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
2334 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
2335 ; CHECK-NEXT: %7 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 2
2336 ; CHECK-NEXT: %8 = load i8, i8* %7, align 2
2337 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
2338 ; CHECK-NEXT: %10 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 3
2339 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
2340 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
2341 ; CHECK-NEXT: %13 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 4
2342 ; CHECK-NEXT: %14 = load i8, i8* %13, align 4
2343 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
2344 ; CHECK-NEXT: %16 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 5
2345 ; CHECK-NEXT: %17 = load i8, i8* %16, align 1
2346 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
2347 ; CHECK-NEXT: ret i32 0
2348 ; CHECK-NEXT: }
2349
2350 define i32 @load_from_6xi16_align_8(<6 x i16>*) {
2351 entry:
2352 %1 = load <6 x i16>, <6 x i16>* %0, align 8
2353 ret i32 0
2354 }
2355 ; CHECK-LABEL: define i32 @load_from_6xi16_align_8(<6 x i16>*) {
2356 ; CHECK: entry:
2357 ; CHECK-NEXT: %1 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 0
2358 ; CHECK-NEXT: %2 = load i16, i16* %1, align 8
2359 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
2360 ; CHECK-NEXT: %4 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 1
2361 ; CHECK-NEXT: %5 = load i16, i16* %4, align 2
2362 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
2363 ; CHECK-NEXT: %7 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 2
2364 ; CHECK-NEXT: %8 = load i16, i16* %7, align 4
2365 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
2366 ; CHECK-NEXT: %10 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 3
2367 ; CHECK-NEXT: %11 = load i16, i16* %10, align 2
2368 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
2369 ; CHECK-NEXT: %13 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 4
2370 ; CHECK-NEXT: %14 = load i16, i16* %13, align 8
2371 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 4
2372 ; CHECK-NEXT: %16 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 5
2373 ; CHECK-NEXT: %17 = load i16, i16* %16, align 2
2374 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 5
2375 ; CHECK-NEXT: ret i32 0
2376 ; CHECK-NEXT: }
2377
2378 define i32 @load_from_6xi32_align_8(<6 x i32>*) {
2379 entry:
2380 %1 = load <6 x i32>, <6 x i32>* %0, align 8
2381 ret i32 0
2382 }
2383 ; CHECK-LABEL: define i32 @load_from_6xi32_align_8(<6 x i32>*) {
2384 ; CHECK: entry:
2385 ; CHECK-NEXT: %1 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 0
2386 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
2387 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 8
2388 ; CHECK-NEXT: %4 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 4
2389 ; CHECK-NEXT: %5 = load i32, i32* %4, align 8
2390 ; CHECK-NEXT: %6 = insertelement <4 x i32> undef, i32 %5, i32 0
2391 ; CHECK-NEXT: %7 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 5
2392 ; CHECK-NEXT: %8 = load i32, i32* %7, align 4
2393 ; CHECK-NEXT: %9 = insertelement <4 x i32> %6, i32 %8, i32 1
2394 ; CHECK-NEXT: ret i32 0
2395 ; CHECK-NEXT: }
2396
2397 define i32 @load_from_6xi64_align_8(<6 x i64>*) {
2398 entry:
2399 %1 = load <6 x i64>, <6 x i64>* %0, align 8
2400 ret i32 0
2401 }
2402 ; CHECK-LABEL: define i32 @load_from_6xi64_align_8(<6 x i64>*) {
2403 ; CHECK: entry:
2404 ; CHECK-NEXT: %1 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 0
2405 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
2406 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 8
2407 ; CHECK-NEXT: %4 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 2
2408 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
2409 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 8
2410 ; CHECK-NEXT: %7 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 4
2411 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
2412 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 8
2413 ; CHECK-NEXT: ret i32 0
2414 ; CHECK-NEXT: }
2415
2416 define i32 @load_from_6xi8ptr_align_8(<6 x i8*>*) {
2417 entry:
2418 %1 = load <6 x i8*>, <6 x i8*>* %0, align 8
2419 ret i32 0
2420 }
2421 ; CHECK-LABEL: define i32 @load_from_6xi8ptr_align_8(<6 x i8*>*) {
2422 ; CHECK: entry:
2423 ; CHECK-NEXT: %1 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 0
2424 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
2425 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 8
2426 ; CHECK-NEXT: %4 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 4
2427 ; CHECK-NEXT: %5 = load i8*, i8** %4, align 8
2428 ; CHECK-NEXT: %6 = insertelement <4 x i8*> undef, i8* %5, i32 0
2429 ; CHECK-NEXT: %7 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 5
2430 ; CHECK-NEXT: %8 = load i8*, i8** %7, align 4
2431 ; CHECK-NEXT: %9 = insertelement <4 x i8*> %6, i8* %8, i32 1
2432 ; CHECK-NEXT: ret i32 0
2433 ; CHECK-NEXT: }
2434
2435 define i32 @load_from_6xfloat_align_8(<6 x float>*) {
2436 entry:
2437 %1 = load <6 x float>, <6 x float>* %0, align 8
2438 ret i32 0
2439 }
2440 ; CHECK-LABEL: define i32 @load_from_6xfloat_align_8(<6 x float>*) {
2441 ; CHECK: entry:
2442 ; CHECK-NEXT: %1 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 0
2443 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
2444 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 8
2445 ; CHECK-NEXT: %4 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 4
2446 ; CHECK-NEXT: %5 = load float, float* %4, align 8
2447 ; CHECK-NEXT: %6 = insertelement <4 x float> undef, float %5, i32 0
2448 ; CHECK-NEXT: %7 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 5
2449 ; CHECK-NEXT: %8 = load float, float* %7, align 4
2450 ; CHECK-NEXT: %9 = insertelement <4 x float> %6, float %8, i32 1
2451 ; CHECK-NEXT: ret i32 0
2452 ; CHECK-NEXT: }
2453
2454 define i32 @load_from_6xdouble_align_8(<6 x double>*) {
2455 entry:
2456 %1 = load <6 x double>, <6 x double>* %0, align 8
2457 ret i32 0
2458 }
2459 ; CHECK-LABEL: define i32 @load_from_6xdouble_align_8(<6 x double>*) {
2460 ; CHECK: entry:
2461 ; CHECK-NEXT: %1 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 0
2462 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
2463 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 8
2464 ; CHECK-NEXT: %4 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 2
2465 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
2466 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 8
2467 ; CHECK-NEXT: %7 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 4
2468 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
2469 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 8
2470 ; CHECK-NEXT: ret i32 0
2471 ; CHECK-NEXT: }
2472
2473 define i32 @load_from_8xi8_align_8(<8 x i8>*) {
2474 entry:
2475 %1 = load <8 x i8>, <8 x i8>* %0, align 8
2476 ret i32 0
2477 }
2478 ; CHECK-LABEL: define i32 @load_from_8xi8_align_8(<8 x i8>*) {
2479 ; CHECK: entry:
2480 ; CHECK-NEXT: %1 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 0
2481 ; CHECK-NEXT: %2 = load i8, i8* %1, align 8
2482 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
2483 ; CHECK-NEXT: %4 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 1
2484 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
2485 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
2486 ; CHECK-NEXT: %7 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 2
2487 ; CHECK-NEXT: %8 = load i8, i8* %7, align 2
2488 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
2489 ; CHECK-NEXT: %10 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 3
2490 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
2491 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
2492 ; CHECK-NEXT: %13 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 4
2493 ; CHECK-NEXT: %14 = load i8, i8* %13, align 4
2494 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
2495 ; CHECK-NEXT: %16 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 5
2496 ; CHECK-NEXT: %17 = load i8, i8* %16, align 1
2497 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
2498 ; CHECK-NEXT: %19 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 6
2499 ; CHECK-NEXT: %20 = load i8, i8* %19, align 2
2500 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
2501 ; CHECK-NEXT: %22 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 7
2502 ; CHECK-NEXT: %23 = load i8, i8* %22, align 1
2503 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
2504 ; CHECK-NEXT: ret i32 0
2505 ; CHECK-NEXT: }
2506
2507 define i32 @load_from_8xi16_align_8(<8 x i16>*) {
2508 entry:
2509 %1 = load <8 x i16>, <8 x i16>* %0, align 8
2510 ret i32 0
2511 }
2512 ; CHECK-LABEL: define i32 @load_from_8xi16_align_8(<8 x i16>*) {
2513 ; CHECK: entry:
2514 ; CHECK-NEXT: %1 = load <8 x i16>, <8 x i16>* %0, align 8
2515 ; CHECK-NEXT: ret i32 0
2516 ; CHECK-NEXT: }
2517
2518 define i32 @load_from_8xi32_align_8(<8 x i32>*) {
2519 entry:
2520 %1 = load <8 x i32>, <8 x i32>* %0, align 8
2521 ret i32 0
2522 }
2523 ; CHECK-LABEL: define i32 @load_from_8xi32_align_8(<8 x i32>*) {
2524 ; CHECK: entry:
2525 ; CHECK-NEXT: %1 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 0
2526 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
2527 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 8
2528 ; CHECK-NEXT: %4 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 4
2529 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
2530 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 8
2531 ; CHECK-NEXT: ret i32 0
2532 ; CHECK-NEXT: }
2533
2534 define i32 @load_from_8xi64_align_8(<8 x i64>*) {
2535 entry:
2536 %1 = load <8 x i64>, <8 x i64>* %0, align 8
2537 ret i32 0
2538 }
2539 ; CHECK-LABEL: define i32 @load_from_8xi64_align_8(<8 x i64>*) {
2540 ; CHECK: entry:
2541 ; CHECK-NEXT: %1 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 0
2542 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
2543 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 8
2544 ; CHECK-NEXT: %4 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 2
2545 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
2546 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 8
2547 ; CHECK-NEXT: %7 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 4
2548 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
2549 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 8
2550 ; CHECK-NEXT: %10 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 6
2551 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
2552 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 8
2553 ; CHECK-NEXT: ret i32 0
2554 ; CHECK-NEXT: }
2555
2556 define i32 @load_from_8xi8ptr_align_8(<8 x i8*>*) {
2557 entry:
2558 %1 = load <8 x i8*>, <8 x i8*>* %0, align 8
2559 ret i32 0
2560 }
2561 ; CHECK-LABEL: define i32 @load_from_8xi8ptr_align_8(<8 x i8*>*) {
2562 ; CHECK: entry:
2563 ; CHECK-NEXT: %1 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 0
2564 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
2565 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 8
2566 ; CHECK-NEXT: %4 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 4
2567 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
2568 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 8
2569 ; CHECK-NEXT: ret i32 0
2570 ; CHECK-NEXT: }
2571
2572 define i32 @load_from_8xfloat_align_8(<8 x float>*) {
2573 entry:
2574 %1 = load <8 x float>, <8 x float>* %0, align 8
2575 ret i32 0
2576 }
2577 ; CHECK-LABEL: define i32 @load_from_8xfloat_align_8(<8 x float>*) {
2578 ; CHECK: entry:
2579 ; CHECK-NEXT: %1 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 0
2580 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
2581 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 8
2582 ; CHECK-NEXT: %4 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 4
2583 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
2584 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 8
2585 ; CHECK-NEXT: ret i32 0
2586 ; CHECK-NEXT: }
2587
2588 define i32 @load_from_8xdouble_align_8(<8 x double>*) {
2589 entry:
2590 %1 = load <8 x double>, <8 x double>* %0, align 8
2591 ret i32 0
2592 }
2593 ; CHECK-LABEL: define i32 @load_from_8xdouble_align_8(<8 x double>*) {
2594 ; CHECK: entry:
2595 ; CHECK-NEXT: %1 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 0
2596 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
2597 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 8
2598 ; CHECK-NEXT: %4 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 2
2599 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
2600 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 8
2601 ; CHECK-NEXT: %7 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 4
2602 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
2603 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 8
2604 ; CHECK-NEXT: %10 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 6
2605 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
2606 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 8
2607 ; CHECK-NEXT: ret i32 0
2608 ; CHECK-NEXT: }
2609
2610 define i32 @load_from_12xi8_align_8(<12 x i8>*) {
2611 entry:
2612 %1 = load <12 x i8>, <12 x i8>* %0, align 8
2613 ret i32 0
2614 }
2615 ; CHECK-LABEL: define i32 @load_from_12xi8_align_8(<12 x i8>*) {
2616 ; CHECK: entry:
2617 ; CHECK-NEXT: %1 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 0
2618 ; CHECK-NEXT: %2 = load i8, i8* %1, align 8
2619 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
2620 ; CHECK-NEXT: %4 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 1
2621 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
2622 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
2623 ; CHECK-NEXT: %7 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 2
2624 ; CHECK-NEXT: %8 = load i8, i8* %7, align 2
2625 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
2626 ; CHECK-NEXT: %10 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 3
2627 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
2628 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
2629 ; CHECK-NEXT: %13 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 4
2630 ; CHECK-NEXT: %14 = load i8, i8* %13, align 4
2631 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
2632 ; CHECK-NEXT: %16 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 5
2633 ; CHECK-NEXT: %17 = load i8, i8* %16, align 1
2634 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
2635 ; CHECK-NEXT: %19 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 6
2636 ; CHECK-NEXT: %20 = load i8, i8* %19, align 2
2637 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
2638 ; CHECK-NEXT: %22 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 7
2639 ; CHECK-NEXT: %23 = load i8, i8* %22, align 1
2640 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
2641 ; CHECK-NEXT: %25 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 8
2642 ; CHECK-NEXT: %26 = load i8, i8* %25, align 8
2643 ; CHECK-NEXT: %27 = insertelement <16 x i8> %24, i8 %26, i32 8
2644 ; CHECK-NEXT: %28 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 9
2645 ; CHECK-NEXT: %29 = load i8, i8* %28, align 1
2646 ; CHECK-NEXT: %30 = insertelement <16 x i8> %27, i8 %29, i32 9
2647 ; CHECK-NEXT: %31 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 10
2648 ; CHECK-NEXT: %32 = load i8, i8* %31, align 2
2649 ; CHECK-NEXT: %33 = insertelement <16 x i8> %30, i8 %32, i32 10
2650 ; CHECK-NEXT: %34 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 11
2651 ; CHECK-NEXT: %35 = load i8, i8* %34, align 1
2652 ; CHECK-NEXT: %36 = insertelement <16 x i8> %33, i8 %35, i32 11
2653 ; CHECK-NEXT: ret i32 0
2654 ; CHECK-NEXT: }
2655
2656 define i32 @load_from_12xi16_align_8(<12 x i16>*) {
2657 entry:
2658 %1 = load <12 x i16>, <12 x i16>* %0, align 8
2659 ret i32 0
2660 }
2661 ; CHECK-LABEL: define i32 @load_from_12xi16_align_8(<12 x i16>*) {
2662 ; CHECK: entry:
2663 ; CHECK-NEXT: %1 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 0
2664 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
2665 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2, align 8
2666 ; CHECK-NEXT: %4 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 8
2667 ; CHECK-NEXT: %5 = load i16, i16* %4, align 8
2668 ; CHECK-NEXT: %6 = insertelement <8 x i16> undef, i16 %5, i32 0
2669 ; CHECK-NEXT: %7 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 9
2670 ; CHECK-NEXT: %8 = load i16, i16* %7, align 2
2671 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 1
2672 ; CHECK-NEXT: %10 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 10
2673 ; CHECK-NEXT: %11 = load i16, i16* %10, align 4
2674 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 2
2675 ; CHECK-NEXT: %13 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 11
2676 ; CHECK-NEXT: %14 = load i16, i16* %13, align 2
2677 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 3
2678 ; CHECK-NEXT: ret i32 0
2679 ; CHECK-NEXT: }
2680
2681 define i32 @load_from_12xi32_align_8(<12 x i32>*) {
2682 entry:
2683 %1 = load <12 x i32>, <12 x i32>* %0, align 8
2684 ret i32 0
2685 }
2686 ; CHECK-LABEL: define i32 @load_from_12xi32_align_8(<12 x i32>*) {
2687 ; CHECK: entry:
2688 ; CHECK-NEXT: %1 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 0
2689 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
2690 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 8
2691 ; CHECK-NEXT: %4 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 4
2692 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
2693 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 8
2694 ; CHECK-NEXT: %7 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 8
2695 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
2696 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8, align 8
2697 ; CHECK-NEXT: ret i32 0
2698 ; CHECK-NEXT: }
2699
2700 define i32 @load_from_12xi64_align_8(<12 x i64>*) {
2701 entry:
2702 %1 = load <12 x i64>, <12 x i64>* %0, align 8
2703 ret i32 0
2704 }
2705 ; CHECK-LABEL: define i32 @load_from_12xi64_align_8(<12 x i64>*) {
2706 ; CHECK: entry:
2707 ; CHECK-NEXT: %1 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 0
2708 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
2709 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 8
2710 ; CHECK-NEXT: %4 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 2
2711 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
2712 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 8
2713 ; CHECK-NEXT: %7 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 4
2714 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
2715 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 8
2716 ; CHECK-NEXT: %10 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 6
2717 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
2718 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 8
2719 ; CHECK-NEXT: %13 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 8
2720 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
2721 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14, align 8
2722 ; CHECK-NEXT: %16 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 10
2723 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
2724 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17, align 8
2725 ; CHECK-NEXT: ret i32 0
2726 ; CHECK-NEXT: }
2727
2728 define i32 @load_from_12xi8ptr_align_8(<12 x i8*>*) {
2729 entry:
2730 %1 = load <12 x i8*>, <12 x i8*>* %0, align 8
2731 ret i32 0
2732 }
2733 ; CHECK-LABEL: define i32 @load_from_12xi8ptr_align_8(<12 x i8*>*) {
2734 ; CHECK: entry:
2735 ; CHECK-NEXT: %1 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 0
2736 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
2737 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 8
2738 ; CHECK-NEXT: %4 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 4
2739 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
2740 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 8
2741 ; CHECK-NEXT: %7 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 8
2742 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
2743 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8, align 8
2744 ; CHECK-NEXT: ret i32 0
2745 ; CHECK-NEXT: }
2746
2747 define i32 @load_from_12xfloat_align_8(<12 x float>*) {
2748 entry:
2749 %1 = load <12 x float>, <12 x float>* %0, align 8
2750 ret i32 0
2751 }
2752 ; CHECK-LABEL: define i32 @load_from_12xfloat_align_8(<12 x float>*) {
2753 ; CHECK: entry:
2754 ; CHECK-NEXT: %1 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 0
2755 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
2756 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 8
2757 ; CHECK-NEXT: %4 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 4
2758 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
2759 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 8
2760 ; CHECK-NEXT: %7 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 8
2761 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
2762 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8, align 8
2763 ; CHECK-NEXT: ret i32 0
2764 ; CHECK-NEXT: }
2765
2766 define i32 @load_from_12xdouble_align_8(<12 x double>*) {
2767 entry:
2768 %1 = load <12 x double>, <12 x double>* %0, align 8
2769 ret i32 0
2770 }
2771 ; CHECK-LABEL: define i32 @load_from_12xdouble_align_8(<12 x double>*) {
2772 ; CHECK: entry:
2773 ; CHECK-NEXT: %1 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 0
2774 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
2775 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 8
2776 ; CHECK-NEXT: %4 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 2
2777 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
2778 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 8
2779 ; CHECK-NEXT: %7 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 4
2780 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
2781 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 8
2782 ; CHECK-NEXT: %10 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 6
2783 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
2784 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 8
2785 ; CHECK-NEXT: %13 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 8
2786 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
2787 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14, align 8
2788 ; CHECK-NEXT: %16 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 10
2789 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
2790 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17, align 8
2791 ; CHECK-NEXT: ret i32 0
2792 ; CHECK-NEXT: }
2793
2794 define i32 @load_from_16xi8_align_8(<16 x i8>*) {
2795 entry:
2796 %1 = load <16 x i8>, <16 x i8>* %0, align 8
2797 ret i32 0
2798 }
2799 ; CHECK-LABEL: define i32 @load_from_16xi8_align_8(<16 x i8>*) {
2800 ; CHECK: entry:
2801 ; CHECK-NEXT: %1 = load <16 x i8>, <16 x i8>* %0, align 8
2802 ; CHECK-NEXT: ret i32 0
2803 ; CHECK-NEXT: }
2804
2805 define i32 @load_from_16xi16_align_8(<16 x i16>*) {
2806 entry:
2807 %1 = load <16 x i16>, <16 x i16>* %0, align 8
2808 ret i32 0
2809 }
2810 ; CHECK-LABEL: define i32 @load_from_16xi16_align_8(<16 x i16>*) {
2811 ; CHECK: entry:
2812 ; CHECK-NEXT: %1 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 0
2813 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
2814 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2, align 8
2815 ; CHECK-NEXT: %4 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 8
2816 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
2817 ; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5, align 8
2818 ; CHECK-NEXT: ret i32 0
2819 ; CHECK-NEXT: }
2820
2821 define i32 @load_from_16xi32_align_8(<16 x i32>*) {
2822 entry:
2823 %1 = load <16 x i32>, <16 x i32>* %0, align 8
2824 ret i32 0
2825 }
2826 ; CHECK-LABEL: define i32 @load_from_16xi32_align_8(<16 x i32>*) {
2827 ; CHECK: entry:
2828 ; CHECK-NEXT: %1 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 0
2829 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
2830 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 8
2831 ; CHECK-NEXT: %4 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 4
2832 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
2833 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 8
2834 ; CHECK-NEXT: %7 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 8
2835 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
2836 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8, align 8
2837 ; CHECK-NEXT: %10 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 12
2838 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
2839 ; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11, align 8
2840 ; CHECK-NEXT: ret i32 0
2841 ; CHECK-NEXT: }
2842
2843 define i32 @load_from_16xi64_align_8(<16 x i64>*) {
2844 entry:
2845 %1 = load <16 x i64>, <16 x i64>* %0, align 8
2846 ret i32 0
2847 }
2848 ; CHECK-LABEL: define i32 @load_from_16xi64_align_8(<16 x i64>*) {
2849 ; CHECK: entry:
2850 ; CHECK-NEXT: %1 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 0
2851 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
2852 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 8
2853 ; CHECK-NEXT: %4 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 2
2854 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
2855 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 8
2856 ; CHECK-NEXT: %7 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 4
2857 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
2858 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 8
2859 ; CHECK-NEXT: %10 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 6
2860 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
2861 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 8
2862 ; CHECK-NEXT: %13 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 8
2863 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
2864 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14, align 8
2865 ; CHECK-NEXT: %16 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 10
2866 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
2867 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17, align 8
2868 ; CHECK-NEXT: %19 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 12
2869 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
2870 ; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20, align 8
2871 ; CHECK-NEXT: %22 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 14
2872 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
2873 ; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23, align 8
2874 ; CHECK-NEXT: ret i32 0
2875 ; CHECK-NEXT: }
2876
2877 define i32 @load_from_16xi8ptr_align_8(<16 x i8*>*) {
2878 entry:
2879 %1 = load <16 x i8*>, <16 x i8*>* %0, align 8
2880 ret i32 0
2881 }
2882 ; CHECK-LABEL: define i32 @load_from_16xi8ptr_align_8(<16 x i8*>*) {
2883 ; CHECK: entry:
2884 ; CHECK-NEXT: %1 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 0
2885 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
2886 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 8
2887 ; CHECK-NEXT: %4 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 4
2888 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
2889 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 8
2890 ; CHECK-NEXT: %7 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 8
2891 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
2892 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8, align 8
2893 ; CHECK-NEXT: %10 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 12
2894 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
2895 ; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11, align 8
2896 ; CHECK-NEXT: ret i32 0
2897 ; CHECK-NEXT: }
2898
2899 define i32 @load_from_16xfloat_align_8(<16 x float>*) {
2900 entry:
2901 %1 = load <16 x float>, <16 x float>* %0, align 8
2902 ret i32 0
2903 }
2904 ; CHECK-LABEL: define i32 @load_from_16xfloat_align_8(<16 x float>*) {
2905 ; CHECK: entry:
2906 ; CHECK-NEXT: %1 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 0
2907 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
2908 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 8
2909 ; CHECK-NEXT: %4 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 4
2910 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
2911 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 8
2912 ; CHECK-NEXT: %7 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 8
2913 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
2914 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8, align 8
2915 ; CHECK-NEXT: %10 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 12
2916 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
2917 ; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11, align 8
2918 ; CHECK-NEXT: ret i32 0
2919 ; CHECK-NEXT: }
2920
2921 define i32 @load_from_16xdouble_align_8(<16 x double>*) {
2922 entry:
2923 %1 = load <16 x double>, <16 x double>* %0, align 8
2924 ret i32 0
2925 }
2926 ; CHECK-LABEL: define i32 @load_from_16xdouble_align_8(<16 x double>*) {
2927 ; CHECK: entry:
2928 ; CHECK-NEXT: %1 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 0
2929 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
2930 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 8
2931 ; CHECK-NEXT: %4 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 2
2932 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
2933 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 8
2934 ; CHECK-NEXT: %7 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 4
2935 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
2936 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 8
2937 ; CHECK-NEXT: %10 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 6
2938 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
2939 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 8
2940 ; CHECK-NEXT: %13 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 8
2941 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
2942 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14, align 8
2943 ; CHECK-NEXT: %16 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 10
2944 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
2945 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17, align 8
2946 ; CHECK-NEXT: %19 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 12
2947 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
2948 ; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20, align 8
2949 ; CHECK-NEXT: %22 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 14
2950 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
2951 ; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23, align 8
2952 ; CHECK-NEXT: ret i32 0
2953 ; CHECK-NEXT: }
2954
2955 define i32 @load_from_20xi8_align_8(<20 x i8>*) {
2956 entry:
2957 %1 = load <20 x i8>, <20 x i8>* %0, align 8
2958 ret i32 0
2959 }
2960 ; CHECK-LABEL: define i32 @load_from_20xi8_align_8(<20 x i8>*) {
2961 ; CHECK: entry:
2962 ; CHECK-NEXT: %1 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 0
2963 ; CHECK-NEXT: %2 = bitcast i8* %1 to <16 x i8>*
2964 ; CHECK-NEXT: %3 = load <16 x i8>, <16 x i8>* %2, align 8
2965 ; CHECK-NEXT: %4 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 16
2966 ; CHECK-NEXT: %5 = load i8, i8* %4, align 8
2967 ; CHECK-NEXT: %6 = insertelement <16 x i8> undef, i8 %5, i32 0
2968 ; CHECK-NEXT: %7 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 17
2969 ; CHECK-NEXT: %8 = load i8, i8* %7, align 1
2970 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 1
2971 ; CHECK-NEXT: %10 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 18
2972 ; CHECK-NEXT: %11 = load i8, i8* %10, align 2
2973 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 2
2974 ; CHECK-NEXT: %13 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 19
2975 ; CHECK-NEXT: %14 = load i8, i8* %13, align 1
2976 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 3
2977 ; CHECK-NEXT: ret i32 0
2978 ; CHECK-NEXT: }
2979
2980 define i32 @load_from_20xi16_align_8(<20 x i16>*) {
2981 entry:
2982 %1 = load <20 x i16>, <20 x i16>* %0, align 8
2983 ret i32 0
2984 }
2985 ; CHECK-LABEL: define i32 @load_from_20xi16_align_8(<20 x i16>*) {
2986 ; CHECK: entry:
2987 ; CHECK-NEXT: %1 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 0
2988 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
2989 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2, align 8
2990 ; CHECK-NEXT: %4 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 8
2991 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
2992 ; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5, align 8
2993 ; CHECK-NEXT: %7 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 16
2994 ; CHECK-NEXT: %8 = load i16, i16* %7, align 8
2995 ; CHECK-NEXT: %9 = insertelement <8 x i16> undef, i16 %8, i32 0
2996 ; CHECK-NEXT: %10 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 17
2997 ; CHECK-NEXT: %11 = load i16, i16* %10, align 2
2998 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 1
2999 ; CHECK-NEXT: %13 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 18
3000 ; CHECK-NEXT: %14 = load i16, i16* %13, align 4
3001 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 2
3002 ; CHECK-NEXT: %16 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 19
3003 ; CHECK-NEXT: %17 = load i16, i16* %16, align 2
3004 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 3
3005 ; CHECK-NEXT: ret i32 0
3006 ; CHECK-NEXT: }
3007
3008 define i32 @load_from_20xi32_align_8(<20 x i32>*) {
3009 entry:
3010 %1 = load <20 x i32>, <20 x i32>* %0, align 8
3011 ret i32 0
3012 }
3013 ; CHECK-LABEL: define i32 @load_from_20xi32_align_8(<20 x i32>*) {
3014 ; CHECK: entry:
3015 ; CHECK-NEXT: %1 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 0
3016 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
3017 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 8
3018 ; CHECK-NEXT: %4 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 4
3019 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
3020 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 8
3021 ; CHECK-NEXT: %7 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 8
3022 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
3023 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8, align 8
3024 ; CHECK-NEXT: %10 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 12
3025 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
3026 ; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11, align 8
3027 ; CHECK-NEXT: %13 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 16
3028 ; CHECK-NEXT: %14 = bitcast i32* %13 to <4 x i32>*
3029 ; CHECK-NEXT: %15 = load <4 x i32>, <4 x i32>* %14, align 8
3030 ; CHECK-NEXT: ret i32 0
3031 ; CHECK-NEXT: }
3032
3033 define i32 @load_from_20xi64_align_8(<20 x i64>*) {
3034 entry:
3035 %1 = load <20 x i64>, <20 x i64>* %0, align 8
3036 ret i32 0
3037 }
3038 ; CHECK-LABEL: define i32 @load_from_20xi64_align_8(<20 x i64>*) {
3039 ; CHECK: entry:
3040 ; CHECK-NEXT: %1 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 0
3041 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
3042 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 8
3043 ; CHECK-NEXT: %4 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 2
3044 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
3045 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 8
3046 ; CHECK-NEXT: %7 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 4
3047 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
3048 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 8
3049 ; CHECK-NEXT: %10 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 6
3050 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
3051 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 8
3052 ; CHECK-NEXT: %13 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 8
3053 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
3054 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14, align 8
3055 ; CHECK-NEXT: %16 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 10
3056 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
3057 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17, align 8
3058 ; CHECK-NEXT: %19 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 12
3059 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
3060 ; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20, align 8
3061 ; CHECK-NEXT: %22 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 14
3062 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
3063 ; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23, align 8
3064 ; CHECK-NEXT: %25 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 16
3065 ; CHECK-NEXT: %26 = bitcast i64* %25 to <2 x i64>*
3066 ; CHECK-NEXT: %27 = load <2 x i64>, <2 x i64>* %26, align 8
3067 ; CHECK-NEXT: %28 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 18
3068 ; CHECK-NEXT: %29 = bitcast i64* %28 to <2 x i64>*
3069 ; CHECK-NEXT: %30 = load <2 x i64>, <2 x i64>* %29, align 8
3070 ; CHECK-NEXT: ret i32 0
3071 ; CHECK-NEXT: }
3072
3073 define i32 @load_from_20xi8ptr_align_8(<20 x i8*>*) {
3074 entry:
3075 %1 = load <20 x i8*>, <20 x i8*>* %0, align 8
3076 ret i32 0
3077 }
3078 ; CHECK-LABEL: define i32 @load_from_20xi8ptr_align_8(<20 x i8*>*) {
3079 ; CHECK: entry:
3080 ; CHECK-NEXT: %1 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 0
3081 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
3082 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 8
3083 ; CHECK-NEXT: %4 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 4
3084 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
3085 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 8
3086 ; CHECK-NEXT: %7 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 8
3087 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
3088 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8, align 8
3089 ; CHECK-NEXT: %10 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 12
3090 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
3091 ; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11, align 8
3092 ; CHECK-NEXT: %13 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 16
3093 ; CHECK-NEXT: %14 = bitcast i8** %13 to <4 x i8*>*
3094 ; CHECK-NEXT: %15 = load <4 x i8*>, <4 x i8*>* %14, align 8
3095 ; CHECK-NEXT: ret i32 0
3096 ; CHECK-NEXT: }
3097
3098 define i32 @load_from_20xfloat_align_8(<20 x float>*) {
3099 entry:
3100 %1 = load <20 x float>, <20 x float>* %0, align 8
3101 ret i32 0
3102 }
3103 ; CHECK-LABEL: define i32 @load_from_20xfloat_align_8(<20 x float>*) {
3104 ; CHECK: entry:
3105 ; CHECK-NEXT: %1 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 0
3106 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
3107 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 8
3108 ; CHECK-NEXT: %4 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 4
3109 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
3110 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 8
3111 ; CHECK-NEXT: %7 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 8
3112 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
3113 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8, align 8
3114 ; CHECK-NEXT: %10 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 12
3115 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
3116 ; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11, align 8
3117 ; CHECK-NEXT: %13 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 16
3118 ; CHECK-NEXT: %14 = bitcast float* %13 to <4 x float>*
3119 ; CHECK-NEXT: %15 = load <4 x float>, <4 x float>* %14, align 8
3120 ; CHECK-NEXT: ret i32 0
3121 ; CHECK-NEXT: }
3122
3123 define i32 @load_from_20xdouble_align_8(<20 x double>*) {
3124 entry:
3125 %1 = load <20 x double>, <20 x double>* %0, align 8
3126 ret i32 0
3127 }
3128 ; CHECK-LABEL: define i32 @load_from_20xdouble_align_8(<20 x double>*) {
3129 ; CHECK: entry:
3130 ; CHECK-NEXT: %1 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 0
3131 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
3132 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 8
3133 ; CHECK-NEXT: %4 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 2
3134 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
3135 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 8
3136 ; CHECK-NEXT: %7 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 4
3137 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
3138 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 8
3139 ; CHECK-NEXT: %10 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 6
3140 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
3141 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 8
3142 ; CHECK-NEXT: %13 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 8
3143 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
3144 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14, align 8
3145 ; CHECK-NEXT: %16 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 10
3146 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
3147 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17, align 8
3148 ; CHECK-NEXT: %19 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 12
3149 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
3150 ; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20, align 8
3151 ; CHECK-NEXT: %22 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 14
3152 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
3153 ; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23, align 8
3154 ; CHECK-NEXT: %25 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 16
3155 ; CHECK-NEXT: %26 = bitcast double* %25 to <2 x double>*
3156 ; CHECK-NEXT: %27 = load <2 x double>, <2 x double>* %26, align 8
3157 ; CHECK-NEXT: %28 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 18
3158 ; CHECK-NEXT: %29 = bitcast double* %28 to <2 x double>*
3159 ; CHECK-NEXT: %30 = load <2 x double>, <2 x double>* %29, align 8
3160 ; CHECK-NEXT: ret i32 0
3161 ; CHECK-NEXT: }
3162
3163 define i32 @load_from_2xi8_align_32(<2 x i8>*) {
3164 entry:
3165 %1 = load <2 x i8>, <2 x i8>* %0, align 32
3166 ret i32 0
3167 }
3168 ; CHECK-LABEL: define i32 @load_from_2xi8_align_32(<2 x i8>*) {
3169 ; CHECK: entry:
3170 ; CHECK-NEXT: %1 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 0
3171 ; CHECK-NEXT: %2 = load i8, i8* %1, align 32
3172 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
3173 ; CHECK-NEXT: %4 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 1
3174 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
3175 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
3176 ; CHECK-NEXT: ret i32 0
3177 ; CHECK-NEXT: }
3178
3179 define i32 @load_from_2xi16_align_32(<2 x i16>*) {
3180 entry:
3181 %1 = load <2 x i16>, <2 x i16>* %0, align 32
3182 ret i32 0
3183 }
3184 ; CHECK-LABEL: define i32 @load_from_2xi16_align_32(<2 x i16>*) {
3185 ; CHECK: entry:
3186 ; CHECK-NEXT: %1 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 0
3187 ; CHECK-NEXT: %2 = load i16, i16* %1, align 32
3188 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
3189 ; CHECK-NEXT: %4 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 1
3190 ; CHECK-NEXT: %5 = load i16, i16* %4, align 2
3191 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
3192 ; CHECK-NEXT: ret i32 0
3193 ; CHECK-NEXT: }
3194
3195 define i32 @load_from_2xi32_align_32(<2 x i32>*) {
3196 entry:
3197 %1 = load <2 x i32>, <2 x i32>* %0, align 32
3198 ret i32 0
3199 }
3200 ; CHECK-LABEL: define i32 @load_from_2xi32_align_32(<2 x i32>*) {
3201 ; CHECK: entry:
3202 ; CHECK-NEXT: %1 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 0
3203 ; CHECK-NEXT: %2 = load i32, i32* %1, align 32
3204 ; CHECK-NEXT: %3 = insertelement <4 x i32> undef, i32 %2, i32 0
3205 ; CHECK-NEXT: %4 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 1
3206 ; CHECK-NEXT: %5 = load i32, i32* %4, align 4
3207 ; CHECK-NEXT: %6 = insertelement <4 x i32> %3, i32 %5, i32 1
3208 ; CHECK-NEXT: ret i32 0
3209 ; CHECK-NEXT: }
3210
3211 define i32 @load_from_2xi64_align_32(<2 x i64>*) {
3212 entry:
3213 %1 = load <2 x i64>, <2 x i64>* %0, align 32
3214 ret i32 0
3215 }
3216 ; CHECK-LABEL: define i32 @load_from_2xi64_align_32(<2 x i64>*) {
3217 ; CHECK: entry:
3218 ; CHECK-NEXT: %1 = load <2 x i64>, <2 x i64>* %0, align 32
3219 ; CHECK-NEXT: ret i32 0
3220 ; CHECK-NEXT: }
3221
3222 define i32 @load_from_2xi8ptr_align_32(<2 x i8*>*) {
3223 entry:
3224 %1 = load <2 x i8*>, <2 x i8*>* %0, align 32
3225 ret i32 0
3226 }
3227 ; CHECK-LABEL: define i32 @load_from_2xi8ptr_align_32(<2 x i8*>*) {
3228 ; CHECK: entry:
3229 ; CHECK-NEXT: %1 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 0
3230 ; CHECK-NEXT: %2 = load i8*, i8** %1, align 32
3231 ; CHECK-NEXT: %3 = insertelement <4 x i8*> undef, i8* %2, i32 0
3232 ; CHECK-NEXT: %4 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 1
3233 ; CHECK-NEXT: %5 = load i8*, i8** %4, align 4
3234 ; CHECK-NEXT: %6 = insertelement <4 x i8*> %3, i8* %5, i32 1
3235 ; CHECK-NEXT: ret i32 0
3236 ; CHECK-NEXT: }
3237
3238 define i32 @load_from_2xfloat_align_32(<2 x float>*) {
3239 entry:
3240 %1 = load <2 x float>, <2 x float>* %0, align 32
3241 ret i32 0
3242 }
3243 ; CHECK-LABEL: define i32 @load_from_2xfloat_align_32(<2 x float>*) {
3244 ; CHECK: entry:
3245 ; CHECK-NEXT: %1 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 0
3246 ; CHECK-NEXT: %2 = load float, float* %1, align 32
3247 ; CHECK-NEXT: %3 = insertelement <4 x float> undef, float %2, i32 0
3248 ; CHECK-NEXT: %4 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 1
3249 ; CHECK-NEXT: %5 = load float, float* %4, align 4
3250 ; CHECK-NEXT: %6 = insertelement <4 x float> %3, float %5, i32 1
3251 ; CHECK-NEXT: ret i32 0
3252 ; CHECK-NEXT: }
3253
3254 define i32 @load_from_2xdouble_align_32(<2 x double>*) {
3255 entry:
3256 %1 = load <2 x double>, <2 x double>* %0, align 32
3257 ret i32 0
3258 }
3259 ; CHECK-LABEL: define i32 @load_from_2xdouble_align_32(<2 x double>*) {
3260 ; CHECK: entry:
3261 ; CHECK-NEXT: %1 = load <2 x double>, <2 x double>* %0, align 32
3262 ; CHECK-NEXT: ret i32 0
3263 ; CHECK-NEXT: }
3264
3265 define i32 @load_from_4xi8_align_32(<4 x i8>*) {
3266 entry:
3267 %1 = load <4 x i8>, <4 x i8>* %0, align 32
3268 ret i32 0
3269 }
3270 ; CHECK-LABEL: define i32 @load_from_4xi8_align_32(<4 x i8>*) {
3271 ; CHECK: entry:
3272 ; CHECK-NEXT: %1 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 0
3273 ; CHECK-NEXT: %2 = load i8, i8* %1, align 32
3274 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
3275 ; CHECK-NEXT: %4 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 1
3276 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
3277 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
3278 ; CHECK-NEXT: %7 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 2
3279 ; CHECK-NEXT: %8 = load i8, i8* %7, align 2
3280 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
3281 ; CHECK-NEXT: %10 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 3
3282 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
3283 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
3284 ; CHECK-NEXT: ret i32 0
3285 ; CHECK-NEXT: }
3286
3287 define i32 @load_from_4xi16_align_32(<4 x i16>*) {
3288 entry:
3289 %1 = load <4 x i16>, <4 x i16>* %0, align 32
3290 ret i32 0
3291 }
3292 ; CHECK-LABEL: define i32 @load_from_4xi16_align_32(<4 x i16>*) {
3293 ; CHECK: entry:
3294 ; CHECK-NEXT: %1 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 0
3295 ; CHECK-NEXT: %2 = load i16, i16* %1, align 32
3296 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
3297 ; CHECK-NEXT: %4 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 1
3298 ; CHECK-NEXT: %5 = load i16, i16* %4, align 2
3299 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
3300 ; CHECK-NEXT: %7 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 2
3301 ; CHECK-NEXT: %8 = load i16, i16* %7, align 4
3302 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
3303 ; CHECK-NEXT: %10 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 3
3304 ; CHECK-NEXT: %11 = load i16, i16* %10, align 2
3305 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
3306 ; CHECK-NEXT: ret i32 0
3307 ; CHECK-NEXT: }
3308
3309 define i32 @load_from_4xi32_align_32(<4 x i32>*) {
3310 entry:
3311 %1 = load <4 x i32>, <4 x i32>* %0, align 32
3312 ret i32 0
3313 }
3314 ; CHECK-LABEL: define i32 @load_from_4xi32_align_32(<4 x i32>*) {
3315 ; CHECK: entry:
3316 ; CHECK-NEXT: %1 = load <4 x i32>, <4 x i32>* %0, align 32
3317 ; CHECK-NEXT: ret i32 0
3318 ; CHECK-NEXT: }
3319
3320 define i32 @load_from_4xi64_align_32(<4 x i64>*) {
3321 entry:
3322 %1 = load <4 x i64>, <4 x i64>* %0, align 32
3323 ret i32 0
3324 }
3325 ; CHECK-LABEL: define i32 @load_from_4xi64_align_32(<4 x i64>*) {
3326 ; CHECK: entry:
3327 ; CHECK-NEXT: %1 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 0
3328 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
3329 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 32
3330 ; CHECK-NEXT: %4 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 2
3331 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
3332 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 16
3333 ; CHECK-NEXT: ret i32 0
3334 ; CHECK-NEXT: }
3335
3336 define i32 @load_from_4xi8ptr_align_32(<4 x i8*>*) {
3337 entry:
3338 %1 = load <4 x i8*>, <4 x i8*>* %0, align 32
3339 ret i32 0
3340 }
3341 ; CHECK-LABEL: define i32 @load_from_4xi8ptr_align_32(<4 x i8*>*) {
3342 ; CHECK: entry:
3343 ; CHECK-NEXT: %1 = load <4 x i8*>, <4 x i8*>* %0, align 32
3344 ; CHECK-NEXT: ret i32 0
3345 ; CHECK-NEXT: }
3346
3347 define i32 @load_from_4xfloat_align_32(<4 x float>*) {
3348 entry:
3349 %1 = load <4 x float>, <4 x float>* %0, align 32
3350 ret i32 0
3351 }
3352 ; CHECK-LABEL: define i32 @load_from_4xfloat_align_32(<4 x float>*) {
3353 ; CHECK: entry:
3354 ; CHECK-NEXT: %1 = load <4 x float>, <4 x float>* %0, align 32
3355 ; CHECK-NEXT: ret i32 0
3356 ; CHECK-NEXT: }
3357
3358 define i32 @load_from_4xdouble_align_32(<4 x double>*) {
3359 entry:
3360 %1 = load <4 x double>, <4 x double>* %0, align 32
3361 ret i32 0
3362 }
3363 ; CHECK-LABEL: define i32 @load_from_4xdouble_align_32(<4 x double>*) {
3364 ; CHECK: entry:
3365 ; CHECK-NEXT: %1 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 0
3366 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
3367 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 32
3368 ; CHECK-NEXT: %4 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 2
3369 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
3370 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 16
3371 ; CHECK-NEXT: ret i32 0
3372 ; CHECK-NEXT: }
3373
3374 define i32 @load_from_6xi8_align_32(<6 x i8>*) {
3375 entry:
3376 %1 = load <6 x i8>, <6 x i8>* %0, align 32
3377 ret i32 0
3378 }
3379 ; CHECK-LABEL: define i32 @load_from_6xi8_align_32(<6 x i8>*) {
3380 ; CHECK: entry:
3381 ; CHECK-NEXT: %1 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 0
3382 ; CHECK-NEXT: %2 = load i8, i8* %1, align 32
3383 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
3384 ; CHECK-NEXT: %4 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 1
3385 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
3386 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
3387 ; CHECK-NEXT: %7 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 2
3388 ; CHECK-NEXT: %8 = load i8, i8* %7, align 2
3389 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
3390 ; CHECK-NEXT: %10 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 3
3391 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
3392 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
3393 ; CHECK-NEXT: %13 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 4
3394 ; CHECK-NEXT: %14 = load i8, i8* %13, align 4
3395 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
3396 ; CHECK-NEXT: %16 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 5
3397 ; CHECK-NEXT: %17 = load i8, i8* %16, align 1
3398 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
3399 ; CHECK-NEXT: ret i32 0
3400 ; CHECK-NEXT: }
3401
3402 define i32 @load_from_6xi16_align_32(<6 x i16>*) {
3403 entry:
3404 %1 = load <6 x i16>, <6 x i16>* %0, align 32
3405 ret i32 0
3406 }
3407 ; CHECK-LABEL: define i32 @load_from_6xi16_align_32(<6 x i16>*) {
3408 ; CHECK: entry:
3409 ; CHECK-NEXT: %1 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 0
3410 ; CHECK-NEXT: %2 = load i16, i16* %1, align 32
3411 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
3412 ; CHECK-NEXT: %4 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 1
3413 ; CHECK-NEXT: %5 = load i16, i16* %4, align 2
3414 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
3415 ; CHECK-NEXT: %7 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 2
3416 ; CHECK-NEXT: %8 = load i16, i16* %7, align 4
3417 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
3418 ; CHECK-NEXT: %10 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 3
3419 ; CHECK-NEXT: %11 = load i16, i16* %10, align 2
3420 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
3421 ; CHECK-NEXT: %13 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 4
3422 ; CHECK-NEXT: %14 = load i16, i16* %13, align 8
3423 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 4
3424 ; CHECK-NEXT: %16 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 5
3425 ; CHECK-NEXT: %17 = load i16, i16* %16, align 2
3426 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 5
3427 ; CHECK-NEXT: ret i32 0
3428 ; CHECK-NEXT: }
3429
3430 define i32 @load_from_6xi32_align_32(<6 x i32>*) {
3431 entry:
3432 %1 = load <6 x i32>, <6 x i32>* %0, align 32
3433 ret i32 0
3434 }
3435 ; CHECK-LABEL: define i32 @load_from_6xi32_align_32(<6 x i32>*) {
3436 ; CHECK: entry:
3437 ; CHECK-NEXT: %1 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 0
3438 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
3439 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 32
3440 ; CHECK-NEXT: %4 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 4
3441 ; CHECK-NEXT: %5 = load i32, i32* %4, align 16
3442 ; CHECK-NEXT: %6 = insertelement <4 x i32> undef, i32 %5, i32 0
3443 ; CHECK-NEXT: %7 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 5
3444 ; CHECK-NEXT: %8 = load i32, i32* %7, align 4
3445 ; CHECK-NEXT: %9 = insertelement <4 x i32> %6, i32 %8, i32 1
3446 ; CHECK-NEXT: ret i32 0
3447 ; CHECK-NEXT: }
3448
3449 define i32 @load_from_6xi64_align_32(<6 x i64>*) {
3450 entry:
3451 %1 = load <6 x i64>, <6 x i64>* %0, align 32
3452 ret i32 0
3453 }
3454 ; CHECK-LABEL: define i32 @load_from_6xi64_align_32(<6 x i64>*) {
3455 ; CHECK: entry:
3456 ; CHECK-NEXT: %1 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 0
3457 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
3458 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 32
3459 ; CHECK-NEXT: %4 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 2
3460 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
3461 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 16
3462 ; CHECK-NEXT: %7 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 4
3463 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
3464 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 32
3465 ; CHECK-NEXT: ret i32 0
3466 ; CHECK-NEXT: }
3467
3468 define i32 @load_from_6xi8ptr_align_32(<6 x i8*>*) {
3469 entry:
3470 %1 = load <6 x i8*>, <6 x i8*>* %0, align 32
3471 ret i32 0
3472 }
3473 ; CHECK-LABEL: define i32 @load_from_6xi8ptr_align_32(<6 x i8*>*) {
3474 ; CHECK: entry:
3475 ; CHECK-NEXT: %1 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 0
3476 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
3477 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 32
3478 ; CHECK-NEXT: %4 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 4
3479 ; CHECK-NEXT: %5 = load i8*, i8** %4, align 16
3480 ; CHECK-NEXT: %6 = insertelement <4 x i8*> undef, i8* %5, i32 0
3481 ; CHECK-NEXT: %7 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 5
3482 ; CHECK-NEXT: %8 = load i8*, i8** %7, align 4
3483 ; CHECK-NEXT: %9 = insertelement <4 x i8*> %6, i8* %8, i32 1
3484 ; CHECK-NEXT: ret i32 0
3485 ; CHECK-NEXT: }
3486
3487 define i32 @load_from_6xfloat_align_32(<6 x float>*) {
3488 entry:
3489 %1 = load <6 x float>, <6 x float>* %0, align 32
3490 ret i32 0
3491 }
3492 ; CHECK-LABEL: define i32 @load_from_6xfloat_align_32(<6 x float>*) {
3493 ; CHECK: entry:
3494 ; CHECK-NEXT: %1 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 0
3495 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
3496 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 32
3497 ; CHECK-NEXT: %4 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 4
3498 ; CHECK-NEXT: %5 = load float, float* %4, align 16
3499 ; CHECK-NEXT: %6 = insertelement <4 x float> undef, float %5, i32 0
3500 ; CHECK-NEXT: %7 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 5
3501 ; CHECK-NEXT: %8 = load float, float* %7, align 4
3502 ; CHECK-NEXT: %9 = insertelement <4 x float> %6, float %8, i32 1
3503 ; CHECK-NEXT: ret i32 0
3504 ; CHECK-NEXT: }
3505
3506 define i32 @load_from_6xdouble_align_32(<6 x double>*) {
3507 entry:
3508 %1 = load <6 x double>, <6 x double>* %0, align 32
3509 ret i32 0
3510 }
3511 ; CHECK-LABEL: define i32 @load_from_6xdouble_align_32(<6 x double>*) {
3512 ; CHECK: entry:
3513 ; CHECK-NEXT: %1 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 0
3514 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
3515 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 32
3516 ; CHECK-NEXT: %4 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 2
3517 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
3518 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 16
3519 ; CHECK-NEXT: %7 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 4
3520 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
3521 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 32
3522 ; CHECK-NEXT: ret i32 0
3523 ; CHECK-NEXT: }
3524
3525 define i32 @load_from_8xi8_align_32(<8 x i8>*) {
3526 entry:
3527 %1 = load <8 x i8>, <8 x i8>* %0, align 32
3528 ret i32 0
3529 }
3530 ; CHECK-LABEL: define i32 @load_from_8xi8_align_32(<8 x i8>*) {
3531 ; CHECK: entry:
3532 ; CHECK-NEXT: %1 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 0
3533 ; CHECK-NEXT: %2 = load i8, i8* %1, align 32
3534 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
3535 ; CHECK-NEXT: %4 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 1
3536 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
3537 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
3538 ; CHECK-NEXT: %7 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 2
3539 ; CHECK-NEXT: %8 = load i8, i8* %7, align 2
3540 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
3541 ; CHECK-NEXT: %10 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 3
3542 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
3543 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
3544 ; CHECK-NEXT: %13 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 4
3545 ; CHECK-NEXT: %14 = load i8, i8* %13, align 4
3546 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
3547 ; CHECK-NEXT: %16 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 5
3548 ; CHECK-NEXT: %17 = load i8, i8* %16, align 1
3549 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
3550 ; CHECK-NEXT: %19 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 6
3551 ; CHECK-NEXT: %20 = load i8, i8* %19, align 2
3552 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
3553 ; CHECK-NEXT: %22 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 7
3554 ; CHECK-NEXT: %23 = load i8, i8* %22, align 1
3555 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
3556 ; CHECK-NEXT: ret i32 0
3557 ; CHECK-NEXT: }
3558
3559 define i32 @load_from_8xi16_align_32(<8 x i16>*) {
3560 entry:
3561 %1 = load <8 x i16>, <8 x i16>* %0, align 32
3562 ret i32 0
3563 }
3564 ; CHECK-LABEL: define i32 @load_from_8xi16_align_32(<8 x i16>*) {
3565 ; CHECK: entry:
3566 ; CHECK-NEXT: %1 = load <8 x i16>, <8 x i16>* %0, align 32
3567 ; CHECK-NEXT: ret i32 0
3568 ; CHECK-NEXT: }
3569
3570 define i32 @load_from_8xi32_align_32(<8 x i32>*) {
3571 entry:
3572 %1 = load <8 x i32>, <8 x i32>* %0, align 32
3573 ret i32 0
3574 }
3575 ; CHECK-LABEL: define i32 @load_from_8xi32_align_32(<8 x i32>*) {
3576 ; CHECK: entry:
3577 ; CHECK-NEXT: %1 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 0
3578 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
3579 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 32
3580 ; CHECK-NEXT: %4 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 4
3581 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
3582 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 16
3583 ; CHECK-NEXT: ret i32 0
3584 ; CHECK-NEXT: }
3585
3586 define i32 @load_from_8xi64_align_32(<8 x i64>*) {
3587 entry:
3588 %1 = load <8 x i64>, <8 x i64>* %0, align 32
3589 ret i32 0
3590 }
3591 ; CHECK-LABEL: define i32 @load_from_8xi64_align_32(<8 x i64>*) {
3592 ; CHECK: entry:
3593 ; CHECK-NEXT: %1 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 0
3594 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
3595 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 32
3596 ; CHECK-NEXT: %4 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 2
3597 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
3598 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 16
3599 ; CHECK-NEXT: %7 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 4
3600 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
3601 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 32
3602 ; CHECK-NEXT: %10 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 6
3603 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
3604 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 16
3605 ; CHECK-NEXT: ret i32 0
3606 ; CHECK-NEXT: }
3607
3608 define i32 @load_from_8xi8ptr_align_32(<8 x i8*>*) {
3609 entry:
3610 %1 = load <8 x i8*>, <8 x i8*>* %0, align 32
3611 ret i32 0
3612 }
3613 ; CHECK-LABEL: define i32 @load_from_8xi8ptr_align_32(<8 x i8*>*) {
3614 ; CHECK: entry:
3615 ; CHECK-NEXT: %1 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 0
3616 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
3617 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 32
3618 ; CHECK-NEXT: %4 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 4
3619 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
3620 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 16
3621 ; CHECK-NEXT: ret i32 0
3622 ; CHECK-NEXT: }
3623
3624 define i32 @load_from_8xfloat_align_32(<8 x float>*) {
3625 entry:
3626 %1 = load <8 x float>, <8 x float>* %0, align 32
3627 ret i32 0
3628 }
3629 ; CHECK-LABEL: define i32 @load_from_8xfloat_align_32(<8 x float>*) {
3630 ; CHECK: entry:
3631 ; CHECK-NEXT: %1 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 0
3632 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
3633 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 32
3634 ; CHECK-NEXT: %4 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 4
3635 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
3636 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 16
3637 ; CHECK-NEXT: ret i32 0
3638 ; CHECK-NEXT: }
3639
3640 define i32 @load_from_8xdouble_align_32(<8 x double>*) {
3641 entry:
3642 %1 = load <8 x double>, <8 x double>* %0, align 32
3643 ret i32 0
3644 }
3645 ; CHECK-LABEL: define i32 @load_from_8xdouble_align_32(<8 x double>*) {
3646 ; CHECK: entry:
3647 ; CHECK-NEXT: %1 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 0
3648 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
3649 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 32
3650 ; CHECK-NEXT: %4 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 2
3651 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
3652 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 16
3653 ; CHECK-NEXT: %7 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 4
3654 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
3655 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 32
3656 ; CHECK-NEXT: %10 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 6
3657 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
3658 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 16
3659 ; CHECK-NEXT: ret i32 0
3660 ; CHECK-NEXT: }
3661
3662 define i32 @load_from_12xi8_align_32(<12 x i8>*) {
3663 entry:
3664 %1 = load <12 x i8>, <12 x i8>* %0, align 32
3665 ret i32 0
3666 }
3667 ; CHECK-LABEL: define i32 @load_from_12xi8_align_32(<12 x i8>*) {
3668 ; CHECK: entry:
3669 ; CHECK-NEXT: %1 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 0
3670 ; CHECK-NEXT: %2 = load i8, i8* %1, align 32
3671 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
3672 ; CHECK-NEXT: %4 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 1
3673 ; CHECK-NEXT: %5 = load i8, i8* %4, align 1
3674 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
3675 ; CHECK-NEXT: %7 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 2
3676 ; CHECK-NEXT: %8 = load i8, i8* %7, align 2
3677 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
3678 ; CHECK-NEXT: %10 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 3
3679 ; CHECK-NEXT: %11 = load i8, i8* %10, align 1
3680 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
3681 ; CHECK-NEXT: %13 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 4
3682 ; CHECK-NEXT: %14 = load i8, i8* %13, align 4
3683 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
3684 ; CHECK-NEXT: %16 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 5
3685 ; CHECK-NEXT: %17 = load i8, i8* %16, align 1
3686 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
3687 ; CHECK-NEXT: %19 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 6
3688 ; CHECK-NEXT: %20 = load i8, i8* %19, align 2
3689 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
3690 ; CHECK-NEXT: %22 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 7
3691 ; CHECK-NEXT: %23 = load i8, i8* %22, align 1
3692 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
3693 ; CHECK-NEXT: %25 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 8
3694 ; CHECK-NEXT: %26 = load i8, i8* %25, align 8
3695 ; CHECK-NEXT: %27 = insertelement <16 x i8> %24, i8 %26, i32 8
3696 ; CHECK-NEXT: %28 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 9
3697 ; CHECK-NEXT: %29 = load i8, i8* %28, align 1
3698 ; CHECK-NEXT: %30 = insertelement <16 x i8> %27, i8 %29, i32 9
3699 ; CHECK-NEXT: %31 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 10
3700 ; CHECK-NEXT: %32 = load i8, i8* %31, align 2
3701 ; CHECK-NEXT: %33 = insertelement <16 x i8> %30, i8 %32, i32 10
3702 ; CHECK-NEXT: %34 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 11
3703 ; CHECK-NEXT: %35 = load i8, i8* %34, align 1
3704 ; CHECK-NEXT: %36 = insertelement <16 x i8> %33, i8 %35, i32 11
3705 ; CHECK-NEXT: ret i32 0
3706 ; CHECK-NEXT: }
3707
3708 define i32 @load_from_12xi16_align_32(<12 x i16>*) {
3709 entry:
3710 %1 = load <12 x i16>, <12 x i16>* %0, align 32
3711 ret i32 0
3712 }
3713 ; CHECK-LABEL: define i32 @load_from_12xi16_align_32(<12 x i16>*) {
3714 ; CHECK: entry:
3715 ; CHECK-NEXT: %1 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 0
3716 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
3717 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2, align 32
3718 ; CHECK-NEXT: %4 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 8
3719 ; CHECK-NEXT: %5 = load i16, i16* %4, align 16
3720 ; CHECK-NEXT: %6 = insertelement <8 x i16> undef, i16 %5, i32 0
3721 ; CHECK-NEXT: %7 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 9
3722 ; CHECK-NEXT: %8 = load i16, i16* %7, align 2
3723 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 1
3724 ; CHECK-NEXT: %10 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 10
3725 ; CHECK-NEXT: %11 = load i16, i16* %10, align 4
3726 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 2
3727 ; CHECK-NEXT: %13 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 11
3728 ; CHECK-NEXT: %14 = load i16, i16* %13, align 2
3729 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 3
3730 ; CHECK-NEXT: ret i32 0
3731 ; CHECK-NEXT: }
3732
3733 define i32 @load_from_12xi32_align_32(<12 x i32>*) {
3734 entry:
3735 %1 = load <12 x i32>, <12 x i32>* %0, align 32
3736 ret i32 0
3737 }
3738 ; CHECK-LABEL: define i32 @load_from_12xi32_align_32(<12 x i32>*) {
3739 ; CHECK: entry:
3740 ; CHECK-NEXT: %1 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 0
3741 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
3742 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 32
3743 ; CHECK-NEXT: %4 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 4
3744 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
3745 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 16
3746 ; CHECK-NEXT: %7 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 8
3747 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
3748 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8, align 32
3749 ; CHECK-NEXT: ret i32 0
3750 ; CHECK-NEXT: }
3751
3752 define i32 @load_from_12xi64_align_32(<12 x i64>*) {
3753 entry:
3754 %1 = load <12 x i64>, <12 x i64>* %0, align 32
3755 ret i32 0
3756 }
3757 ; CHECK-LABEL: define i32 @load_from_12xi64_align_32(<12 x i64>*) {
3758 ; CHECK: entry:
3759 ; CHECK-NEXT: %1 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 0
3760 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
3761 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 32
3762 ; CHECK-NEXT: %4 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 2
3763 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
3764 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 16
3765 ; CHECK-NEXT: %7 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 4
3766 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
3767 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 32
3768 ; CHECK-NEXT: %10 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 6
3769 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
3770 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 16
3771 ; CHECK-NEXT: %13 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 8
3772 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
3773 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14, align 32
3774 ; CHECK-NEXT: %16 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 10
3775 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
3776 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17, align 16
3777 ; CHECK-NEXT: ret i32 0
3778 ; CHECK-NEXT: }
3779
3780 define i32 @load_from_12xi8ptr_align_32(<12 x i8*>*) {
3781 entry:
3782 %1 = load <12 x i8*>, <12 x i8*>* %0, align 32
3783 ret i32 0
3784 }
3785 ; CHECK-LABEL: define i32 @load_from_12xi8ptr_align_32(<12 x i8*>*) {
3786 ; CHECK: entry:
3787 ; CHECK-NEXT: %1 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 0
3788 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
3789 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 32
3790 ; CHECK-NEXT: %4 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 4
3791 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
3792 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 16
3793 ; CHECK-NEXT: %7 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 8
3794 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
3795 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8, align 32
3796 ; CHECK-NEXT: ret i32 0
3797 ; CHECK-NEXT: }
3798
3799 define i32 @load_from_12xfloat_align_32(<12 x float>*) {
3800 entry:
3801 %1 = load <12 x float>, <12 x float>* %0, align 32
3802 ret i32 0
3803 }
3804 ; CHECK-LABEL: define i32 @load_from_12xfloat_align_32(<12 x float>*) {
3805 ; CHECK: entry:
3806 ; CHECK-NEXT: %1 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 0
3807 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
3808 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 32
3809 ; CHECK-NEXT: %4 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 4
3810 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
3811 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 16
3812 ; CHECK-NEXT: %7 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 8
3813 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
3814 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8, align 32
3815 ; CHECK-NEXT: ret i32 0
3816 ; CHECK-NEXT: }
3817
3818 define i32 @load_from_12xdouble_align_32(<12 x double>*) {
3819 entry:
3820 %1 = load <12 x double>, <12 x double>* %0, align 32
3821 ret i32 0
3822 }
3823 ; CHECK-LABEL: define i32 @load_from_12xdouble_align_32(<12 x double>*) {
3824 ; CHECK: entry:
3825 ; CHECK-NEXT: %1 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 0
3826 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
3827 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 32
3828 ; CHECK-NEXT: %4 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 2
3829 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
3830 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 16
3831 ; CHECK-NEXT: %7 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 4
3832 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
3833 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 32
3834 ; CHECK-NEXT: %10 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 6
3835 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
3836 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 16
3837 ; CHECK-NEXT: %13 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 8
3838 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
3839 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14, align 32
3840 ; CHECK-NEXT: %16 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 10
3841 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
3842 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17, align 16
3843 ; CHECK-NEXT: ret i32 0
3844 ; CHECK-NEXT: }
3845
3846 define i32 @load_from_16xi8_align_32(<16 x i8>*) {
3847 entry:
3848 %1 = load <16 x i8>, <16 x i8>* %0, align 32
3849 ret i32 0
3850 }
3851 ; CHECK-LABEL: define i32 @load_from_16xi8_align_32(<16 x i8>*) {
3852 ; CHECK: entry:
3853 ; CHECK-NEXT: %1 = load <16 x i8>, <16 x i8>* %0, align 32
3854 ; CHECK-NEXT: ret i32 0
3855 ; CHECK-NEXT: }
3856
3857 define i32 @load_from_16xi16_align_32(<16 x i16>*) {
3858 entry:
3859 %1 = load <16 x i16>, <16 x i16>* %0, align 32
3860 ret i32 0
3861 }
3862 ; CHECK-LABEL: define i32 @load_from_16xi16_align_32(<16 x i16>*) {
3863 ; CHECK: entry:
3864 ; CHECK-NEXT: %1 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 0
3865 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
3866 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2, align 32
3867 ; CHECK-NEXT: %4 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 8
3868 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
3869 ; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5, align 16
3870 ; CHECK-NEXT: ret i32 0
3871 ; CHECK-NEXT: }
3872
3873 define i32 @load_from_16xi32_align_32(<16 x i32>*) {
3874 entry:
3875 %1 = load <16 x i32>, <16 x i32>* %0, align 32
3876 ret i32 0
3877 }
3878 ; CHECK-LABEL: define i32 @load_from_16xi32_align_32(<16 x i32>*) {
3879 ; CHECK: entry:
3880 ; CHECK-NEXT: %1 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 0
3881 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
3882 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 32
3883 ; CHECK-NEXT: %4 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 4
3884 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
3885 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 16
3886 ; CHECK-NEXT: %7 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 8
3887 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
3888 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8, align 32
3889 ; CHECK-NEXT: %10 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 12
3890 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
3891 ; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11, align 16
3892 ; CHECK-NEXT: ret i32 0
3893 ; CHECK-NEXT: }
3894
3895 define i32 @load_from_16xi64_align_32(<16 x i64>*) {
3896 entry:
3897 %1 = load <16 x i64>, <16 x i64>* %0, align 32
3898 ret i32 0
3899 }
3900 ; CHECK-LABEL: define i32 @load_from_16xi64_align_32(<16 x i64>*) {
3901 ; CHECK: entry:
3902 ; CHECK-NEXT: %1 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 0
3903 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
3904 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 32
3905 ; CHECK-NEXT: %4 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 2
3906 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
3907 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 16
3908 ; CHECK-NEXT: %7 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 4
3909 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
3910 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 32
3911 ; CHECK-NEXT: %10 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 6
3912 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
3913 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 16
3914 ; CHECK-NEXT: %13 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 8
3915 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
3916 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14, align 32
3917 ; CHECK-NEXT: %16 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 10
3918 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
3919 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17, align 16
3920 ; CHECK-NEXT: %19 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 12
3921 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
3922 ; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20, align 32
3923 ; CHECK-NEXT: %22 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 14
3924 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
3925 ; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23, align 16
3926 ; CHECK-NEXT: ret i32 0
3927 ; CHECK-NEXT: }
3928
3929 define i32 @load_from_16xi8ptr_align_32(<16 x i8*>*) {
3930 entry:
3931 %1 = load <16 x i8*>, <16 x i8*>* %0, align 32
3932 ret i32 0
3933 }
3934 ; CHECK-LABEL: define i32 @load_from_16xi8ptr_align_32(<16 x i8*>*) {
3935 ; CHECK: entry:
3936 ; CHECK-NEXT: %1 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 0
3937 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
3938 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 32
3939 ; CHECK-NEXT: %4 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 4
3940 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
3941 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 16
3942 ; CHECK-NEXT: %7 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 8
3943 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
3944 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8, align 32
3945 ; CHECK-NEXT: %10 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 12
3946 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
3947 ; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11, align 16
3948 ; CHECK-NEXT: ret i32 0
3949 ; CHECK-NEXT: }
3950
3951 define i32 @load_from_16xfloat_align_32(<16 x float>*) {
3952 entry:
3953 %1 = load <16 x float>, <16 x float>* %0, align 32
3954 ret i32 0
3955 }
3956 ; CHECK-LABEL: define i32 @load_from_16xfloat_align_32(<16 x float>*) {
3957 ; CHECK: entry:
3958 ; CHECK-NEXT: %1 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 0
3959 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
3960 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 32
3961 ; CHECK-NEXT: %4 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 4
3962 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
3963 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 16
3964 ; CHECK-NEXT: %7 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 8
3965 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
3966 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8, align 32
3967 ; CHECK-NEXT: %10 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 12
3968 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
3969 ; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11, align 16
3970 ; CHECK-NEXT: ret i32 0
3971 ; CHECK-NEXT: }
3972
3973 define i32 @load_from_16xdouble_align_32(<16 x double>*) {
3974 entry:
3975 %1 = load <16 x double>, <16 x double>* %0, align 32
3976 ret i32 0
3977 }
3978 ; CHECK-LABEL: define i32 @load_from_16xdouble_align_32(<16 x double>*) {
3979 ; CHECK: entry:
3980 ; CHECK-NEXT: %1 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 0
3981 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
3982 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 32
3983 ; CHECK-NEXT: %4 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 2
3984 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
3985 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 16
3986 ; CHECK-NEXT: %7 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 4
3987 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
3988 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 32
3989 ; CHECK-NEXT: %10 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 6
3990 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
3991 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 16
3992 ; CHECK-NEXT: %13 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 8
3993 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
3994 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14, align 32
3995 ; CHECK-NEXT: %16 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 10
3996 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
3997 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17, align 16
3998 ; CHECK-NEXT: %19 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 12
3999 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
4000 ; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20, align 32
4001 ; CHECK-NEXT: %22 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 14
4002 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
4003 ; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23, align 16
4004 ; CHECK-NEXT: ret i32 0
4005 ; CHECK-NEXT: }
4006
4007 define i32 @load_from_20xi8_align_32(<20 x i8>*) {
4008 entry:
4009 %1 = load <20 x i8>, <20 x i8>* %0, align 32
4010 ret i32 0
4011 }
4012 ; CHECK-LABEL: define i32 @load_from_20xi8_align_32(<20 x i8>*) {
4013 ; CHECK: entry:
4014 ; CHECK-NEXT: %1 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 0
4015 ; CHECK-NEXT: %2 = bitcast i8* %1 to <16 x i8>*
4016 ; CHECK-NEXT: %3 = load <16 x i8>, <16 x i8>* %2, align 32
4017 ; CHECK-NEXT: %4 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 16
4018 ; CHECK-NEXT: %5 = load i8, i8* %4, align 16
4019 ; CHECK-NEXT: %6 = insertelement <16 x i8> undef, i8 %5, i32 0
4020 ; CHECK-NEXT: %7 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 17
4021 ; CHECK-NEXT: %8 = load i8, i8* %7, align 1
4022 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 1
4023 ; CHECK-NEXT: %10 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 18
4024 ; CHECK-NEXT: %11 = load i8, i8* %10, align 2
4025 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 2
4026 ; CHECK-NEXT: %13 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 19
4027 ; CHECK-NEXT: %14 = load i8, i8* %13, align 1
4028 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 3
4029 ; CHECK-NEXT: ret i32 0
4030 ; CHECK-NEXT: }
4031
4032 define i32 @load_from_20xi16_align_32(<20 x i16>*) {
4033 entry:
4034 %1 = load <20 x i16>, <20 x i16>* %0, align 32
4035 ret i32 0
4036 }
4037 ; CHECK-LABEL: define i32 @load_from_20xi16_align_32(<20 x i16>*) {
4038 ; CHECK: entry:
4039 ; CHECK-NEXT: %1 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 0
4040 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
4041 ; CHECK-NEXT: %3 = load <8 x i16>, <8 x i16>* %2, align 32
4042 ; CHECK-NEXT: %4 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 8
4043 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
4044 ; CHECK-NEXT: %6 = load <8 x i16>, <8 x i16>* %5, align 16
4045 ; CHECK-NEXT: %7 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 16
4046 ; CHECK-NEXT: %8 = load i16, i16* %7, align 32
4047 ; CHECK-NEXT: %9 = insertelement <8 x i16> undef, i16 %8, i32 0
4048 ; CHECK-NEXT: %10 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 17
4049 ; CHECK-NEXT: %11 = load i16, i16* %10, align 2
4050 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 1
4051 ; CHECK-NEXT: %13 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 18
4052 ; CHECK-NEXT: %14 = load i16, i16* %13, align 4
4053 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 2
4054 ; CHECK-NEXT: %16 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 19
4055 ; CHECK-NEXT: %17 = load i16, i16* %16, align 2
4056 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 3
4057 ; CHECK-NEXT: ret i32 0
4058 ; CHECK-NEXT: }
4059
4060 define i32 @load_from_20xi32_align_32(<20 x i32>*) {
4061 entry:
4062 %1 = load <20 x i32>, <20 x i32>* %0, align 32
4063 ret i32 0
4064 }
4065 ; CHECK-LABEL: define i32 @load_from_20xi32_align_32(<20 x i32>*) {
4066 ; CHECK: entry:
4067 ; CHECK-NEXT: %1 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 0
4068 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
4069 ; CHECK-NEXT: %3 = load <4 x i32>, <4 x i32>* %2, align 32
4070 ; CHECK-NEXT: %4 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 4
4071 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
4072 ; CHECK-NEXT: %6 = load <4 x i32>, <4 x i32>* %5, align 16
4073 ; CHECK-NEXT: %7 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 8
4074 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
4075 ; CHECK-NEXT: %9 = load <4 x i32>, <4 x i32>* %8, align 32
4076 ; CHECK-NEXT: %10 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 12
4077 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
4078 ; CHECK-NEXT: %12 = load <4 x i32>, <4 x i32>* %11, align 16
4079 ; CHECK-NEXT: %13 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 16
4080 ; CHECK-NEXT: %14 = bitcast i32* %13 to <4 x i32>*
4081 ; CHECK-NEXT: %15 = load <4 x i32>, <4 x i32>* %14, align 32
4082 ; CHECK-NEXT: ret i32 0
4083 ; CHECK-NEXT: }
4084
4085 define i32 @load_from_20xi64_align_32(<20 x i64>*) {
4086 entry:
4087 %1 = load <20 x i64>, <20 x i64>* %0, align 32
4088 ret i32 0
4089 }
4090 ; CHECK-LABEL: define i32 @load_from_20xi64_align_32(<20 x i64>*) {
4091 ; CHECK: entry:
4092 ; CHECK-NEXT: %1 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 0
4093 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
4094 ; CHECK-NEXT: %3 = load <2 x i64>, <2 x i64>* %2, align 32
4095 ; CHECK-NEXT: %4 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 2
4096 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
4097 ; CHECK-NEXT: %6 = load <2 x i64>, <2 x i64>* %5, align 16
4098 ; CHECK-NEXT: %7 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 4
4099 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
4100 ; CHECK-NEXT: %9 = load <2 x i64>, <2 x i64>* %8, align 32
4101 ; CHECK-NEXT: %10 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 6
4102 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
4103 ; CHECK-NEXT: %12 = load <2 x i64>, <2 x i64>* %11, align 16
4104 ; CHECK-NEXT: %13 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 8
4105 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
4106 ; CHECK-NEXT: %15 = load <2 x i64>, <2 x i64>* %14, align 32
4107 ; CHECK-NEXT: %16 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 10
4108 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
4109 ; CHECK-NEXT: %18 = load <2 x i64>, <2 x i64>* %17, align 16
4110 ; CHECK-NEXT: %19 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 12
4111 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
4112 ; CHECK-NEXT: %21 = load <2 x i64>, <2 x i64>* %20, align 32
4113 ; CHECK-NEXT: %22 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 14
4114 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
4115 ; CHECK-NEXT: %24 = load <2 x i64>, <2 x i64>* %23, align 16
4116 ; CHECK-NEXT: %25 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 16
4117 ; CHECK-NEXT: %26 = bitcast i64* %25 to <2 x i64>*
4118 ; CHECK-NEXT: %27 = load <2 x i64>, <2 x i64>* %26, align 32
4119 ; CHECK-NEXT: %28 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 18
4120 ; CHECK-NEXT: %29 = bitcast i64* %28 to <2 x i64>*
4121 ; CHECK-NEXT: %30 = load <2 x i64>, <2 x i64>* %29, align 16
4122 ; CHECK-NEXT: ret i32 0
4123 ; CHECK-NEXT: }
4124
4125 define i32 @load_from_20xi8ptr_align_32(<20 x i8*>*) {
4126 entry:
4127 %1 = load <20 x i8*>, <20 x i8*>* %0, align 32
4128 ret i32 0
4129 }
4130 ; CHECK-LABEL: define i32 @load_from_20xi8ptr_align_32(<20 x i8*>*) {
4131 ; CHECK: entry:
4132 ; CHECK-NEXT: %1 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 0
4133 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
4134 ; CHECK-NEXT: %3 = load <4 x i8*>, <4 x i8*>* %2, align 32
4135 ; CHECK-NEXT: %4 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 4
4136 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
4137 ; CHECK-NEXT: %6 = load <4 x i8*>, <4 x i8*>* %5, align 16
4138 ; CHECK-NEXT: %7 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 8
4139 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
4140 ; CHECK-NEXT: %9 = load <4 x i8*>, <4 x i8*>* %8, align 32
4141 ; CHECK-NEXT: %10 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 12
4142 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
4143 ; CHECK-NEXT: %12 = load <4 x i8*>, <4 x i8*>* %11, align 16
4144 ; CHECK-NEXT: %13 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 16
4145 ; CHECK-NEXT: %14 = bitcast i8** %13 to <4 x i8*>*
4146 ; CHECK-NEXT: %15 = load <4 x i8*>, <4 x i8*>* %14, align 32
4147 ; CHECK-NEXT: ret i32 0
4148 ; CHECK-NEXT: }
4149
4150 define i32 @load_from_20xfloat_align_32(<20 x float>*) {
4151 entry:
4152 %1 = load <20 x float>, <20 x float>* %0, align 32
4153 ret i32 0
4154 }
4155 ; CHECK-LABEL: define i32 @load_from_20xfloat_align_32(<20 x float>*) {
4156 ; CHECK: entry:
4157 ; CHECK-NEXT: %1 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 0
4158 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
4159 ; CHECK-NEXT: %3 = load <4 x float>, <4 x float>* %2, align 32
4160 ; CHECK-NEXT: %4 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 4
4161 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
4162 ; CHECK-NEXT: %6 = load <4 x float>, <4 x float>* %5, align 16
4163 ; CHECK-NEXT: %7 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 8
4164 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
4165 ; CHECK-NEXT: %9 = load <4 x float>, <4 x float>* %8, align 32
4166 ; CHECK-NEXT: %10 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 12
4167 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
4168 ; CHECK-NEXT: %12 = load <4 x float>, <4 x float>* %11, align 16
4169 ; CHECK-NEXT: %13 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 16
4170 ; CHECK-NEXT: %14 = bitcast float* %13 to <4 x float>*
4171 ; CHECK-NEXT: %15 = load <4 x float>, <4 x float>* %14, align 32
4172 ; CHECK-NEXT: ret i32 0
4173 ; CHECK-NEXT: }
4174
4175 define i32 @load_from_20xdouble_align_32(<20 x double>*) {
4176 entry:
4177 %1 = load <20 x double>, <20 x double>* %0, align 32
4178 ret i32 0
4179 }
4180 ; CHECK-LABEL: define i32 @load_from_20xdouble_align_32(<20 x double>*) {
4181 ; CHECK: entry:
4182 ; CHECK-NEXT: %1 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 0
4183 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
4184 ; CHECK-NEXT: %3 = load <2 x double>, <2 x double>* %2, align 32
4185 ; CHECK-NEXT: %4 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 2
4186 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
4187 ; CHECK-NEXT: %6 = load <2 x double>, <2 x double>* %5, align 16
4188 ; CHECK-NEXT: %7 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 4
4189 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
4190 ; CHECK-NEXT: %9 = load <2 x double>, <2 x double>* %8, align 32
4191 ; CHECK-NEXT: %10 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 6
4192 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
4193 ; CHECK-NEXT: %12 = load <2 x double>, <2 x double>* %11, align 16
4194 ; CHECK-NEXT: %13 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 8
4195 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
4196 ; CHECK-NEXT: %15 = load <2 x double>, <2 x double>* %14, align 32
4197 ; CHECK-NEXT: %16 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 10
4198 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
4199 ; CHECK-NEXT: %18 = load <2 x double>, <2 x double>* %17, align 16
4200 ; CHECK-NEXT: %19 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 12
4201 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
4202 ; CHECK-NEXT: %21 = load <2 x double>, <2 x double>* %20, align 32
4203 ; CHECK-NEXT: %22 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 14
4204 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
4205 ; CHECK-NEXT: %24 = load <2 x double>, <2 x double>* %23, align 16
4206 ; CHECK-NEXT: %25 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 16
4207 ; CHECK-NEXT: %26 = bitcast double* %25 to <2 x double>*
4208 ; CHECK-NEXT: %27 = load <2 x double>, <2 x double>* %26, align 32
4209 ; CHECK-NEXT: %28 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 18
4210 ; CHECK-NEXT: %29 = bitcast double* %28 to <2 x double>*
4211 ; CHECK-NEXT: %30 = load <2 x double>, <2 x double>* %29, align 16
4212 ; CHECK-NEXT: ret i32 0
4213 ; CHECK-NEXT: }
4214
4215 define i32 @volatile_load_from_2xi8_unaligned(<2 x i8>*) {
4216 entry:
4217 %1 = load volatile <2 x i8>, <2 x i8>* %0
4218 ret i32 0
4219 }
4220 ; CHECK-LABEL: define i32 @volatile_load_from_2xi8_unaligned(<2 x i8>*) {
4221 ; CHECK: entry:
4222 ; CHECK-NEXT: %1 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 0
4223 ; CHECK-NEXT: %2 = load volatile i8, i8* %1
4224 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
4225 ; CHECK-NEXT: %4 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 1
4226 ; CHECK-NEXT: %5 = load volatile i8, i8* %4
4227 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
4228 ; CHECK-NEXT: ret i32 0
4229 ; CHECK-NEXT: }
4230
4231 define i32 @volatile_load_from_2xi16_unaligned(<2 x i16>*) {
4232 entry:
4233 %1 = load volatile <2 x i16>, <2 x i16>* %0
4234 ret i32 0
4235 }
4236 ; CHECK-LABEL: define i32 @volatile_load_from_2xi16_unaligned(<2 x i16>*) {
4237 ; CHECK: entry:
4238 ; CHECK-NEXT: %1 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 0
4239 ; CHECK-NEXT: %2 = load volatile i16, i16* %1
4240 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
4241 ; CHECK-NEXT: %4 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 1
4242 ; CHECK-NEXT: %5 = load volatile i16, i16* %4
4243 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
4244 ; CHECK-NEXT: ret i32 0
4245 ; CHECK-NEXT: }
4246
4247 define i32 @volatile_load_from_2xi32_unaligned(<2 x i32>*) {
4248 entry:
4249 %1 = load volatile <2 x i32>, <2 x i32>* %0
4250 ret i32 0
4251 }
4252 ; CHECK-LABEL: define i32 @volatile_load_from_2xi32_unaligned(<2 x i32>*) {
4253 ; CHECK: entry:
4254 ; CHECK-NEXT: %1 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 0
4255 ; CHECK-NEXT: %2 = load volatile i32, i32* %1
4256 ; CHECK-NEXT: %3 = insertelement <4 x i32> undef, i32 %2, i32 0
4257 ; CHECK-NEXT: %4 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 1
4258 ; CHECK-NEXT: %5 = load volatile i32, i32* %4
4259 ; CHECK-NEXT: %6 = insertelement <4 x i32> %3, i32 %5, i32 1
4260 ; CHECK-NEXT: ret i32 0
4261 ; CHECK-NEXT: }
4262
4263 define i32 @volatile_load_from_2xi64_unaligned(<2 x i64>*) {
4264 entry:
4265 %1 = load volatile <2 x i64>, <2 x i64>* %0
4266 ret i32 0
4267 }
4268 ; CHECK-LABEL: define i32 @volatile_load_from_2xi64_unaligned(<2 x i64>*) {
4269 ; CHECK: entry:
4270 ; CHECK-NEXT: %1 = load volatile <2 x i64>, <2 x i64>* %0
4271 ; CHECK-NEXT: ret i32 0
4272 ; CHECK-NEXT: }
4273
4274 define i32 @volatile_load_from_2xi8ptr_unaligned(<2 x i8*>*) {
4275 entry:
4276 %1 = load volatile <2 x i8*>, <2 x i8*>* %0
4277 ret i32 0
4278 }
4279 ; CHECK-LABEL: define i32 @volatile_load_from_2xi8ptr_unaligned(<2 x i8*>*) {
4280 ; CHECK: entry:
4281 ; CHECK-NEXT: %1 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 0
4282 ; CHECK-NEXT: %2 = load volatile i8*, i8** %1
4283 ; CHECK-NEXT: %3 = insertelement <4 x i8*> undef, i8* %2, i32 0
4284 ; CHECK-NEXT: %4 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 1
4285 ; CHECK-NEXT: %5 = load volatile i8*, i8** %4
4286 ; CHECK-NEXT: %6 = insertelement <4 x i8*> %3, i8* %5, i32 1
4287 ; CHECK-NEXT: ret i32 0
4288 ; CHECK-NEXT: }
4289
4290 define i32 @volatile_load_from_2xfloat_unaligned(<2 x float>*) {
4291 entry:
4292 %1 = load volatile <2 x float>, <2 x float>* %0
4293 ret i32 0
4294 }
4295 ; CHECK-LABEL: define i32 @volatile_load_from_2xfloat_unaligned(<2 x float>*) {
4296 ; CHECK: entry:
4297 ; CHECK-NEXT: %1 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 0
4298 ; CHECK-NEXT: %2 = load volatile float, float* %1
4299 ; CHECK-NEXT: %3 = insertelement <4 x float> undef, float %2, i32 0
4300 ; CHECK-NEXT: %4 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 1
4301 ; CHECK-NEXT: %5 = load volatile float, float* %4
4302 ; CHECK-NEXT: %6 = insertelement <4 x float> %3, float %5, i32 1
4303 ; CHECK-NEXT: ret i32 0
4304 ; CHECK-NEXT: }
4305
4306 define i32 @volatile_load_from_2xdouble_unaligned(<2 x double>*) {
4307 entry:
4308 %1 = load volatile <2 x double>, <2 x double>* %0
4309 ret i32 0
4310 }
4311 ; CHECK-LABEL: define i32 @volatile_load_from_2xdouble_unaligned(<2 x double>*) {
4312 ; CHECK: entry:
4313 ; CHECK-NEXT: %1 = load volatile <2 x double>, <2 x double>* %0
4314 ; CHECK-NEXT: ret i32 0
4315 ; CHECK-NEXT: }
4316
4317 define i32 @volatile_load_from_4xi8_unaligned(<4 x i8>*) {
4318 entry:
4319 %1 = load volatile <4 x i8>, <4 x i8>* %0
4320 ret i32 0
4321 }
4322 ; CHECK-LABEL: define i32 @volatile_load_from_4xi8_unaligned(<4 x i8>*) {
4323 ; CHECK: entry:
4324 ; CHECK-NEXT: %1 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 0
4325 ; CHECK-NEXT: %2 = load volatile i8, i8* %1
4326 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
4327 ; CHECK-NEXT: %4 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 1
4328 ; CHECK-NEXT: %5 = load volatile i8, i8* %4
4329 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
4330 ; CHECK-NEXT: %7 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 2
4331 ; CHECK-NEXT: %8 = load volatile i8, i8* %7
4332 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
4333 ; CHECK-NEXT: %10 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 3
4334 ; CHECK-NEXT: %11 = load volatile i8, i8* %10
4335 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
4336 ; CHECK-NEXT: ret i32 0
4337 ; CHECK-NEXT: }
4338
4339 define i32 @volatile_load_from_4xi16_unaligned(<4 x i16>*) {
4340 entry:
4341 %1 = load volatile <4 x i16>, <4 x i16>* %0
4342 ret i32 0
4343 }
4344 ; CHECK-LABEL: define i32 @volatile_load_from_4xi16_unaligned(<4 x i16>*) {
4345 ; CHECK: entry:
4346 ; CHECK-NEXT: %1 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 0
4347 ; CHECK-NEXT: %2 = load volatile i16, i16* %1
4348 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
4349 ; CHECK-NEXT: %4 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 1
4350 ; CHECK-NEXT: %5 = load volatile i16, i16* %4
4351 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
4352 ; CHECK-NEXT: %7 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 2
4353 ; CHECK-NEXT: %8 = load volatile i16, i16* %7
4354 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
4355 ; CHECK-NEXT: %10 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 3
4356 ; CHECK-NEXT: %11 = load volatile i16, i16* %10
4357 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
4358 ; CHECK-NEXT: ret i32 0
4359 ; CHECK-NEXT: }
4360
4361 define i32 @volatile_load_from_4xi32_unaligned(<4 x i32>*) {
4362 entry:
4363 %1 = load volatile <4 x i32>, <4 x i32>* %0
4364 ret i32 0
4365 }
4366 ; CHECK-LABEL: define i32 @volatile_load_from_4xi32_unaligned(<4 x i32>*) {
4367 ; CHECK: entry:
4368 ; CHECK-NEXT: %1 = load volatile <4 x i32>, <4 x i32>* %0
4369 ; CHECK-NEXT: ret i32 0
4370 ; CHECK-NEXT: }
4371
4372 define i32 @volatile_load_from_4xi64_unaligned(<4 x i64>*) {
4373 entry:
4374 %1 = load volatile <4 x i64>, <4 x i64>* %0
4375 ret i32 0
4376 }
4377 ; CHECK-LABEL: define i32 @volatile_load_from_4xi64_unaligned(<4 x i64>*) {
4378 ; CHECK: entry:
4379 ; CHECK-NEXT: %1 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 0
4380 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
4381 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2
4382 ; CHECK-NEXT: %4 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 2
4383 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
4384 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5
4385 ; CHECK-NEXT: ret i32 0
4386 ; CHECK-NEXT: }
4387
4388 define i32 @volatile_load_from_4xi8ptr_unaligned(<4 x i8*>*) {
4389 entry:
4390 %1 = load volatile <4 x i8*>, <4 x i8*>* %0
4391 ret i32 0
4392 }
4393 ; CHECK-LABEL: define i32 @volatile_load_from_4xi8ptr_unaligned(<4 x i8*>*) {
4394 ; CHECK: entry:
4395 ; CHECK-NEXT: %1 = load volatile <4 x i8*>, <4 x i8*>* %0
4396 ; CHECK-NEXT: ret i32 0
4397 ; CHECK-NEXT: }
4398
4399 define i32 @volatile_load_from_4xfloat_unaligned(<4 x float>*) {
4400 entry:
4401 %1 = load volatile <4 x float>, <4 x float>* %0
4402 ret i32 0
4403 }
4404 ; CHECK-LABEL: define i32 @volatile_load_from_4xfloat_unaligned(<4 x float>*) {
4405 ; CHECK: entry:
4406 ; CHECK-NEXT: %1 = load volatile <4 x float>, <4 x float>* %0
4407 ; CHECK-NEXT: ret i32 0
4408 ; CHECK-NEXT: }
4409
4410 define i32 @volatile_load_from_4xdouble_unaligned(<4 x double>*) {
4411 entry:
4412 %1 = load volatile <4 x double>, <4 x double>* %0
4413 ret i32 0
4414 }
4415 ; CHECK-LABEL: define i32 @volatile_load_from_4xdouble_unaligned(<4 x double>*) {
4416 ; CHECK: entry:
4417 ; CHECK-NEXT: %1 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 0
4418 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
4419 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2
4420 ; CHECK-NEXT: %4 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 2
4421 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
4422 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5
4423 ; CHECK-NEXT: ret i32 0
4424 ; CHECK-NEXT: }
4425
4426 define i32 @volatile_load_from_6xi8_unaligned(<6 x i8>*) {
4427 entry:
4428 %1 = load volatile <6 x i8>, <6 x i8>* %0
4429 ret i32 0
4430 }
4431 ; CHECK-LABEL: define i32 @volatile_load_from_6xi8_unaligned(<6 x i8>*) {
4432 ; CHECK: entry:
4433 ; CHECK-NEXT: %1 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 0
4434 ; CHECK-NEXT: %2 = load volatile i8, i8* %1
4435 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
4436 ; CHECK-NEXT: %4 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 1
4437 ; CHECK-NEXT: %5 = load volatile i8, i8* %4
4438 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
4439 ; CHECK-NEXT: %7 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 2
4440 ; CHECK-NEXT: %8 = load volatile i8, i8* %7
4441 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
4442 ; CHECK-NEXT: %10 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 3
4443 ; CHECK-NEXT: %11 = load volatile i8, i8* %10
4444 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
4445 ; CHECK-NEXT: %13 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 4
4446 ; CHECK-NEXT: %14 = load volatile i8, i8* %13
4447 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
4448 ; CHECK-NEXT: %16 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 5
4449 ; CHECK-NEXT: %17 = load volatile i8, i8* %16
4450 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
4451 ; CHECK-NEXT: ret i32 0
4452 ; CHECK-NEXT: }
4453
4454 define i32 @volatile_load_from_6xi16_unaligned(<6 x i16>*) {
4455 entry:
4456 %1 = load volatile <6 x i16>, <6 x i16>* %0
4457 ret i32 0
4458 }
4459 ; CHECK-LABEL: define i32 @volatile_load_from_6xi16_unaligned(<6 x i16>*) {
4460 ; CHECK: entry:
4461 ; CHECK-NEXT: %1 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 0
4462 ; CHECK-NEXT: %2 = load volatile i16, i16* %1
4463 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
4464 ; CHECK-NEXT: %4 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 1
4465 ; CHECK-NEXT: %5 = load volatile i16, i16* %4
4466 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
4467 ; CHECK-NEXT: %7 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 2
4468 ; CHECK-NEXT: %8 = load volatile i16, i16* %7
4469 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
4470 ; CHECK-NEXT: %10 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 3
4471 ; CHECK-NEXT: %11 = load volatile i16, i16* %10
4472 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
4473 ; CHECK-NEXT: %13 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 4
4474 ; CHECK-NEXT: %14 = load volatile i16, i16* %13
4475 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 4
4476 ; CHECK-NEXT: %16 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 5
4477 ; CHECK-NEXT: %17 = load volatile i16, i16* %16
4478 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 5
4479 ; CHECK-NEXT: ret i32 0
4480 ; CHECK-NEXT: }
4481
4482 define i32 @volatile_load_from_6xi32_unaligned(<6 x i32>*) {
4483 entry:
4484 %1 = load volatile <6 x i32>, <6 x i32>* %0
4485 ret i32 0
4486 }
4487 ; CHECK-LABEL: define i32 @volatile_load_from_6xi32_unaligned(<6 x i32>*) {
4488 ; CHECK: entry:
4489 ; CHECK-NEXT: %1 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 0
4490 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
4491 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2
4492 ; CHECK-NEXT: %4 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 4
4493 ; CHECK-NEXT: %5 = load volatile i32, i32* %4
4494 ; CHECK-NEXT: %6 = insertelement <4 x i32> undef, i32 %5, i32 0
4495 ; CHECK-NEXT: %7 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 5
4496 ; CHECK-NEXT: %8 = load volatile i32, i32* %7
4497 ; CHECK-NEXT: %9 = insertelement <4 x i32> %6, i32 %8, i32 1
4498 ; CHECK-NEXT: ret i32 0
4499 ; CHECK-NEXT: }
4500
4501 define i32 @volatile_load_from_6xi64_unaligned(<6 x i64>*) {
4502 entry:
4503 %1 = load volatile <6 x i64>, <6 x i64>* %0
4504 ret i32 0
4505 }
4506 ; CHECK-LABEL: define i32 @volatile_load_from_6xi64_unaligned(<6 x i64>*) {
4507 ; CHECK: entry:
4508 ; CHECK-NEXT: %1 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 0
4509 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
4510 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2
4511 ; CHECK-NEXT: %4 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 2
4512 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
4513 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5
4514 ; CHECK-NEXT: %7 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 4
4515 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
4516 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8
4517 ; CHECK-NEXT: ret i32 0
4518 ; CHECK-NEXT: }
4519
4520 define i32 @volatile_load_from_6xi8ptr_unaligned(<6 x i8*>*) {
4521 entry:
4522 %1 = load volatile <6 x i8*>, <6 x i8*>* %0
4523 ret i32 0
4524 }
4525 ; CHECK-LABEL: define i32 @volatile_load_from_6xi8ptr_unaligned(<6 x i8*>*) {
4526 ; CHECK: entry:
4527 ; CHECK-NEXT: %1 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 0
4528 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
4529 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2
4530 ; CHECK-NEXT: %4 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 4
4531 ; CHECK-NEXT: %5 = load volatile i8*, i8** %4
4532 ; CHECK-NEXT: %6 = insertelement <4 x i8*> undef, i8* %5, i32 0
4533 ; CHECK-NEXT: %7 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 5
4534 ; CHECK-NEXT: %8 = load volatile i8*, i8** %7
4535 ; CHECK-NEXT: %9 = insertelement <4 x i8*> %6, i8* %8, i32 1
4536 ; CHECK-NEXT: ret i32 0
4537 ; CHECK-NEXT: }
4538
4539 define i32 @volatile_load_from_6xfloat_unaligned(<6 x float>*) {
4540 entry:
4541 %1 = load volatile <6 x float>, <6 x float>* %0
4542 ret i32 0
4543 }
4544 ; CHECK-LABEL: define i32 @volatile_load_from_6xfloat_unaligned(<6 x float>*) {
4545 ; CHECK: entry:
4546 ; CHECK-NEXT: %1 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 0
4547 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
4548 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2
4549 ; CHECK-NEXT: %4 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 4
4550 ; CHECK-NEXT: %5 = load volatile float, float* %4
4551 ; CHECK-NEXT: %6 = insertelement <4 x float> undef, float %5, i32 0
4552 ; CHECK-NEXT: %7 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 5
4553 ; CHECK-NEXT: %8 = load volatile float, float* %7
4554 ; CHECK-NEXT: %9 = insertelement <4 x float> %6, float %8, i32 1
4555 ; CHECK-NEXT: ret i32 0
4556 ; CHECK-NEXT: }
4557
4558 define i32 @volatile_load_from_6xdouble_unaligned(<6 x double>*) {
4559 entry:
4560 %1 = load volatile <6 x double>, <6 x double>* %0
4561 ret i32 0
4562 }
4563 ; CHECK-LABEL: define i32 @volatile_load_from_6xdouble_unaligned(<6 x double>*) {
4564 ; CHECK: entry:
4565 ; CHECK-NEXT: %1 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 0
4566 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
4567 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2
4568 ; CHECK-NEXT: %4 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 2
4569 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
4570 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5
4571 ; CHECK-NEXT: %7 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 4
4572 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
4573 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8
4574 ; CHECK-NEXT: ret i32 0
4575 ; CHECK-NEXT: }
4576
4577 define i32 @volatile_load_from_8xi8_unaligned(<8 x i8>*) {
4578 entry:
4579 %1 = load volatile <8 x i8>, <8 x i8>* %0
4580 ret i32 0
4581 }
4582 ; CHECK-LABEL: define i32 @volatile_load_from_8xi8_unaligned(<8 x i8>*) {
4583 ; CHECK: entry:
4584 ; CHECK-NEXT: %1 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 0
4585 ; CHECK-NEXT: %2 = load volatile i8, i8* %1
4586 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
4587 ; CHECK-NEXT: %4 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 1
4588 ; CHECK-NEXT: %5 = load volatile i8, i8* %4
4589 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
4590 ; CHECK-NEXT: %7 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 2
4591 ; CHECK-NEXT: %8 = load volatile i8, i8* %7
4592 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
4593 ; CHECK-NEXT: %10 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 3
4594 ; CHECK-NEXT: %11 = load volatile i8, i8* %10
4595 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
4596 ; CHECK-NEXT: %13 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 4
4597 ; CHECK-NEXT: %14 = load volatile i8, i8* %13
4598 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
4599 ; CHECK-NEXT: %16 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 5
4600 ; CHECK-NEXT: %17 = load volatile i8, i8* %16
4601 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
4602 ; CHECK-NEXT: %19 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 6
4603 ; CHECK-NEXT: %20 = load volatile i8, i8* %19
4604 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
4605 ; CHECK-NEXT: %22 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 7
4606 ; CHECK-NEXT: %23 = load volatile i8, i8* %22
4607 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
4608 ; CHECK-NEXT: ret i32 0
4609 ; CHECK-NEXT: }
4610
4611 define i32 @volatile_load_from_8xi16_unaligned(<8 x i16>*) {
4612 entry:
4613 %1 = load volatile <8 x i16>, <8 x i16>* %0
4614 ret i32 0
4615 }
4616 ; CHECK-LABEL: define i32 @volatile_load_from_8xi16_unaligned(<8 x i16>*) {
4617 ; CHECK: entry:
4618 ; CHECK-NEXT: %1 = load volatile <8 x i16>, <8 x i16>* %0
4619 ; CHECK-NEXT: ret i32 0
4620 ; CHECK-NEXT: }
4621
4622 define i32 @volatile_load_from_8xi32_unaligned(<8 x i32>*) {
4623 entry:
4624 %1 = load volatile <8 x i32>, <8 x i32>* %0
4625 ret i32 0
4626 }
4627 ; CHECK-LABEL: define i32 @volatile_load_from_8xi32_unaligned(<8 x i32>*) {
4628 ; CHECK: entry:
4629 ; CHECK-NEXT: %1 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 0
4630 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
4631 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2
4632 ; CHECK-NEXT: %4 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 4
4633 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
4634 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5
4635 ; CHECK-NEXT: ret i32 0
4636 ; CHECK-NEXT: }
4637
4638 define i32 @volatile_load_from_8xi64_unaligned(<8 x i64>*) {
4639 entry:
4640 %1 = load volatile <8 x i64>, <8 x i64>* %0
4641 ret i32 0
4642 }
4643 ; CHECK-LABEL: define i32 @volatile_load_from_8xi64_unaligned(<8 x i64>*) {
4644 ; CHECK: entry:
4645 ; CHECK-NEXT: %1 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 0
4646 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
4647 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2
4648 ; CHECK-NEXT: %4 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 2
4649 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
4650 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5
4651 ; CHECK-NEXT: %7 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 4
4652 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
4653 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8
4654 ; CHECK-NEXT: %10 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 6
4655 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
4656 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11
4657 ; CHECK-NEXT: ret i32 0
4658 ; CHECK-NEXT: }
4659
4660 define i32 @volatile_load_from_8xi8ptr_unaligned(<8 x i8*>*) {
4661 entry:
4662 %1 = load volatile <8 x i8*>, <8 x i8*>* %0
4663 ret i32 0
4664 }
4665 ; CHECK-LABEL: define i32 @volatile_load_from_8xi8ptr_unaligned(<8 x i8*>*) {
4666 ; CHECK: entry:
4667 ; CHECK-NEXT: %1 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 0
4668 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
4669 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2
4670 ; CHECK-NEXT: %4 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 4
4671 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
4672 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5
4673 ; CHECK-NEXT: ret i32 0
4674 ; CHECK-NEXT: }
4675
4676 define i32 @volatile_load_from_8xfloat_unaligned(<8 x float>*) {
4677 entry:
4678 %1 = load volatile <8 x float>, <8 x float>* %0
4679 ret i32 0
4680 }
4681 ; CHECK-LABEL: define i32 @volatile_load_from_8xfloat_unaligned(<8 x float>*) {
4682 ; CHECK: entry:
4683 ; CHECK-NEXT: %1 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 0
4684 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
4685 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2
4686 ; CHECK-NEXT: %4 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 4
4687 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
4688 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5
4689 ; CHECK-NEXT: ret i32 0
4690 ; CHECK-NEXT: }
4691
4692 define i32 @volatile_load_from_8xdouble_unaligned(<8 x double>*) {
4693 entry:
4694 %1 = load volatile <8 x double>, <8 x double>* %0
4695 ret i32 0
4696 }
4697 ; CHECK-LABEL: define i32 @volatile_load_from_8xdouble_unaligned(<8 x double>*) {
4698 ; CHECK: entry:
4699 ; CHECK-NEXT: %1 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 0
4700 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
4701 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2
4702 ; CHECK-NEXT: %4 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 2
4703 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
4704 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5
4705 ; CHECK-NEXT: %7 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 4
4706 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
4707 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8
4708 ; CHECK-NEXT: %10 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 6
4709 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
4710 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11
4711 ; CHECK-NEXT: ret i32 0
4712 ; CHECK-NEXT: }
4713
4714 define i32 @volatile_load_from_12xi8_unaligned(<12 x i8>*) {
4715 entry:
4716 %1 = load volatile <12 x i8>, <12 x i8>* %0
4717 ret i32 0
4718 }
4719 ; CHECK-LABEL: define i32 @volatile_load_from_12xi8_unaligned(<12 x i8>*) {
4720 ; CHECK: entry:
4721 ; CHECK-NEXT: %1 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 0
4722 ; CHECK-NEXT: %2 = load volatile i8, i8* %1
4723 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
4724 ; CHECK-NEXT: %4 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 1
4725 ; CHECK-NEXT: %5 = load volatile i8, i8* %4
4726 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
4727 ; CHECK-NEXT: %7 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 2
4728 ; CHECK-NEXT: %8 = load volatile i8, i8* %7
4729 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
4730 ; CHECK-NEXT: %10 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 3
4731 ; CHECK-NEXT: %11 = load volatile i8, i8* %10
4732 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
4733 ; CHECK-NEXT: %13 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 4
4734 ; CHECK-NEXT: %14 = load volatile i8, i8* %13
4735 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
4736 ; CHECK-NEXT: %16 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 5
4737 ; CHECK-NEXT: %17 = load volatile i8, i8* %16
4738 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
4739 ; CHECK-NEXT: %19 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 6
4740 ; CHECK-NEXT: %20 = load volatile i8, i8* %19
4741 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
4742 ; CHECK-NEXT: %22 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 7
4743 ; CHECK-NEXT: %23 = load volatile i8, i8* %22
4744 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
4745 ; CHECK-NEXT: %25 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 8
4746 ; CHECK-NEXT: %26 = load volatile i8, i8* %25
4747 ; CHECK-NEXT: %27 = insertelement <16 x i8> %24, i8 %26, i32 8
4748 ; CHECK-NEXT: %28 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 9
4749 ; CHECK-NEXT: %29 = load volatile i8, i8* %28
4750 ; CHECK-NEXT: %30 = insertelement <16 x i8> %27, i8 %29, i32 9
4751 ; CHECK-NEXT: %31 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 10
4752 ; CHECK-NEXT: %32 = load volatile i8, i8* %31
4753 ; CHECK-NEXT: %33 = insertelement <16 x i8> %30, i8 %32, i32 10
4754 ; CHECK-NEXT: %34 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 11
4755 ; CHECK-NEXT: %35 = load volatile i8, i8* %34
4756 ; CHECK-NEXT: %36 = insertelement <16 x i8> %33, i8 %35, i32 11
4757 ; CHECK-NEXT: ret i32 0
4758 ; CHECK-NEXT: }
4759
4760 define i32 @volatile_load_from_12xi16_unaligned(<12 x i16>*) {
4761 entry:
4762 %1 = load volatile <12 x i16>, <12 x i16>* %0
4763 ret i32 0
4764 }
4765 ; CHECK-LABEL: define i32 @volatile_load_from_12xi16_unaligned(<12 x i16>*) {
4766 ; CHECK: entry:
4767 ; CHECK-NEXT: %1 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 0
4768 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
4769 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2
4770 ; CHECK-NEXT: %4 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 8
4771 ; CHECK-NEXT: %5 = load volatile i16, i16* %4
4772 ; CHECK-NEXT: %6 = insertelement <8 x i16> undef, i16 %5, i32 0
4773 ; CHECK-NEXT: %7 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 9
4774 ; CHECK-NEXT: %8 = load volatile i16, i16* %7
4775 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 1
4776 ; CHECK-NEXT: %10 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 10
4777 ; CHECK-NEXT: %11 = load volatile i16, i16* %10
4778 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 2
4779 ; CHECK-NEXT: %13 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 11
4780 ; CHECK-NEXT: %14 = load volatile i16, i16* %13
4781 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 3
4782 ; CHECK-NEXT: ret i32 0
4783 ; CHECK-NEXT: }
4784
4785 define i32 @volatile_load_from_12xi32_unaligned(<12 x i32>*) {
4786 entry:
4787 %1 = load volatile <12 x i32>, <12 x i32>* %0
4788 ret i32 0
4789 }
4790 ; CHECK-LABEL: define i32 @volatile_load_from_12xi32_unaligned(<12 x i32>*) {
4791 ; CHECK: entry:
4792 ; CHECK-NEXT: %1 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 0
4793 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
4794 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2
4795 ; CHECK-NEXT: %4 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 4
4796 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
4797 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5
4798 ; CHECK-NEXT: %7 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 8
4799 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
4800 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8
4801 ; CHECK-NEXT: ret i32 0
4802 ; CHECK-NEXT: }
4803
4804 define i32 @volatile_load_from_12xi64_unaligned(<12 x i64>*) {
4805 entry:
4806 %1 = load volatile <12 x i64>, <12 x i64>* %0
4807 ret i32 0
4808 }
4809 ; CHECK-LABEL: define i32 @volatile_load_from_12xi64_unaligned(<12 x i64>*) {
4810 ; CHECK: entry:
4811 ; CHECK-NEXT: %1 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 0
4812 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
4813 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2
4814 ; CHECK-NEXT: %4 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 2
4815 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
4816 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5
4817 ; CHECK-NEXT: %7 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 4
4818 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
4819 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8
4820 ; CHECK-NEXT: %10 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 6
4821 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
4822 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11
4823 ; CHECK-NEXT: %13 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 8
4824 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
4825 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14
4826 ; CHECK-NEXT: %16 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 10
4827 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
4828 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17
4829 ; CHECK-NEXT: ret i32 0
4830 ; CHECK-NEXT: }
4831
4832 define i32 @volatile_load_from_12xi8ptr_unaligned(<12 x i8*>*) {
4833 entry:
4834 %1 = load volatile <12 x i8*>, <12 x i8*>* %0
4835 ret i32 0
4836 }
4837 ; CHECK-LABEL: define i32 @volatile_load_from_12xi8ptr_unaligned(<12 x i8*>*) {
4838 ; CHECK: entry:
4839 ; CHECK-NEXT: %1 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 0
4840 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
4841 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2
4842 ; CHECK-NEXT: %4 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 4
4843 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
4844 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5
4845 ; CHECK-NEXT: %7 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 8
4846 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
4847 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8
4848 ; CHECK-NEXT: ret i32 0
4849 ; CHECK-NEXT: }
4850
4851 define i32 @volatile_load_from_12xfloat_unaligned(<12 x float>*) {
4852 entry:
4853 %1 = load volatile <12 x float>, <12 x float>* %0
4854 ret i32 0
4855 }
4856 ; CHECK-LABEL: define i32 @volatile_load_from_12xfloat_unaligned(<12 x float>*) {
4857 ; CHECK: entry:
4858 ; CHECK-NEXT: %1 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 0
4859 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
4860 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2
4861 ; CHECK-NEXT: %4 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 4
4862 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
4863 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5
4864 ; CHECK-NEXT: %7 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 8
4865 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
4866 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8
4867 ; CHECK-NEXT: ret i32 0
4868 ; CHECK-NEXT: }
4869
4870 define i32 @volatile_load_from_12xdouble_unaligned(<12 x double>*) {
4871 entry:
4872 %1 = load volatile <12 x double>, <12 x double>* %0
4873 ret i32 0
4874 }
4875 ; CHECK-LABEL: define i32 @volatile_load_from_12xdouble_unaligned(<12 x double>* ) {
4876 ; CHECK: entry:
4877 ; CHECK-NEXT: %1 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 0
4878 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
4879 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2
4880 ; CHECK-NEXT: %4 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 2
4881 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
4882 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5
4883 ; CHECK-NEXT: %7 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 4
4884 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
4885 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8
4886 ; CHECK-NEXT: %10 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 6
4887 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
4888 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11
4889 ; CHECK-NEXT: %13 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 8
4890 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
4891 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14
4892 ; CHECK-NEXT: %16 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 10
4893 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
4894 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17
4895 ; CHECK-NEXT: ret i32 0
4896 ; CHECK-NEXT: }
4897
4898 define i32 @volatile_load_from_16xi8_unaligned(<16 x i8>*) {
4899 entry:
4900 %1 = load volatile <16 x i8>, <16 x i8>* %0
4901 ret i32 0
4902 }
4903 ; CHECK-LABEL: define i32 @volatile_load_from_16xi8_unaligned(<16 x i8>*) {
4904 ; CHECK: entry:
4905 ; CHECK-NEXT: %1 = load volatile <16 x i8>, <16 x i8>* %0
4906 ; CHECK-NEXT: ret i32 0
4907 ; CHECK-NEXT: }
4908
4909 define i32 @volatile_load_from_16xi16_unaligned(<16 x i16>*) {
4910 entry:
4911 %1 = load volatile <16 x i16>, <16 x i16>* %0
4912 ret i32 0
4913 }
4914 ; CHECK-LABEL: define i32 @volatile_load_from_16xi16_unaligned(<16 x i16>*) {
4915 ; CHECK: entry:
4916 ; CHECK-NEXT: %1 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 0
4917 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
4918 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2
4919 ; CHECK-NEXT: %4 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 8
4920 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
4921 ; CHECK-NEXT: %6 = load volatile <8 x i16>, <8 x i16>* %5
4922 ; CHECK-NEXT: ret i32 0
4923 ; CHECK-NEXT: }
4924
4925 define i32 @volatile_load_from_16xi32_unaligned(<16 x i32>*) {
4926 entry:
4927 %1 = load volatile <16 x i32>, <16 x i32>* %0
4928 ret i32 0
4929 }
4930 ; CHECK-LABEL: define i32 @volatile_load_from_16xi32_unaligned(<16 x i32>*) {
4931 ; CHECK: entry:
4932 ; CHECK-NEXT: %1 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 0
4933 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
4934 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2
4935 ; CHECK-NEXT: %4 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 4
4936 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
4937 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5
4938 ; CHECK-NEXT: %7 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 8
4939 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
4940 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8
4941 ; CHECK-NEXT: %10 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 12
4942 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
4943 ; CHECK-NEXT: %12 = load volatile <4 x i32>, <4 x i32>* %11
4944 ; CHECK-NEXT: ret i32 0
4945 ; CHECK-NEXT: }
4946
4947 define i32 @volatile_load_from_16xi64_unaligned(<16 x i64>*) {
4948 entry:
4949 %1 = load volatile <16 x i64>, <16 x i64>* %0
4950 ret i32 0
4951 }
4952 ; CHECK-LABEL: define i32 @volatile_load_from_16xi64_unaligned(<16 x i64>*) {
4953 ; CHECK: entry:
4954 ; CHECK-NEXT: %1 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 0
4955 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
4956 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2
4957 ; CHECK-NEXT: %4 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 2
4958 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
4959 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5
4960 ; CHECK-NEXT: %7 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 4
4961 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
4962 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8
4963 ; CHECK-NEXT: %10 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 6
4964 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
4965 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11
4966 ; CHECK-NEXT: %13 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 8
4967 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
4968 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14
4969 ; CHECK-NEXT: %16 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 10
4970 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
4971 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17
4972 ; CHECK-NEXT: %19 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 12
4973 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
4974 ; CHECK-NEXT: %21 = load volatile <2 x i64>, <2 x i64>* %20
4975 ; CHECK-NEXT: %22 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 14
4976 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
4977 ; CHECK-NEXT: %24 = load volatile <2 x i64>, <2 x i64>* %23
4978 ; CHECK-NEXT: ret i32 0
4979 ; CHECK-NEXT: }
4980
4981 define i32 @volatile_load_from_16xi8ptr_unaligned(<16 x i8*>*) {
4982 entry:
4983 %1 = load volatile <16 x i8*>, <16 x i8*>* %0
4984 ret i32 0
4985 }
4986 ; CHECK-LABEL: define i32 @volatile_load_from_16xi8ptr_unaligned(<16 x i8*>*) {
4987 ; CHECK: entry:
4988 ; CHECK-NEXT: %1 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 0
4989 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
4990 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2
4991 ; CHECK-NEXT: %4 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 4
4992 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
4993 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5
4994 ; CHECK-NEXT: %7 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 8
4995 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
4996 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8
4997 ; CHECK-NEXT: %10 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 12
4998 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
4999 ; CHECK-NEXT: %12 = load volatile <4 x i8*>, <4 x i8*>* %11
5000 ; CHECK-NEXT: ret i32 0
5001 ; CHECK-NEXT: }
5002
5003 define i32 @volatile_load_from_16xfloat_unaligned(<16 x float>*) {
5004 entry:
5005 %1 = load volatile <16 x float>, <16 x float>* %0
5006 ret i32 0
5007 }
5008 ; CHECK-LABEL: define i32 @volatile_load_from_16xfloat_unaligned(<16 x float>*) {
5009 ; CHECK: entry:
5010 ; CHECK-NEXT: %1 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 0
5011 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
5012 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2
5013 ; CHECK-NEXT: %4 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 4
5014 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
5015 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5
5016 ; CHECK-NEXT: %7 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 8
5017 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
5018 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8
5019 ; CHECK-NEXT: %10 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 12
5020 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
5021 ; CHECK-NEXT: %12 = load volatile <4 x float>, <4 x float>* %11
5022 ; CHECK-NEXT: ret i32 0
5023 ; CHECK-NEXT: }
5024
5025 define i32 @volatile_load_from_16xdouble_unaligned(<16 x double>*) {
5026 entry:
5027 %1 = load volatile <16 x double>, <16 x double>* %0
5028 ret i32 0
5029 }
5030 ; CHECK-LABEL: define i32 @volatile_load_from_16xdouble_unaligned(<16 x double>* ) {
5031 ; CHECK: entry:
5032 ; CHECK-NEXT: %1 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 0
5033 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
5034 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2
5035 ; CHECK-NEXT: %4 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 2
5036 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
5037 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5
5038 ; CHECK-NEXT: %7 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 4
5039 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
5040 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8
5041 ; CHECK-NEXT: %10 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 6
5042 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
5043 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11
5044 ; CHECK-NEXT: %13 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 8
5045 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
5046 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14
5047 ; CHECK-NEXT: %16 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 10
5048 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
5049 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17
5050 ; CHECK-NEXT: %19 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 12
5051 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
5052 ; CHECK-NEXT: %21 = load volatile <2 x double>, <2 x double>* %20
5053 ; CHECK-NEXT: %22 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 14
5054 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
5055 ; CHECK-NEXT: %24 = load volatile <2 x double>, <2 x double>* %23
5056 ; CHECK-NEXT: ret i32 0
5057 ; CHECK-NEXT: }
5058
5059 define i32 @volatile_load_from_20xi8_unaligned(<20 x i8>*) {
5060 entry:
5061 %1 = load volatile <20 x i8>, <20 x i8>* %0
5062 ret i32 0
5063 }
5064 ; CHECK-LABEL: define i32 @volatile_load_from_20xi8_unaligned(<20 x i8>*) {
5065 ; CHECK: entry:
5066 ; CHECK-NEXT: %1 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 0
5067 ; CHECK-NEXT: %2 = bitcast i8* %1 to <16 x i8>*
5068 ; CHECK-NEXT: %3 = load volatile <16 x i8>, <16 x i8>* %2
5069 ; CHECK-NEXT: %4 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 16
5070 ; CHECK-NEXT: %5 = load volatile i8, i8* %4
5071 ; CHECK-NEXT: %6 = insertelement <16 x i8> undef, i8 %5, i32 0
5072 ; CHECK-NEXT: %7 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 17
5073 ; CHECK-NEXT: %8 = load volatile i8, i8* %7
5074 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 1
5075 ; CHECK-NEXT: %10 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 18
5076 ; CHECK-NEXT: %11 = load volatile i8, i8* %10
5077 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 2
5078 ; CHECK-NEXT: %13 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 19
5079 ; CHECK-NEXT: %14 = load volatile i8, i8* %13
5080 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 3
5081 ; CHECK-NEXT: ret i32 0
5082 ; CHECK-NEXT: }
5083
5084 define i32 @volatile_load_from_20xi16_unaligned(<20 x i16>*) {
5085 entry:
5086 %1 = load volatile <20 x i16>, <20 x i16>* %0
5087 ret i32 0
5088 }
5089 ; CHECK-LABEL: define i32 @volatile_load_from_20xi16_unaligned(<20 x i16>*) {
5090 ; CHECK: entry:
5091 ; CHECK-NEXT: %1 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 0
5092 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
5093 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2
5094 ; CHECK-NEXT: %4 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 8
5095 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
5096 ; CHECK-NEXT: %6 = load volatile <8 x i16>, <8 x i16>* %5
5097 ; CHECK-NEXT: %7 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 16
5098 ; CHECK-NEXT: %8 = load volatile i16, i16* %7
5099 ; CHECK-NEXT: %9 = insertelement <8 x i16> undef, i16 %8, i32 0
5100 ; CHECK-NEXT: %10 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 17
5101 ; CHECK-NEXT: %11 = load volatile i16, i16* %10
5102 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 1
5103 ; CHECK-NEXT: %13 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 18
5104 ; CHECK-NEXT: %14 = load volatile i16, i16* %13
5105 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 2
5106 ; CHECK-NEXT: %16 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 19
5107 ; CHECK-NEXT: %17 = load volatile i16, i16* %16
5108 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 3
5109 ; CHECK-NEXT: ret i32 0
5110 ; CHECK-NEXT: }
5111
5112 define i32 @volatile_load_from_20xi32_unaligned(<20 x i32>*) {
5113 entry:
5114 %1 = load volatile <20 x i32>, <20 x i32>* %0
5115 ret i32 0
5116 }
5117 ; CHECK-LABEL: define i32 @volatile_load_from_20xi32_unaligned(<20 x i32>*) {
5118 ; CHECK: entry:
5119 ; CHECK-NEXT: %1 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 0
5120 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
5121 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2
5122 ; CHECK-NEXT: %4 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 4
5123 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
5124 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5
5125 ; CHECK-NEXT: %7 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 8
5126 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
5127 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8
5128 ; CHECK-NEXT: %10 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 12
5129 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
5130 ; CHECK-NEXT: %12 = load volatile <4 x i32>, <4 x i32>* %11
5131 ; CHECK-NEXT: %13 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 16
5132 ; CHECK-NEXT: %14 = bitcast i32* %13 to <4 x i32>*
5133 ; CHECK-NEXT: %15 = load volatile <4 x i32>, <4 x i32>* %14
5134 ; CHECK-NEXT: ret i32 0
5135 ; CHECK-NEXT: }
5136
5137 define i32 @volatile_load_from_20xi64_unaligned(<20 x i64>*) {
5138 entry:
5139 %1 = load volatile <20 x i64>, <20 x i64>* %0
5140 ret i32 0
5141 }
5142 ; CHECK-LABEL: define i32 @volatile_load_from_20xi64_unaligned(<20 x i64>*) {
5143 ; CHECK: entry:
5144 ; CHECK-NEXT: %1 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 0
5145 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
5146 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2
5147 ; CHECK-NEXT: %4 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 2
5148 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
5149 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5
5150 ; CHECK-NEXT: %7 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 4
5151 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
5152 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8
5153 ; CHECK-NEXT: %10 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 6
5154 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
5155 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11
5156 ; CHECK-NEXT: %13 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 8
5157 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
5158 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14
5159 ; CHECK-NEXT: %16 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 10
5160 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
5161 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17
5162 ; CHECK-NEXT: %19 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 12
5163 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
5164 ; CHECK-NEXT: %21 = load volatile <2 x i64>, <2 x i64>* %20
5165 ; CHECK-NEXT: %22 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 14
5166 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
5167 ; CHECK-NEXT: %24 = load volatile <2 x i64>, <2 x i64>* %23
5168 ; CHECK-NEXT: %25 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 16
5169 ; CHECK-NEXT: %26 = bitcast i64* %25 to <2 x i64>*
5170 ; CHECK-NEXT: %27 = load volatile <2 x i64>, <2 x i64>* %26
5171 ; CHECK-NEXT: %28 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 18
5172 ; CHECK-NEXT: %29 = bitcast i64* %28 to <2 x i64>*
5173 ; CHECK-NEXT: %30 = load volatile <2 x i64>, <2 x i64>* %29
5174 ; CHECK-NEXT: ret i32 0
5175 ; CHECK-NEXT: }
5176
5177 define i32 @volatile_load_from_20xi8ptr_unaligned(<20 x i8*>*) {
5178 entry:
5179 %1 = load volatile <20 x i8*>, <20 x i8*>* %0
5180 ret i32 0
5181 }
5182 ; CHECK-LABEL: define i32 @volatile_load_from_20xi8ptr_unaligned(<20 x i8*>*) {
5183 ; CHECK: entry:
5184 ; CHECK-NEXT: %1 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 0
5185 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
5186 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2
5187 ; CHECK-NEXT: %4 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 4
5188 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
5189 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5
5190 ; CHECK-NEXT: %7 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 8
5191 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
5192 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8
5193 ; CHECK-NEXT: %10 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 12
5194 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
5195 ; CHECK-NEXT: %12 = load volatile <4 x i8*>, <4 x i8*>* %11
5196 ; CHECK-NEXT: %13 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 16
5197 ; CHECK-NEXT: %14 = bitcast i8** %13 to <4 x i8*>*
5198 ; CHECK-NEXT: %15 = load volatile <4 x i8*>, <4 x i8*>* %14
5199 ; CHECK-NEXT: ret i32 0
5200 ; CHECK-NEXT: }
5201
5202 define i32 @volatile_load_from_20xfloat_unaligned(<20 x float>*) {
5203 entry:
5204 %1 = load volatile <20 x float>, <20 x float>* %0
5205 ret i32 0
5206 }
5207 ; CHECK-LABEL: define i32 @volatile_load_from_20xfloat_unaligned(<20 x float>*) {
5208 ; CHECK: entry:
5209 ; CHECK-NEXT: %1 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 0
5210 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
5211 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2
5212 ; CHECK-NEXT: %4 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 4
5213 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
5214 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5
5215 ; CHECK-NEXT: %7 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 8
5216 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
5217 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8
5218 ; CHECK-NEXT: %10 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 12
5219 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
5220 ; CHECK-NEXT: %12 = load volatile <4 x float>, <4 x float>* %11
5221 ; CHECK-NEXT: %13 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 16
5222 ; CHECK-NEXT: %14 = bitcast float* %13 to <4 x float>*
5223 ; CHECK-NEXT: %15 = load volatile <4 x float>, <4 x float>* %14
5224 ; CHECK-NEXT: ret i32 0
5225 ; CHECK-NEXT: }
5226
5227 define i32 @volatile_load_from_20xdouble_unaligned(<20 x double>*) {
5228 entry:
5229 %1 = load volatile <20 x double>, <20 x double>* %0
5230 ret i32 0
5231 }
5232 ; CHECK-LABEL: define i32 @volatile_load_from_20xdouble_unaligned(<20 x double>* ) {
5233 ; CHECK: entry:
5234 ; CHECK-NEXT: %1 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 0
5235 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
5236 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2
5237 ; CHECK-NEXT: %4 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 2
5238 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
5239 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5
5240 ; CHECK-NEXT: %7 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 4
5241 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
5242 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8
5243 ; CHECK-NEXT: %10 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 6
5244 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
5245 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11
5246 ; CHECK-NEXT: %13 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 8
5247 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
5248 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14
5249 ; CHECK-NEXT: %16 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 10
5250 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
5251 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17
5252 ; CHECK-NEXT: %19 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 12
5253 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
5254 ; CHECK-NEXT: %21 = load volatile <2 x double>, <2 x double>* %20
5255 ; CHECK-NEXT: %22 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 14
5256 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
5257 ; CHECK-NEXT: %24 = load volatile <2 x double>, <2 x double>* %23
5258 ; CHECK-NEXT: %25 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 16
5259 ; CHECK-NEXT: %26 = bitcast double* %25 to <2 x double>*
5260 ; CHECK-NEXT: %27 = load volatile <2 x double>, <2 x double>* %26
5261 ; CHECK-NEXT: %28 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 18
5262 ; CHECK-NEXT: %29 = bitcast double* %28 to <2 x double>*
5263 ; CHECK-NEXT: %30 = load volatile <2 x double>, <2 x double>* %29
5264 ; CHECK-NEXT: ret i32 0
5265 ; CHECK-NEXT: }
5266
5267 define i32 @volatile_load_from_2xi8_align_1(<2 x i8>*) {
5268 entry:
5269 %1 = load volatile <2 x i8>, <2 x i8>* %0, align 1
5270 ret i32 0
5271 }
5272 ; CHECK-LABEL: define i32 @volatile_load_from_2xi8_align_1(<2 x i8>*) {
5273 ; CHECK: entry:
5274 ; CHECK-NEXT: %1 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 0
5275 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 1
5276 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
5277 ; CHECK-NEXT: %4 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 1
5278 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
5279 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
5280 ; CHECK-NEXT: ret i32 0
5281 ; CHECK-NEXT: }
5282
5283 define i32 @volatile_load_from_2xi16_align_1(<2 x i16>*) {
5284 entry:
5285 %1 = load volatile <2 x i16>, <2 x i16>* %0, align 1
5286 ret i32 0
5287 }
5288 ; CHECK-LABEL: define i32 @volatile_load_from_2xi16_align_1(<2 x i16>*) {
5289 ; CHECK: entry:
5290 ; CHECK-NEXT: %1 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 0
5291 ; CHECK-NEXT: %2 = load volatile i16, i16* %1, align 1
5292 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
5293 ; CHECK-NEXT: %4 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 1
5294 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 1
5295 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
5296 ; CHECK-NEXT: ret i32 0
5297 ; CHECK-NEXT: }
5298
5299 define i32 @volatile_load_from_2xi32_align_1(<2 x i32>*) {
5300 entry:
5301 %1 = load volatile <2 x i32>, <2 x i32>* %0, align 1
5302 ret i32 0
5303 }
5304 ; CHECK-LABEL: define i32 @volatile_load_from_2xi32_align_1(<2 x i32>*) {
5305 ; CHECK: entry:
5306 ; CHECK-NEXT: %1 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 0
5307 ; CHECK-NEXT: %2 = load volatile i32, i32* %1, align 1
5308 ; CHECK-NEXT: %3 = insertelement <4 x i32> undef, i32 %2, i32 0
5309 ; CHECK-NEXT: %4 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 1
5310 ; CHECK-NEXT: %5 = load volatile i32, i32* %4, align 1
5311 ; CHECK-NEXT: %6 = insertelement <4 x i32> %3, i32 %5, i32 1
5312 ; CHECK-NEXT: ret i32 0
5313 ; CHECK-NEXT: }
5314
5315 define i32 @volatile_load_from_2xi64_align_1(<2 x i64>*) {
5316 entry:
5317 %1 = load volatile <2 x i64>, <2 x i64>* %0, align 1
5318 ret i32 0
5319 }
5320 ; CHECK-LABEL: define i32 @volatile_load_from_2xi64_align_1(<2 x i64>*) {
5321 ; CHECK: entry:
5322 ; CHECK-NEXT: %1 = load volatile <2 x i64>, <2 x i64>* %0, align 1
5323 ; CHECK-NEXT: ret i32 0
5324 ; CHECK-NEXT: }
5325
5326 define i32 @volatile_load_from_2xi8ptr_align_1(<2 x i8*>*) {
5327 entry:
5328 %1 = load volatile <2 x i8*>, <2 x i8*>* %0, align 1
5329 ret i32 0
5330 }
5331 ; CHECK-LABEL: define i32 @volatile_load_from_2xi8ptr_align_1(<2 x i8*>*) {
5332 ; CHECK: entry:
5333 ; CHECK-NEXT: %1 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 0
5334 ; CHECK-NEXT: %2 = load volatile i8*, i8** %1, align 1
5335 ; CHECK-NEXT: %3 = insertelement <4 x i8*> undef, i8* %2, i32 0
5336 ; CHECK-NEXT: %4 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 1
5337 ; CHECK-NEXT: %5 = load volatile i8*, i8** %4, align 1
5338 ; CHECK-NEXT: %6 = insertelement <4 x i8*> %3, i8* %5, i32 1
5339 ; CHECK-NEXT: ret i32 0
5340 ; CHECK-NEXT: }
5341
5342 define i32 @volatile_load_from_2xfloat_align_1(<2 x float>*) {
5343 entry:
5344 %1 = load volatile <2 x float>, <2 x float>* %0, align 1
5345 ret i32 0
5346 }
5347 ; CHECK-LABEL: define i32 @volatile_load_from_2xfloat_align_1(<2 x float>*) {
5348 ; CHECK: entry:
5349 ; CHECK-NEXT: %1 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 0
5350 ; CHECK-NEXT: %2 = load volatile float, float* %1, align 1
5351 ; CHECK-NEXT: %3 = insertelement <4 x float> undef, float %2, i32 0
5352 ; CHECK-NEXT: %4 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 1
5353 ; CHECK-NEXT: %5 = load volatile float, float* %4, align 1
5354 ; CHECK-NEXT: %6 = insertelement <4 x float> %3, float %5, i32 1
5355 ; CHECK-NEXT: ret i32 0
5356 ; CHECK-NEXT: }
5357
5358 define i32 @volatile_load_from_2xdouble_align_1(<2 x double>*) {
5359 entry:
5360 %1 = load volatile <2 x double>, <2 x double>* %0, align 1
5361 ret i32 0
5362 }
5363 ; CHECK-LABEL: define i32 @volatile_load_from_2xdouble_align_1(<2 x double>*) {
5364 ; CHECK: entry:
5365 ; CHECK-NEXT: %1 = load volatile <2 x double>, <2 x double>* %0, align 1
5366 ; CHECK-NEXT: ret i32 0
5367 ; CHECK-NEXT: }
5368
5369 define i32 @volatile_load_from_4xi8_align_1(<4 x i8>*) {
5370 entry:
5371 %1 = load volatile <4 x i8>, <4 x i8>* %0, align 1
5372 ret i32 0
5373 }
5374 ; CHECK-LABEL: define i32 @volatile_load_from_4xi8_align_1(<4 x i8>*) {
5375 ; CHECK: entry:
5376 ; CHECK-NEXT: %1 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 0
5377 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 1
5378 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
5379 ; CHECK-NEXT: %4 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 1
5380 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
5381 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
5382 ; CHECK-NEXT: %7 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 2
5383 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 1
5384 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
5385 ; CHECK-NEXT: %10 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 3
5386 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
5387 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
5388 ; CHECK-NEXT: ret i32 0
5389 ; CHECK-NEXT: }
5390
5391 define i32 @volatile_load_from_4xi16_align_1(<4 x i16>*) {
5392 entry:
5393 %1 = load volatile <4 x i16>, <4 x i16>* %0, align 1
5394 ret i32 0
5395 }
5396 ; CHECK-LABEL: define i32 @volatile_load_from_4xi16_align_1(<4 x i16>*) {
5397 ; CHECK: entry:
5398 ; CHECK-NEXT: %1 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 0
5399 ; CHECK-NEXT: %2 = load volatile i16, i16* %1, align 1
5400 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
5401 ; CHECK-NEXT: %4 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 1
5402 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 1
5403 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
5404 ; CHECK-NEXT: %7 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 2
5405 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 1
5406 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
5407 ; CHECK-NEXT: %10 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 3
5408 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 1
5409 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
5410 ; CHECK-NEXT: ret i32 0
5411 ; CHECK-NEXT: }
5412
5413 define i32 @volatile_load_from_4xi32_align_1(<4 x i32>*) {
5414 entry:
5415 %1 = load volatile <4 x i32>, <4 x i32>* %0, align 1
5416 ret i32 0
5417 }
5418 ; CHECK-LABEL: define i32 @volatile_load_from_4xi32_align_1(<4 x i32>*) {
5419 ; CHECK: entry:
5420 ; CHECK-NEXT: %1 = load volatile <4 x i32>, <4 x i32>* %0, align 1
5421 ; CHECK-NEXT: ret i32 0
5422 ; CHECK-NEXT: }
5423
5424 define i32 @volatile_load_from_4xi64_align_1(<4 x i64>*) {
5425 entry:
5426 %1 = load volatile <4 x i64>, <4 x i64>* %0, align 1
5427 ret i32 0
5428 }
5429 ; CHECK-LABEL: define i32 @volatile_load_from_4xi64_align_1(<4 x i64>*) {
5430 ; CHECK: entry:
5431 ; CHECK-NEXT: %1 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 0
5432 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
5433 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 1
5434 ; CHECK-NEXT: %4 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 2
5435 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
5436 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 1
5437 ; CHECK-NEXT: ret i32 0
5438 ; CHECK-NEXT: }
5439
5440 define i32 @volatile_load_from_4xi8ptr_align_1(<4 x i8*>*) {
5441 entry:
5442 %1 = load volatile <4 x i8*>, <4 x i8*>* %0, align 1
5443 ret i32 0
5444 }
5445 ; CHECK-LABEL: define i32 @volatile_load_from_4xi8ptr_align_1(<4 x i8*>*) {
5446 ; CHECK: entry:
5447 ; CHECK-NEXT: %1 = load volatile <4 x i8*>, <4 x i8*>* %0, align 1
5448 ; CHECK-NEXT: ret i32 0
5449 ; CHECK-NEXT: }
5450
5451 define i32 @volatile_load_from_4xfloat_align_1(<4 x float>*) {
5452 entry:
5453 %1 = load volatile <4 x float>, <4 x float>* %0, align 1
5454 ret i32 0
5455 }
5456 ; CHECK-LABEL: define i32 @volatile_load_from_4xfloat_align_1(<4 x float>*) {
5457 ; CHECK: entry:
5458 ; CHECK-NEXT: %1 = load volatile <4 x float>, <4 x float>* %0, align 1
5459 ; CHECK-NEXT: ret i32 0
5460 ; CHECK-NEXT: }
5461
5462 define i32 @volatile_load_from_4xdouble_align_1(<4 x double>*) {
5463 entry:
5464 %1 = load volatile <4 x double>, <4 x double>* %0, align 1
5465 ret i32 0
5466 }
5467 ; CHECK-LABEL: define i32 @volatile_load_from_4xdouble_align_1(<4 x double>*) {
5468 ; CHECK: entry:
5469 ; CHECK-NEXT: %1 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 0
5470 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
5471 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 1
5472 ; CHECK-NEXT: %4 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 2
5473 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
5474 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 1
5475 ; CHECK-NEXT: ret i32 0
5476 ; CHECK-NEXT: }
5477
5478 define i32 @volatile_load_from_6xi8_align_1(<6 x i8>*) {
5479 entry:
5480 %1 = load volatile <6 x i8>, <6 x i8>* %0, align 1
5481 ret i32 0
5482 }
5483 ; CHECK-LABEL: define i32 @volatile_load_from_6xi8_align_1(<6 x i8>*) {
5484 ; CHECK: entry:
5485 ; CHECK-NEXT: %1 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 0
5486 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 1
5487 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
5488 ; CHECK-NEXT: %4 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 1
5489 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
5490 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
5491 ; CHECK-NEXT: %7 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 2
5492 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 1
5493 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
5494 ; CHECK-NEXT: %10 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 3
5495 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
5496 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
5497 ; CHECK-NEXT: %13 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 4
5498 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 1
5499 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
5500 ; CHECK-NEXT: %16 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 5
5501 ; CHECK-NEXT: %17 = load volatile i8, i8* %16, align 1
5502 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
5503 ; CHECK-NEXT: ret i32 0
5504 ; CHECK-NEXT: }
5505
5506 define i32 @volatile_load_from_6xi16_align_1(<6 x i16>*) {
5507 entry:
5508 %1 = load volatile <6 x i16>, <6 x i16>* %0, align 1
5509 ret i32 0
5510 }
5511 ; CHECK-LABEL: define i32 @volatile_load_from_6xi16_align_1(<6 x i16>*) {
5512 ; CHECK: entry:
5513 ; CHECK-NEXT: %1 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 0
5514 ; CHECK-NEXT: %2 = load volatile i16, i16* %1, align 1
5515 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
5516 ; CHECK-NEXT: %4 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 1
5517 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 1
5518 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
5519 ; CHECK-NEXT: %7 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 2
5520 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 1
5521 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
5522 ; CHECK-NEXT: %10 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 3
5523 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 1
5524 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
5525 ; CHECK-NEXT: %13 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 4
5526 ; CHECK-NEXT: %14 = load volatile i16, i16* %13, align 1
5527 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 4
5528 ; CHECK-NEXT: %16 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 5
5529 ; CHECK-NEXT: %17 = load volatile i16, i16* %16, align 1
5530 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 5
5531 ; CHECK-NEXT: ret i32 0
5532 ; CHECK-NEXT: }
5533
5534 define i32 @volatile_load_from_6xi32_align_1(<6 x i32>*) {
5535 entry:
5536 %1 = load volatile <6 x i32>, <6 x i32>* %0, align 1
5537 ret i32 0
5538 }
5539 ; CHECK-LABEL: define i32 @volatile_load_from_6xi32_align_1(<6 x i32>*) {
5540 ; CHECK: entry:
5541 ; CHECK-NEXT: %1 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 0
5542 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
5543 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 1
5544 ; CHECK-NEXT: %4 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 4
5545 ; CHECK-NEXT: %5 = load volatile i32, i32* %4, align 1
5546 ; CHECK-NEXT: %6 = insertelement <4 x i32> undef, i32 %5, i32 0
5547 ; CHECK-NEXT: %7 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 5
5548 ; CHECK-NEXT: %8 = load volatile i32, i32* %7, align 1
5549 ; CHECK-NEXT: %9 = insertelement <4 x i32> %6, i32 %8, i32 1
5550 ; CHECK-NEXT: ret i32 0
5551 ; CHECK-NEXT: }
5552
5553 define i32 @volatile_load_from_6xi64_align_1(<6 x i64>*) {
5554 entry:
5555 %1 = load volatile <6 x i64>, <6 x i64>* %0, align 1
5556 ret i32 0
5557 }
5558 ; CHECK-LABEL: define i32 @volatile_load_from_6xi64_align_1(<6 x i64>*) {
5559 ; CHECK: entry:
5560 ; CHECK-NEXT: %1 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 0
5561 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
5562 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 1
5563 ; CHECK-NEXT: %4 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 2
5564 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
5565 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 1
5566 ; CHECK-NEXT: %7 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 4
5567 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
5568 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 1
5569 ; CHECK-NEXT: ret i32 0
5570 ; CHECK-NEXT: }
5571
5572 define i32 @volatile_load_from_6xi8ptr_align_1(<6 x i8*>*) {
5573 entry:
5574 %1 = load volatile <6 x i8*>, <6 x i8*>* %0, align 1
5575 ret i32 0
5576 }
5577 ; CHECK-LABEL: define i32 @volatile_load_from_6xi8ptr_align_1(<6 x i8*>*) {
5578 ; CHECK: entry:
5579 ; CHECK-NEXT: %1 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 0
5580 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
5581 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 1
5582 ; CHECK-NEXT: %4 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 4
5583 ; CHECK-NEXT: %5 = load volatile i8*, i8** %4, align 1
5584 ; CHECK-NEXT: %6 = insertelement <4 x i8*> undef, i8* %5, i32 0
5585 ; CHECK-NEXT: %7 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 5
5586 ; CHECK-NEXT: %8 = load volatile i8*, i8** %7, align 1
5587 ; CHECK-NEXT: %9 = insertelement <4 x i8*> %6, i8* %8, i32 1
5588 ; CHECK-NEXT: ret i32 0
5589 ; CHECK-NEXT: }
5590
5591 define i32 @volatile_load_from_6xfloat_align_1(<6 x float>*) {
5592 entry:
5593 %1 = load volatile <6 x float>, <6 x float>* %0, align 1
5594 ret i32 0
5595 }
5596 ; CHECK-LABEL: define i32 @volatile_load_from_6xfloat_align_1(<6 x float>*) {
5597 ; CHECK: entry:
5598 ; CHECK-NEXT: %1 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 0
5599 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
5600 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 1
5601 ; CHECK-NEXT: %4 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 4
5602 ; CHECK-NEXT: %5 = load volatile float, float* %4, align 1
5603 ; CHECK-NEXT: %6 = insertelement <4 x float> undef, float %5, i32 0
5604 ; CHECK-NEXT: %7 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 5
5605 ; CHECK-NEXT: %8 = load volatile float, float* %7, align 1
5606 ; CHECK-NEXT: %9 = insertelement <4 x float> %6, float %8, i32 1
5607 ; CHECK-NEXT: ret i32 0
5608 ; CHECK-NEXT: }
5609
5610 define i32 @volatile_load_from_6xdouble_align_1(<6 x double>*) {
5611 entry:
5612 %1 = load volatile <6 x double>, <6 x double>* %0, align 1
5613 ret i32 0
5614 }
5615 ; CHECK-LABEL: define i32 @volatile_load_from_6xdouble_align_1(<6 x double>*) {
5616 ; CHECK: entry:
5617 ; CHECK-NEXT: %1 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 0
5618 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
5619 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 1
5620 ; CHECK-NEXT: %4 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 2
5621 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
5622 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 1
5623 ; CHECK-NEXT: %7 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 4
5624 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
5625 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 1
5626 ; CHECK-NEXT: ret i32 0
5627 ; CHECK-NEXT: }
5628
5629 define i32 @volatile_load_from_8xi8_align_1(<8 x i8>*) {
5630 entry:
5631 %1 = load volatile <8 x i8>, <8 x i8>* %0, align 1
5632 ret i32 0
5633 }
5634 ; CHECK-LABEL: define i32 @volatile_load_from_8xi8_align_1(<8 x i8>*) {
5635 ; CHECK: entry:
5636 ; CHECK-NEXT: %1 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 0
5637 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 1
5638 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
5639 ; CHECK-NEXT: %4 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 1
5640 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
5641 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
5642 ; CHECK-NEXT: %7 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 2
5643 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 1
5644 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
5645 ; CHECK-NEXT: %10 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 3
5646 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
5647 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
5648 ; CHECK-NEXT: %13 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 4
5649 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 1
5650 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
5651 ; CHECK-NEXT: %16 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 5
5652 ; CHECK-NEXT: %17 = load volatile i8, i8* %16, align 1
5653 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
5654 ; CHECK-NEXT: %19 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 6
5655 ; CHECK-NEXT: %20 = load volatile i8, i8* %19, align 1
5656 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
5657 ; CHECK-NEXT: %22 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 7
5658 ; CHECK-NEXT: %23 = load volatile i8, i8* %22, align 1
5659 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
5660 ; CHECK-NEXT: ret i32 0
5661 ; CHECK-NEXT: }
5662
5663 define i32 @volatile_load_from_8xi16_align_1(<8 x i16>*) {
5664 entry:
5665 %1 = load volatile <8 x i16>, <8 x i16>* %0, align 1
5666 ret i32 0
5667 }
5668 ; CHECK-LABEL: define i32 @volatile_load_from_8xi16_align_1(<8 x i16>*) {
5669 ; CHECK: entry:
5670 ; CHECK-NEXT: %1 = load volatile <8 x i16>, <8 x i16>* %0, align 1
5671 ; CHECK-NEXT: ret i32 0
5672 ; CHECK-NEXT: }
5673
5674 define i32 @volatile_load_from_8xi32_align_1(<8 x i32>*) {
5675 entry:
5676 %1 = load volatile <8 x i32>, <8 x i32>* %0, align 1
5677 ret i32 0
5678 }
5679 ; CHECK-LABEL: define i32 @volatile_load_from_8xi32_align_1(<8 x i32>*) {
5680 ; CHECK: entry:
5681 ; CHECK-NEXT: %1 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 0
5682 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
5683 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 1
5684 ; CHECK-NEXT: %4 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 4
5685 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
5686 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 1
5687 ; CHECK-NEXT: ret i32 0
5688 ; CHECK-NEXT: }
5689
5690 define i32 @volatile_load_from_8xi64_align_1(<8 x i64>*) {
5691 entry:
5692 %1 = load volatile <8 x i64>, <8 x i64>* %0, align 1
5693 ret i32 0
5694 }
5695 ; CHECK-LABEL: define i32 @volatile_load_from_8xi64_align_1(<8 x i64>*) {
5696 ; CHECK: entry:
5697 ; CHECK-NEXT: %1 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 0
5698 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
5699 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 1
5700 ; CHECK-NEXT: %4 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 2
5701 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
5702 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 1
5703 ; CHECK-NEXT: %7 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 4
5704 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
5705 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 1
5706 ; CHECK-NEXT: %10 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 6
5707 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
5708 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 1
5709 ; CHECK-NEXT: ret i32 0
5710 ; CHECK-NEXT: }
5711
5712 define i32 @volatile_load_from_8xi8ptr_align_1(<8 x i8*>*) {
5713 entry:
5714 %1 = load volatile <8 x i8*>, <8 x i8*>* %0, align 1
5715 ret i32 0
5716 }
5717 ; CHECK-LABEL: define i32 @volatile_load_from_8xi8ptr_align_1(<8 x i8*>*) {
5718 ; CHECK: entry:
5719 ; CHECK-NEXT: %1 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 0
5720 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
5721 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 1
5722 ; CHECK-NEXT: %4 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 4
5723 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
5724 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 1
5725 ; CHECK-NEXT: ret i32 0
5726 ; CHECK-NEXT: }
5727
5728 define i32 @volatile_load_from_8xfloat_align_1(<8 x float>*) {
5729 entry:
5730 %1 = load volatile <8 x float>, <8 x float>* %0, align 1
5731 ret i32 0
5732 }
5733 ; CHECK-LABEL: define i32 @volatile_load_from_8xfloat_align_1(<8 x float>*) {
5734 ; CHECK: entry:
5735 ; CHECK-NEXT: %1 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 0
5736 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
5737 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 1
5738 ; CHECK-NEXT: %4 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 4
5739 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
5740 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 1
5741 ; CHECK-NEXT: ret i32 0
5742 ; CHECK-NEXT: }
5743
5744 define i32 @volatile_load_from_8xdouble_align_1(<8 x double>*) {
5745 entry:
5746 %1 = load volatile <8 x double>, <8 x double>* %0, align 1
5747 ret i32 0
5748 }
5749 ; CHECK-LABEL: define i32 @volatile_load_from_8xdouble_align_1(<8 x double>*) {
5750 ; CHECK: entry:
5751 ; CHECK-NEXT: %1 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 0
5752 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
5753 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 1
5754 ; CHECK-NEXT: %4 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 2
5755 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
5756 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 1
5757 ; CHECK-NEXT: %7 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 4
5758 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
5759 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 1
5760 ; CHECK-NEXT: %10 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 6
5761 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
5762 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 1
5763 ; CHECK-NEXT: ret i32 0
5764 ; CHECK-NEXT: }
5765
5766 define i32 @volatile_load_from_12xi8_align_1(<12 x i8>*) {
5767 entry:
5768 %1 = load volatile <12 x i8>, <12 x i8>* %0, align 1
5769 ret i32 0
5770 }
5771 ; CHECK-LABEL: define i32 @volatile_load_from_12xi8_align_1(<12 x i8>*) {
5772 ; CHECK: entry:
5773 ; CHECK-NEXT: %1 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 0
5774 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 1
5775 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
5776 ; CHECK-NEXT: %4 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 1
5777 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
5778 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
5779 ; CHECK-NEXT: %7 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 2
5780 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 1
5781 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
5782 ; CHECK-NEXT: %10 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 3
5783 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
5784 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
5785 ; CHECK-NEXT: %13 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 4
5786 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 1
5787 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
5788 ; CHECK-NEXT: %16 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 5
5789 ; CHECK-NEXT: %17 = load volatile i8, i8* %16, align 1
5790 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
5791 ; CHECK-NEXT: %19 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 6
5792 ; CHECK-NEXT: %20 = load volatile i8, i8* %19, align 1
5793 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
5794 ; CHECK-NEXT: %22 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 7
5795 ; CHECK-NEXT: %23 = load volatile i8, i8* %22, align 1
5796 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
5797 ; CHECK-NEXT: %25 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 8
5798 ; CHECK-NEXT: %26 = load volatile i8, i8* %25, align 1
5799 ; CHECK-NEXT: %27 = insertelement <16 x i8> %24, i8 %26, i32 8
5800 ; CHECK-NEXT: %28 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 9
5801 ; CHECK-NEXT: %29 = load volatile i8, i8* %28, align 1
5802 ; CHECK-NEXT: %30 = insertelement <16 x i8> %27, i8 %29, i32 9
5803 ; CHECK-NEXT: %31 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 10
5804 ; CHECK-NEXT: %32 = load volatile i8, i8* %31, align 1
5805 ; CHECK-NEXT: %33 = insertelement <16 x i8> %30, i8 %32, i32 10
5806 ; CHECK-NEXT: %34 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 11
5807 ; CHECK-NEXT: %35 = load volatile i8, i8* %34, align 1
5808 ; CHECK-NEXT: %36 = insertelement <16 x i8> %33, i8 %35, i32 11
5809 ; CHECK-NEXT: ret i32 0
5810 ; CHECK-NEXT: }
5811
5812 define i32 @volatile_load_from_12xi16_align_1(<12 x i16>*) {
5813 entry:
5814 %1 = load volatile <12 x i16>, <12 x i16>* %0, align 1
5815 ret i32 0
5816 }
5817 ; CHECK-LABEL: define i32 @volatile_load_from_12xi16_align_1(<12 x i16>*) {
5818 ; CHECK: entry:
5819 ; CHECK-NEXT: %1 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 0
5820 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
5821 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2, align 1
5822 ; CHECK-NEXT: %4 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 8
5823 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 1
5824 ; CHECK-NEXT: %6 = insertelement <8 x i16> undef, i16 %5, i32 0
5825 ; CHECK-NEXT: %7 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 9
5826 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 1
5827 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 1
5828 ; CHECK-NEXT: %10 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 10
5829 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 1
5830 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 2
5831 ; CHECK-NEXT: %13 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 11
5832 ; CHECK-NEXT: %14 = load volatile i16, i16* %13, align 1
5833 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 3
5834 ; CHECK-NEXT: ret i32 0
5835 ; CHECK-NEXT: }
5836
5837 define i32 @volatile_load_from_12xi32_align_1(<12 x i32>*) {
5838 entry:
5839 %1 = load volatile <12 x i32>, <12 x i32>* %0, align 1
5840 ret i32 0
5841 }
5842 ; CHECK-LABEL: define i32 @volatile_load_from_12xi32_align_1(<12 x i32>*) {
5843 ; CHECK: entry:
5844 ; CHECK-NEXT: %1 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 0
5845 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
5846 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 1
5847 ; CHECK-NEXT: %4 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 4
5848 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
5849 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 1
5850 ; CHECK-NEXT: %7 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 8
5851 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
5852 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8, align 1
5853 ; CHECK-NEXT: ret i32 0
5854 ; CHECK-NEXT: }
5855
5856 define i32 @volatile_load_from_12xi64_align_1(<12 x i64>*) {
5857 entry:
5858 %1 = load volatile <12 x i64>, <12 x i64>* %0, align 1
5859 ret i32 0
5860 }
5861 ; CHECK-LABEL: define i32 @volatile_load_from_12xi64_align_1(<12 x i64>*) {
5862 ; CHECK: entry:
5863 ; CHECK-NEXT: %1 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 0
5864 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
5865 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 1
5866 ; CHECK-NEXT: %4 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 2
5867 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
5868 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 1
5869 ; CHECK-NEXT: %7 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 4
5870 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
5871 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 1
5872 ; CHECK-NEXT: %10 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 6
5873 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
5874 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 1
5875 ; CHECK-NEXT: %13 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 8
5876 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
5877 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14, align 1
5878 ; CHECK-NEXT: %16 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 10
5879 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
5880 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17, align 1
5881 ; CHECK-NEXT: ret i32 0
5882 ; CHECK-NEXT: }
5883
5884 define i32 @volatile_load_from_12xi8ptr_align_1(<12 x i8*>*) {
5885 entry:
5886 %1 = load volatile <12 x i8*>, <12 x i8*>* %0, align 1
5887 ret i32 0
5888 }
5889 ; CHECK-LABEL: define i32 @volatile_load_from_12xi8ptr_align_1(<12 x i8*>*) {
5890 ; CHECK: entry:
5891 ; CHECK-NEXT: %1 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 0
5892 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
5893 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 1
5894 ; CHECK-NEXT: %4 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 4
5895 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
5896 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 1
5897 ; CHECK-NEXT: %7 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 8
5898 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
5899 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8, align 1
5900 ; CHECK-NEXT: ret i32 0
5901 ; CHECK-NEXT: }
5902
5903 define i32 @volatile_load_from_12xfloat_align_1(<12 x float>*) {
5904 entry:
5905 %1 = load volatile <12 x float>, <12 x float>* %0, align 1
5906 ret i32 0
5907 }
5908 ; CHECK-LABEL: define i32 @volatile_load_from_12xfloat_align_1(<12 x float>*) {
5909 ; CHECK: entry:
5910 ; CHECK-NEXT: %1 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 0
5911 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
5912 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 1
5913 ; CHECK-NEXT: %4 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 4
5914 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
5915 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 1
5916 ; CHECK-NEXT: %7 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 8
5917 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
5918 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8, align 1
5919 ; CHECK-NEXT: ret i32 0
5920 ; CHECK-NEXT: }
5921
5922 define i32 @volatile_load_from_12xdouble_align_1(<12 x double>*) {
5923 entry:
5924 %1 = load volatile <12 x double>, <12 x double>* %0, align 1
5925 ret i32 0
5926 }
5927 ; CHECK-LABEL: define i32 @volatile_load_from_12xdouble_align_1(<12 x double>*) {
5928 ; CHECK: entry:
5929 ; CHECK-NEXT: %1 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 0
5930 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
5931 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 1
5932 ; CHECK-NEXT: %4 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 2
5933 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
5934 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 1
5935 ; CHECK-NEXT: %7 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 4
5936 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
5937 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 1
5938 ; CHECK-NEXT: %10 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 6
5939 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
5940 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 1
5941 ; CHECK-NEXT: %13 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 8
5942 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
5943 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14, align 1
5944 ; CHECK-NEXT: %16 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 10
5945 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
5946 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17, align 1
5947 ; CHECK-NEXT: ret i32 0
5948 ; CHECK-NEXT: }
5949
5950 define i32 @volatile_load_from_16xi8_align_1(<16 x i8>*) {
5951 entry:
5952 %1 = load volatile <16 x i8>, <16 x i8>* %0, align 1
5953 ret i32 0
5954 }
5955 ; CHECK-LABEL: define i32 @volatile_load_from_16xi8_align_1(<16 x i8>*) {
5956 ; CHECK: entry:
5957 ; CHECK-NEXT: %1 = load volatile <16 x i8>, <16 x i8>* %0, align 1
5958 ; CHECK-NEXT: ret i32 0
5959 ; CHECK-NEXT: }
5960
5961 define i32 @volatile_load_from_16xi16_align_1(<16 x i16>*) {
5962 entry:
5963 %1 = load volatile <16 x i16>, <16 x i16>* %0, align 1
5964 ret i32 0
5965 }
5966 ; CHECK-LABEL: define i32 @volatile_load_from_16xi16_align_1(<16 x i16>*) {
5967 ; CHECK: entry:
5968 ; CHECK-NEXT: %1 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 0
5969 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
5970 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2, align 1
5971 ; CHECK-NEXT: %4 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 8
5972 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
5973 ; CHECK-NEXT: %6 = load volatile <8 x i16>, <8 x i16>* %5, align 1
5974 ; CHECK-NEXT: ret i32 0
5975 ; CHECK-NEXT: }
5976
5977 define i32 @volatile_load_from_16xi32_align_1(<16 x i32>*) {
5978 entry:
5979 %1 = load volatile <16 x i32>, <16 x i32>* %0, align 1
5980 ret i32 0
5981 }
5982 ; CHECK-LABEL: define i32 @volatile_load_from_16xi32_align_1(<16 x i32>*) {
5983 ; CHECK: entry:
5984 ; CHECK-NEXT: %1 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 0
5985 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
5986 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 1
5987 ; CHECK-NEXT: %4 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 4
5988 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
5989 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 1
5990 ; CHECK-NEXT: %7 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 8
5991 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
5992 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8, align 1
5993 ; CHECK-NEXT: %10 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 12
5994 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
5995 ; CHECK-NEXT: %12 = load volatile <4 x i32>, <4 x i32>* %11, align 1
5996 ; CHECK-NEXT: ret i32 0
5997 ; CHECK-NEXT: }
5998
5999 define i32 @volatile_load_from_16xi64_align_1(<16 x i64>*) {
6000 entry:
6001 %1 = load volatile <16 x i64>, <16 x i64>* %0, align 1
6002 ret i32 0
6003 }
6004 ; CHECK-LABEL: define i32 @volatile_load_from_16xi64_align_1(<16 x i64>*) {
6005 ; CHECK: entry:
6006 ; CHECK-NEXT: %1 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 0
6007 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
6008 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 1
6009 ; CHECK-NEXT: %4 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 2
6010 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
6011 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 1
6012 ; CHECK-NEXT: %7 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 4
6013 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
6014 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 1
6015 ; CHECK-NEXT: %10 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 6
6016 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
6017 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 1
6018 ; CHECK-NEXT: %13 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 8
6019 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
6020 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14, align 1
6021 ; CHECK-NEXT: %16 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 10
6022 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
6023 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17, align 1
6024 ; CHECK-NEXT: %19 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 12
6025 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
6026 ; CHECK-NEXT: %21 = load volatile <2 x i64>, <2 x i64>* %20, align 1
6027 ; CHECK-NEXT: %22 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 14
6028 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
6029 ; CHECK-NEXT: %24 = load volatile <2 x i64>, <2 x i64>* %23, align 1
6030 ; CHECK-NEXT: ret i32 0
6031 ; CHECK-NEXT: }
6032
6033 define i32 @volatile_load_from_16xi8ptr_align_1(<16 x i8*>*) {
6034 entry:
6035 %1 = load volatile <16 x i8*>, <16 x i8*>* %0, align 1
6036 ret i32 0
6037 }
6038 ; CHECK-LABEL: define i32 @volatile_load_from_16xi8ptr_align_1(<16 x i8*>*) {
6039 ; CHECK: entry:
6040 ; CHECK-NEXT: %1 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 0
6041 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
6042 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 1
6043 ; CHECK-NEXT: %4 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 4
6044 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
6045 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 1
6046 ; CHECK-NEXT: %7 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 8
6047 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
6048 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8, align 1
6049 ; CHECK-NEXT: %10 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 12
6050 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
6051 ; CHECK-NEXT: %12 = load volatile <4 x i8*>, <4 x i8*>* %11, align 1
6052 ; CHECK-NEXT: ret i32 0
6053 ; CHECK-NEXT: }
6054
6055 define i32 @volatile_load_from_16xfloat_align_1(<16 x float>*) {
6056 entry:
6057 %1 = load volatile <16 x float>, <16 x float>* %0, align 1
6058 ret i32 0
6059 }
6060 ; CHECK-LABEL: define i32 @volatile_load_from_16xfloat_align_1(<16 x float>*) {
6061 ; CHECK: entry:
6062 ; CHECK-NEXT: %1 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 0
6063 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
6064 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 1
6065 ; CHECK-NEXT: %4 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 4
6066 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
6067 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 1
6068 ; CHECK-NEXT: %7 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 8
6069 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
6070 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8, align 1
6071 ; CHECK-NEXT: %10 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 12
6072 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
6073 ; CHECK-NEXT: %12 = load volatile <4 x float>, <4 x float>* %11, align 1
6074 ; CHECK-NEXT: ret i32 0
6075 ; CHECK-NEXT: }
6076
6077 define i32 @volatile_load_from_16xdouble_align_1(<16 x double>*) {
6078 entry:
6079 %1 = load volatile <16 x double>, <16 x double>* %0, align 1
6080 ret i32 0
6081 }
6082 ; CHECK-LABEL: define i32 @volatile_load_from_16xdouble_align_1(<16 x double>*) {
6083 ; CHECK: entry:
6084 ; CHECK-NEXT: %1 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 0
6085 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
6086 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 1
6087 ; CHECK-NEXT: %4 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 2
6088 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
6089 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 1
6090 ; CHECK-NEXT: %7 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 4
6091 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
6092 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 1
6093 ; CHECK-NEXT: %10 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 6
6094 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
6095 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 1
6096 ; CHECK-NEXT: %13 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 8
6097 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
6098 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14, align 1
6099 ; CHECK-NEXT: %16 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 10
6100 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
6101 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17, align 1
6102 ; CHECK-NEXT: %19 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 12
6103 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
6104 ; CHECK-NEXT: %21 = load volatile <2 x double>, <2 x double>* %20, align 1
6105 ; CHECK-NEXT: %22 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 14
6106 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
6107 ; CHECK-NEXT: %24 = load volatile <2 x double>, <2 x double>* %23, align 1
6108 ; CHECK-NEXT: ret i32 0
6109 ; CHECK-NEXT: }
6110
6111 define i32 @volatile_load_from_20xi8_align_1(<20 x i8>*) {
6112 entry:
6113 %1 = load volatile <20 x i8>, <20 x i8>* %0, align 1
6114 ret i32 0
6115 }
6116 ; CHECK-LABEL: define i32 @volatile_load_from_20xi8_align_1(<20 x i8>*) {
6117 ; CHECK: entry:
6118 ; CHECK-NEXT: %1 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 0
6119 ; CHECK-NEXT: %2 = bitcast i8* %1 to <16 x i8>*
6120 ; CHECK-NEXT: %3 = load volatile <16 x i8>, <16 x i8>* %2, align 1
6121 ; CHECK-NEXT: %4 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 16
6122 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
6123 ; CHECK-NEXT: %6 = insertelement <16 x i8> undef, i8 %5, i32 0
6124 ; CHECK-NEXT: %7 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 17
6125 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 1
6126 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 1
6127 ; CHECK-NEXT: %10 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 18
6128 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
6129 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 2
6130 ; CHECK-NEXT: %13 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 19
6131 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 1
6132 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 3
6133 ; CHECK-NEXT: ret i32 0
6134 ; CHECK-NEXT: }
6135
6136 define i32 @volatile_load_from_20xi16_align_1(<20 x i16>*) {
6137 entry:
6138 %1 = load volatile <20 x i16>, <20 x i16>* %0, align 1
6139 ret i32 0
6140 }
6141 ; CHECK-LABEL: define i32 @volatile_load_from_20xi16_align_1(<20 x i16>*) {
6142 ; CHECK: entry:
6143 ; CHECK-NEXT: %1 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 0
6144 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
6145 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2, align 1
6146 ; CHECK-NEXT: %4 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 8
6147 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
6148 ; CHECK-NEXT: %6 = load volatile <8 x i16>, <8 x i16>* %5, align 1
6149 ; CHECK-NEXT: %7 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 16
6150 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 1
6151 ; CHECK-NEXT: %9 = insertelement <8 x i16> undef, i16 %8, i32 0
6152 ; CHECK-NEXT: %10 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 17
6153 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 1
6154 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 1
6155 ; CHECK-NEXT: %13 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 18
6156 ; CHECK-NEXT: %14 = load volatile i16, i16* %13, align 1
6157 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 2
6158 ; CHECK-NEXT: %16 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 19
6159 ; CHECK-NEXT: %17 = load volatile i16, i16* %16, align 1
6160 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 3
6161 ; CHECK-NEXT: ret i32 0
6162 ; CHECK-NEXT: }
6163
6164 define i32 @volatile_load_from_20xi32_align_1(<20 x i32>*) {
6165 entry:
6166 %1 = load volatile <20 x i32>, <20 x i32>* %0, align 1
6167 ret i32 0
6168 }
6169 ; CHECK-LABEL: define i32 @volatile_load_from_20xi32_align_1(<20 x i32>*) {
6170 ; CHECK: entry:
6171 ; CHECK-NEXT: %1 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 0
6172 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
6173 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 1
6174 ; CHECK-NEXT: %4 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 4
6175 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
6176 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 1
6177 ; CHECK-NEXT: %7 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 8
6178 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
6179 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8, align 1
6180 ; CHECK-NEXT: %10 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 12
6181 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
6182 ; CHECK-NEXT: %12 = load volatile <4 x i32>, <4 x i32>* %11, align 1
6183 ; CHECK-NEXT: %13 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 16
6184 ; CHECK-NEXT: %14 = bitcast i32* %13 to <4 x i32>*
6185 ; CHECK-NEXT: %15 = load volatile <4 x i32>, <4 x i32>* %14, align 1
6186 ; CHECK-NEXT: ret i32 0
6187 ; CHECK-NEXT: }
6188
6189 define i32 @volatile_load_from_20xi64_align_1(<20 x i64>*) {
6190 entry:
6191 %1 = load volatile <20 x i64>, <20 x i64>* %0, align 1
6192 ret i32 0
6193 }
6194 ; CHECK-LABEL: define i32 @volatile_load_from_20xi64_align_1(<20 x i64>*) {
6195 ; CHECK: entry:
6196 ; CHECK-NEXT: %1 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 0
6197 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
6198 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 1
6199 ; CHECK-NEXT: %4 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 2
6200 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
6201 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 1
6202 ; CHECK-NEXT: %7 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 4
6203 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
6204 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 1
6205 ; CHECK-NEXT: %10 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 6
6206 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
6207 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 1
6208 ; CHECK-NEXT: %13 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 8
6209 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
6210 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14, align 1
6211 ; CHECK-NEXT: %16 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 10
6212 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
6213 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17, align 1
6214 ; CHECK-NEXT: %19 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 12
6215 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
6216 ; CHECK-NEXT: %21 = load volatile <2 x i64>, <2 x i64>* %20, align 1
6217 ; CHECK-NEXT: %22 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 14
6218 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
6219 ; CHECK-NEXT: %24 = load volatile <2 x i64>, <2 x i64>* %23, align 1
6220 ; CHECK-NEXT: %25 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 16
6221 ; CHECK-NEXT: %26 = bitcast i64* %25 to <2 x i64>*
6222 ; CHECK-NEXT: %27 = load volatile <2 x i64>, <2 x i64>* %26, align 1
6223 ; CHECK-NEXT: %28 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 18
6224 ; CHECK-NEXT: %29 = bitcast i64* %28 to <2 x i64>*
6225 ; CHECK-NEXT: %30 = load volatile <2 x i64>, <2 x i64>* %29, align 1
6226 ; CHECK-NEXT: ret i32 0
6227 ; CHECK-NEXT: }
6228
6229 define i32 @volatile_load_from_20xi8ptr_align_1(<20 x i8*>*) {
6230 entry:
6231 %1 = load volatile <20 x i8*>, <20 x i8*>* %0, align 1
6232 ret i32 0
6233 }
6234 ; CHECK-LABEL: define i32 @volatile_load_from_20xi8ptr_align_1(<20 x i8*>*) {
6235 ; CHECK: entry:
6236 ; CHECK-NEXT: %1 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 0
6237 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
6238 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 1
6239 ; CHECK-NEXT: %4 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 4
6240 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
6241 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 1
6242 ; CHECK-NEXT: %7 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 8
6243 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
6244 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8, align 1
6245 ; CHECK-NEXT: %10 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 12
6246 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
6247 ; CHECK-NEXT: %12 = load volatile <4 x i8*>, <4 x i8*>* %11, align 1
6248 ; CHECK-NEXT: %13 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 16
6249 ; CHECK-NEXT: %14 = bitcast i8** %13 to <4 x i8*>*
6250 ; CHECK-NEXT: %15 = load volatile <4 x i8*>, <4 x i8*>* %14, align 1
6251 ; CHECK-NEXT: ret i32 0
6252 ; CHECK-NEXT: }
6253
6254 define i32 @volatile_load_from_20xfloat_align_1(<20 x float>*) {
6255 entry:
6256 %1 = load volatile <20 x float>, <20 x float>* %0, align 1
6257 ret i32 0
6258 }
6259 ; CHECK-LABEL: define i32 @volatile_load_from_20xfloat_align_1(<20 x float>*) {
6260 ; CHECK: entry:
6261 ; CHECK-NEXT: %1 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 0
6262 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
6263 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 1
6264 ; CHECK-NEXT: %4 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 4
6265 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
6266 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 1
6267 ; CHECK-NEXT: %7 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 8
6268 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
6269 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8, align 1
6270 ; CHECK-NEXT: %10 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 12
6271 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
6272 ; CHECK-NEXT: %12 = load volatile <4 x float>, <4 x float>* %11, align 1
6273 ; CHECK-NEXT: %13 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 16
6274 ; CHECK-NEXT: %14 = bitcast float* %13 to <4 x float>*
6275 ; CHECK-NEXT: %15 = load volatile <4 x float>, <4 x float>* %14, align 1
6276 ; CHECK-NEXT: ret i32 0
6277 ; CHECK-NEXT: }
6278
6279 define i32 @volatile_load_from_20xdouble_align_1(<20 x double>*) {
6280 entry:
6281 %1 = load volatile <20 x double>, <20 x double>* %0, align 1
6282 ret i32 0
6283 }
6284 ; CHECK-LABEL: define i32 @volatile_load_from_20xdouble_align_1(<20 x double>*) {
6285 ; CHECK: entry:
6286 ; CHECK-NEXT: %1 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 0
6287 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
6288 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 1
6289 ; CHECK-NEXT: %4 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 2
6290 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
6291 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 1
6292 ; CHECK-NEXT: %7 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 4
6293 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
6294 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 1
6295 ; CHECK-NEXT: %10 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 6
6296 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
6297 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 1
6298 ; CHECK-NEXT: %13 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 8
6299 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
6300 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14, align 1
6301 ; CHECK-NEXT: %16 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 10
6302 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
6303 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17, align 1
6304 ; CHECK-NEXT: %19 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 12
6305 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
6306 ; CHECK-NEXT: %21 = load volatile <2 x double>, <2 x double>* %20, align 1
6307 ; CHECK-NEXT: %22 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 14
6308 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
6309 ; CHECK-NEXT: %24 = load volatile <2 x double>, <2 x double>* %23, align 1
6310 ; CHECK-NEXT: %25 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 16
6311 ; CHECK-NEXT: %26 = bitcast double* %25 to <2 x double>*
6312 ; CHECK-NEXT: %27 = load volatile <2 x double>, <2 x double>* %26, align 1
6313 ; CHECK-NEXT: %28 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 18
6314 ; CHECK-NEXT: %29 = bitcast double* %28 to <2 x double>*
6315 ; CHECK-NEXT: %30 = load volatile <2 x double>, <2 x double>* %29, align 1
6316 ; CHECK-NEXT: ret i32 0
6317 ; CHECK-NEXT: }
6318
6319 define i32 @volatile_load_from_2xi8_align_8(<2 x i8>*) {
6320 entry:
6321 %1 = load volatile <2 x i8>, <2 x i8>* %0, align 8
6322 ret i32 0
6323 }
6324 ; CHECK-LABEL: define i32 @volatile_load_from_2xi8_align_8(<2 x i8>*) {
6325 ; CHECK: entry:
6326 ; CHECK-NEXT: %1 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 0
6327 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 8
6328 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
6329 ; CHECK-NEXT: %4 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 1
6330 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
6331 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
6332 ; CHECK-NEXT: ret i32 0
6333 ; CHECK-NEXT: }
6334
6335 define i32 @volatile_load_from_2xi16_align_8(<2 x i16>*) {
6336 entry:
6337 %1 = load volatile <2 x i16>, <2 x i16>* %0, align 8
6338 ret i32 0
6339 }
6340 ; CHECK-LABEL: define i32 @volatile_load_from_2xi16_align_8(<2 x i16>*) {
6341 ; CHECK: entry:
6342 ; CHECK-NEXT: %1 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 0
6343 ; CHECK-NEXT: %2 = load volatile i16, i16* %1, align 8
6344 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
6345 ; CHECK-NEXT: %4 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 1
6346 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 2
6347 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
6348 ; CHECK-NEXT: ret i32 0
6349 ; CHECK-NEXT: }
6350
6351 define i32 @volatile_load_from_2xi32_align_8(<2 x i32>*) {
6352 entry:
6353 %1 = load volatile <2 x i32>, <2 x i32>* %0, align 8
6354 ret i32 0
6355 }
6356 ; CHECK-LABEL: define i32 @volatile_load_from_2xi32_align_8(<2 x i32>*) {
6357 ; CHECK: entry:
6358 ; CHECK-NEXT: %1 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 0
6359 ; CHECK-NEXT: %2 = load volatile i32, i32* %1, align 8
6360 ; CHECK-NEXT: %3 = insertelement <4 x i32> undef, i32 %2, i32 0
6361 ; CHECK-NEXT: %4 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 1
6362 ; CHECK-NEXT: %5 = load volatile i32, i32* %4, align 4
6363 ; CHECK-NEXT: %6 = insertelement <4 x i32> %3, i32 %5, i32 1
6364 ; CHECK-NEXT: ret i32 0
6365 ; CHECK-NEXT: }
6366
6367 define i32 @volatile_load_from_2xi64_align_8(<2 x i64>*) {
6368 entry:
6369 %1 = load volatile <2 x i64>, <2 x i64>* %0, align 8
6370 ret i32 0
6371 }
6372 ; CHECK-LABEL: define i32 @volatile_load_from_2xi64_align_8(<2 x i64>*) {
6373 ; CHECK: entry:
6374 ; CHECK-NEXT: %1 = load volatile <2 x i64>, <2 x i64>* %0, align 8
6375 ; CHECK-NEXT: ret i32 0
6376 ; CHECK-NEXT: }
6377
6378 define i32 @volatile_load_from_2xi8ptr_align_8(<2 x i8*>*) {
6379 entry:
6380 %1 = load volatile <2 x i8*>, <2 x i8*>* %0, align 8
6381 ret i32 0
6382 }
6383 ; CHECK-LABEL: define i32 @volatile_load_from_2xi8ptr_align_8(<2 x i8*>*) {
6384 ; CHECK: entry:
6385 ; CHECK-NEXT: %1 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 0
6386 ; CHECK-NEXT: %2 = load volatile i8*, i8** %1, align 8
6387 ; CHECK-NEXT: %3 = insertelement <4 x i8*> undef, i8* %2, i32 0
6388 ; CHECK-NEXT: %4 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 1
6389 ; CHECK-NEXT: %5 = load volatile i8*, i8** %4, align 4
6390 ; CHECK-NEXT: %6 = insertelement <4 x i8*> %3, i8* %5, i32 1
6391 ; CHECK-NEXT: ret i32 0
6392 ; CHECK-NEXT: }
6393
6394 define i32 @volatile_load_from_2xfloat_align_8(<2 x float>*) {
6395 entry:
6396 %1 = load volatile <2 x float>, <2 x float>* %0, align 8
6397 ret i32 0
6398 }
6399 ; CHECK-LABEL: define i32 @volatile_load_from_2xfloat_align_8(<2 x float>*) {
6400 ; CHECK: entry:
6401 ; CHECK-NEXT: %1 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 0
6402 ; CHECK-NEXT: %2 = load volatile float, float* %1, align 8
6403 ; CHECK-NEXT: %3 = insertelement <4 x float> undef, float %2, i32 0
6404 ; CHECK-NEXT: %4 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 1
6405 ; CHECK-NEXT: %5 = load volatile float, float* %4, align 4
6406 ; CHECK-NEXT: %6 = insertelement <4 x float> %3, float %5, i32 1
6407 ; CHECK-NEXT: ret i32 0
6408 ; CHECK-NEXT: }
6409
6410 define i32 @volatile_load_from_2xdouble_align_8(<2 x double>*) {
6411 entry:
6412 %1 = load volatile <2 x double>, <2 x double>* %0, align 8
6413 ret i32 0
6414 }
6415 ; CHECK-LABEL: define i32 @volatile_load_from_2xdouble_align_8(<2 x double>*) {
6416 ; CHECK: entry:
6417 ; CHECK-NEXT: %1 = load volatile <2 x double>, <2 x double>* %0, align 8
6418 ; CHECK-NEXT: ret i32 0
6419 ; CHECK-NEXT: }
6420
6421 define i32 @volatile_load_from_4xi8_align_8(<4 x i8>*) {
6422 entry:
6423 %1 = load volatile <4 x i8>, <4 x i8>* %0, align 8
6424 ret i32 0
6425 }
6426 ; CHECK-LABEL: define i32 @volatile_load_from_4xi8_align_8(<4 x i8>*) {
6427 ; CHECK: entry:
6428 ; CHECK-NEXT: %1 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 0
6429 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 8
6430 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
6431 ; CHECK-NEXT: %4 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 1
6432 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
6433 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
6434 ; CHECK-NEXT: %7 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 2
6435 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 2
6436 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
6437 ; CHECK-NEXT: %10 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 3
6438 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
6439 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
6440 ; CHECK-NEXT: ret i32 0
6441 ; CHECK-NEXT: }
6442
6443 define i32 @volatile_load_from_4xi16_align_8(<4 x i16>*) {
6444 entry:
6445 %1 = load volatile <4 x i16>, <4 x i16>* %0, align 8
6446 ret i32 0
6447 }
6448 ; CHECK-LABEL: define i32 @volatile_load_from_4xi16_align_8(<4 x i16>*) {
6449 ; CHECK: entry:
6450 ; CHECK-NEXT: %1 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 0
6451 ; CHECK-NEXT: %2 = load volatile i16, i16* %1, align 8
6452 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
6453 ; CHECK-NEXT: %4 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 1
6454 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 2
6455 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
6456 ; CHECK-NEXT: %7 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 2
6457 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 4
6458 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
6459 ; CHECK-NEXT: %10 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 3
6460 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 2
6461 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
6462 ; CHECK-NEXT: ret i32 0
6463 ; CHECK-NEXT: }
6464
6465 define i32 @volatile_load_from_4xi32_align_8(<4 x i32>*) {
6466 entry:
6467 %1 = load volatile <4 x i32>, <4 x i32>* %0, align 8
6468 ret i32 0
6469 }
6470 ; CHECK-LABEL: define i32 @volatile_load_from_4xi32_align_8(<4 x i32>*) {
6471 ; CHECK: entry:
6472 ; CHECK-NEXT: %1 = load volatile <4 x i32>, <4 x i32>* %0, align 8
6473 ; CHECK-NEXT: ret i32 0
6474 ; CHECK-NEXT: }
6475
6476 define i32 @volatile_load_from_4xi64_align_8(<4 x i64>*) {
6477 entry:
6478 %1 = load volatile <4 x i64>, <4 x i64>* %0, align 8
6479 ret i32 0
6480 }
6481 ; CHECK-LABEL: define i32 @volatile_load_from_4xi64_align_8(<4 x i64>*) {
6482 ; CHECK: entry:
6483 ; CHECK-NEXT: %1 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 0
6484 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
6485 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 8
6486 ; CHECK-NEXT: %4 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 2
6487 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
6488 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 8
6489 ; CHECK-NEXT: ret i32 0
6490 ; CHECK-NEXT: }
6491
6492 define i32 @volatile_load_from_4xi8ptr_align_8(<4 x i8*>*) {
6493 entry:
6494 %1 = load volatile <4 x i8*>, <4 x i8*>* %0, align 8
6495 ret i32 0
6496 }
6497 ; CHECK-LABEL: define i32 @volatile_load_from_4xi8ptr_align_8(<4 x i8*>*) {
6498 ; CHECK: entry:
6499 ; CHECK-NEXT: %1 = load volatile <4 x i8*>, <4 x i8*>* %0, align 8
6500 ; CHECK-NEXT: ret i32 0
6501 ; CHECK-NEXT: }
6502
6503 define i32 @volatile_load_from_4xfloat_align_8(<4 x float>*) {
6504 entry:
6505 %1 = load volatile <4 x float>, <4 x float>* %0, align 8
6506 ret i32 0
6507 }
6508 ; CHECK-LABEL: define i32 @volatile_load_from_4xfloat_align_8(<4 x float>*) {
6509 ; CHECK: entry:
6510 ; CHECK-NEXT: %1 = load volatile <4 x float>, <4 x float>* %0, align 8
6511 ; CHECK-NEXT: ret i32 0
6512 ; CHECK-NEXT: }
6513
6514 define i32 @volatile_load_from_4xdouble_align_8(<4 x double>*) {
6515 entry:
6516 %1 = load volatile <4 x double>, <4 x double>* %0, align 8
6517 ret i32 0
6518 }
6519 ; CHECK-LABEL: define i32 @volatile_load_from_4xdouble_align_8(<4 x double>*) {
6520 ; CHECK: entry:
6521 ; CHECK-NEXT: %1 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 0
6522 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
6523 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 8
6524 ; CHECK-NEXT: %4 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 2
6525 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
6526 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 8
6527 ; CHECK-NEXT: ret i32 0
6528 ; CHECK-NEXT: }
6529
6530 define i32 @volatile_load_from_6xi8_align_8(<6 x i8>*) {
6531 entry:
6532 %1 = load volatile <6 x i8>, <6 x i8>* %0, align 8
6533 ret i32 0
6534 }
6535 ; CHECK-LABEL: define i32 @volatile_load_from_6xi8_align_8(<6 x i8>*) {
6536 ; CHECK: entry:
6537 ; CHECK-NEXT: %1 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 0
6538 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 8
6539 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
6540 ; CHECK-NEXT: %4 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 1
6541 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
6542 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
6543 ; CHECK-NEXT: %7 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 2
6544 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 2
6545 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
6546 ; CHECK-NEXT: %10 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 3
6547 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
6548 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
6549 ; CHECK-NEXT: %13 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 4
6550 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 4
6551 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
6552 ; CHECK-NEXT: %16 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 5
6553 ; CHECK-NEXT: %17 = load volatile i8, i8* %16, align 1
6554 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
6555 ; CHECK-NEXT: ret i32 0
6556 ; CHECK-NEXT: }
6557
6558 define i32 @volatile_load_from_6xi16_align_8(<6 x i16>*) {
6559 entry:
6560 %1 = load volatile <6 x i16>, <6 x i16>* %0, align 8
6561 ret i32 0
6562 }
6563 ; CHECK-LABEL: define i32 @volatile_load_from_6xi16_align_8(<6 x i16>*) {
6564 ; CHECK: entry:
6565 ; CHECK-NEXT: %1 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 0
6566 ; CHECK-NEXT: %2 = load volatile i16, i16* %1, align 8
6567 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
6568 ; CHECK-NEXT: %4 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 1
6569 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 2
6570 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
6571 ; CHECK-NEXT: %7 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 2
6572 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 4
6573 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
6574 ; CHECK-NEXT: %10 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 3
6575 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 2
6576 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
6577 ; CHECK-NEXT: %13 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 4
6578 ; CHECK-NEXT: %14 = load volatile i16, i16* %13, align 8
6579 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 4
6580 ; CHECK-NEXT: %16 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 5
6581 ; CHECK-NEXT: %17 = load volatile i16, i16* %16, align 2
6582 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 5
6583 ; CHECK-NEXT: ret i32 0
6584 ; CHECK-NEXT: }
6585
6586 define i32 @volatile_load_from_6xi32_align_8(<6 x i32>*) {
6587 entry:
6588 %1 = load volatile <6 x i32>, <6 x i32>* %0, align 8
6589 ret i32 0
6590 }
6591 ; CHECK-LABEL: define i32 @volatile_load_from_6xi32_align_8(<6 x i32>*) {
6592 ; CHECK: entry:
6593 ; CHECK-NEXT: %1 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 0
6594 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
6595 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 8
6596 ; CHECK-NEXT: %4 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 4
6597 ; CHECK-NEXT: %5 = load volatile i32, i32* %4, align 8
6598 ; CHECK-NEXT: %6 = insertelement <4 x i32> undef, i32 %5, i32 0
6599 ; CHECK-NEXT: %7 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 5
6600 ; CHECK-NEXT: %8 = load volatile i32, i32* %7, align 4
6601 ; CHECK-NEXT: %9 = insertelement <4 x i32> %6, i32 %8, i32 1
6602 ; CHECK-NEXT: ret i32 0
6603 ; CHECK-NEXT: }
6604
6605 define i32 @volatile_load_from_6xi64_align_8(<6 x i64>*) {
6606 entry:
6607 %1 = load volatile <6 x i64>, <6 x i64>* %0, align 8
6608 ret i32 0
6609 }
6610 ; CHECK-LABEL: define i32 @volatile_load_from_6xi64_align_8(<6 x i64>*) {
6611 ; CHECK: entry:
6612 ; CHECK-NEXT: %1 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 0
6613 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
6614 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 8
6615 ; CHECK-NEXT: %4 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 2
6616 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
6617 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 8
6618 ; CHECK-NEXT: %7 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 4
6619 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
6620 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 8
6621 ; CHECK-NEXT: ret i32 0
6622 ; CHECK-NEXT: }
6623
6624 define i32 @volatile_load_from_6xi8ptr_align_8(<6 x i8*>*) {
6625 entry:
6626 %1 = load volatile <6 x i8*>, <6 x i8*>* %0, align 8
6627 ret i32 0
6628 }
6629 ; CHECK-LABEL: define i32 @volatile_load_from_6xi8ptr_align_8(<6 x i8*>*) {
6630 ; CHECK: entry:
6631 ; CHECK-NEXT: %1 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 0
6632 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
6633 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 8
6634 ; CHECK-NEXT: %4 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 4
6635 ; CHECK-NEXT: %5 = load volatile i8*, i8** %4, align 8
6636 ; CHECK-NEXT: %6 = insertelement <4 x i8*> undef, i8* %5, i32 0
6637 ; CHECK-NEXT: %7 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 5
6638 ; CHECK-NEXT: %8 = load volatile i8*, i8** %7, align 4
6639 ; CHECK-NEXT: %9 = insertelement <4 x i8*> %6, i8* %8, i32 1
6640 ; CHECK-NEXT: ret i32 0
6641 ; CHECK-NEXT: }
6642
6643 define i32 @volatile_load_from_6xfloat_align_8(<6 x float>*) {
6644 entry:
6645 %1 = load volatile <6 x float>, <6 x float>* %0, align 8
6646 ret i32 0
6647 }
6648 ; CHECK-LABEL: define i32 @volatile_load_from_6xfloat_align_8(<6 x float>*) {
6649 ; CHECK: entry:
6650 ; CHECK-NEXT: %1 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 0
6651 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
6652 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 8
6653 ; CHECK-NEXT: %4 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 4
6654 ; CHECK-NEXT: %5 = load volatile float, float* %4, align 8
6655 ; CHECK-NEXT: %6 = insertelement <4 x float> undef, float %5, i32 0
6656 ; CHECK-NEXT: %7 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 5
6657 ; CHECK-NEXT: %8 = load volatile float, float* %7, align 4
6658 ; CHECK-NEXT: %9 = insertelement <4 x float> %6, float %8, i32 1
6659 ; CHECK-NEXT: ret i32 0
6660 ; CHECK-NEXT: }
6661
6662 define i32 @volatile_load_from_6xdouble_align_8(<6 x double>*) {
6663 entry:
6664 %1 = load volatile <6 x double>, <6 x double>* %0, align 8
6665 ret i32 0
6666 }
6667 ; CHECK-LABEL: define i32 @volatile_load_from_6xdouble_align_8(<6 x double>*) {
6668 ; CHECK: entry:
6669 ; CHECK-NEXT: %1 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 0
6670 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
6671 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 8
6672 ; CHECK-NEXT: %4 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 2
6673 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
6674 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 8
6675 ; CHECK-NEXT: %7 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 4
6676 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
6677 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 8
6678 ; CHECK-NEXT: ret i32 0
6679 ; CHECK-NEXT: }
6680
6681 define i32 @volatile_load_from_8xi8_align_8(<8 x i8>*) {
6682 entry:
6683 %1 = load volatile <8 x i8>, <8 x i8>* %0, align 8
6684 ret i32 0
6685 }
6686 ; CHECK-LABEL: define i32 @volatile_load_from_8xi8_align_8(<8 x i8>*) {
6687 ; CHECK: entry:
6688 ; CHECK-NEXT: %1 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 0
6689 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 8
6690 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
6691 ; CHECK-NEXT: %4 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 1
6692 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
6693 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
6694 ; CHECK-NEXT: %7 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 2
6695 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 2
6696 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
6697 ; CHECK-NEXT: %10 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 3
6698 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
6699 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
6700 ; CHECK-NEXT: %13 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 4
6701 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 4
6702 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
6703 ; CHECK-NEXT: %16 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 5
6704 ; CHECK-NEXT: %17 = load volatile i8, i8* %16, align 1
6705 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
6706 ; CHECK-NEXT: %19 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 6
6707 ; CHECK-NEXT: %20 = load volatile i8, i8* %19, align 2
6708 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
6709 ; CHECK-NEXT: %22 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 7
6710 ; CHECK-NEXT: %23 = load volatile i8, i8* %22, align 1
6711 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
6712 ; CHECK-NEXT: ret i32 0
6713 ; CHECK-NEXT: }
6714
6715 define i32 @volatile_load_from_8xi16_align_8(<8 x i16>*) {
6716 entry:
6717 %1 = load volatile <8 x i16>, <8 x i16>* %0, align 8
6718 ret i32 0
6719 }
6720 ; CHECK-LABEL: define i32 @volatile_load_from_8xi16_align_8(<8 x i16>*) {
6721 ; CHECK: entry:
6722 ; CHECK-NEXT: %1 = load volatile <8 x i16>, <8 x i16>* %0, align 8
6723 ; CHECK-NEXT: ret i32 0
6724 ; CHECK-NEXT: }
6725
6726 define i32 @volatile_load_from_8xi32_align_8(<8 x i32>*) {
6727 entry:
6728 %1 = load volatile <8 x i32>, <8 x i32>* %0, align 8
6729 ret i32 0
6730 }
6731 ; CHECK-LABEL: define i32 @volatile_load_from_8xi32_align_8(<8 x i32>*) {
6732 ; CHECK: entry:
6733 ; CHECK-NEXT: %1 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 0
6734 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
6735 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 8
6736 ; CHECK-NEXT: %4 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 4
6737 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
6738 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 8
6739 ; CHECK-NEXT: ret i32 0
6740 ; CHECK-NEXT: }
6741
6742 define i32 @volatile_load_from_8xi64_align_8(<8 x i64>*) {
6743 entry:
6744 %1 = load volatile <8 x i64>, <8 x i64>* %0, align 8
6745 ret i32 0
6746 }
6747 ; CHECK-LABEL: define i32 @volatile_load_from_8xi64_align_8(<8 x i64>*) {
6748 ; CHECK: entry:
6749 ; CHECK-NEXT: %1 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 0
6750 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
6751 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 8
6752 ; CHECK-NEXT: %4 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 2
6753 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
6754 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 8
6755 ; CHECK-NEXT: %7 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 4
6756 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
6757 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 8
6758 ; CHECK-NEXT: %10 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 6
6759 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
6760 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 8
6761 ; CHECK-NEXT: ret i32 0
6762 ; CHECK-NEXT: }
6763
6764 define i32 @volatile_load_from_8xi8ptr_align_8(<8 x i8*>*) {
6765 entry:
6766 %1 = load volatile <8 x i8*>, <8 x i8*>* %0, align 8
6767 ret i32 0
6768 }
6769 ; CHECK-LABEL: define i32 @volatile_load_from_8xi8ptr_align_8(<8 x i8*>*) {
6770 ; CHECK: entry:
6771 ; CHECK-NEXT: %1 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 0
6772 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
6773 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 8
6774 ; CHECK-NEXT: %4 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 4
6775 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
6776 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 8
6777 ; CHECK-NEXT: ret i32 0
6778 ; CHECK-NEXT: }
6779
6780 define i32 @volatile_load_from_8xfloat_align_8(<8 x float>*) {
6781 entry:
6782 %1 = load volatile <8 x float>, <8 x float>* %0, align 8
6783 ret i32 0
6784 }
6785 ; CHECK-LABEL: define i32 @volatile_load_from_8xfloat_align_8(<8 x float>*) {
6786 ; CHECK: entry:
6787 ; CHECK-NEXT: %1 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 0
6788 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
6789 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 8
6790 ; CHECK-NEXT: %4 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 4
6791 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
6792 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 8
6793 ; CHECK-NEXT: ret i32 0
6794 ; CHECK-NEXT: }
6795
6796 define i32 @volatile_load_from_8xdouble_align_8(<8 x double>*) {
6797 entry:
6798 %1 = load volatile <8 x double>, <8 x double>* %0, align 8
6799 ret i32 0
6800 }
6801 ; CHECK-LABEL: define i32 @volatile_load_from_8xdouble_align_8(<8 x double>*) {
6802 ; CHECK: entry:
6803 ; CHECK-NEXT: %1 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 0
6804 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
6805 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 8
6806 ; CHECK-NEXT: %4 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 2
6807 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
6808 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 8
6809 ; CHECK-NEXT: %7 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 4
6810 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
6811 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 8
6812 ; CHECK-NEXT: %10 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 6
6813 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
6814 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 8
6815 ; CHECK-NEXT: ret i32 0
6816 ; CHECK-NEXT: }
6817
6818 define i32 @volatile_load_from_12xi8_align_8(<12 x i8>*) {
6819 entry:
6820 %1 = load volatile <12 x i8>, <12 x i8>* %0, align 8
6821 ret i32 0
6822 }
6823 ; CHECK-LABEL: define i32 @volatile_load_from_12xi8_align_8(<12 x i8>*) {
6824 ; CHECK: entry:
6825 ; CHECK-NEXT: %1 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 0
6826 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 8
6827 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
6828 ; CHECK-NEXT: %4 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 1
6829 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
6830 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
6831 ; CHECK-NEXT: %7 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 2
6832 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 2
6833 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
6834 ; CHECK-NEXT: %10 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 3
6835 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
6836 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
6837 ; CHECK-NEXT: %13 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 4
6838 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 4
6839 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
6840 ; CHECK-NEXT: %16 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 5
6841 ; CHECK-NEXT: %17 = load volatile i8, i8* %16, align 1
6842 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
6843 ; CHECK-NEXT: %19 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 6
6844 ; CHECK-NEXT: %20 = load volatile i8, i8* %19, align 2
6845 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
6846 ; CHECK-NEXT: %22 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 7
6847 ; CHECK-NEXT: %23 = load volatile i8, i8* %22, align 1
6848 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
6849 ; CHECK-NEXT: %25 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 8
6850 ; CHECK-NEXT: %26 = load volatile i8, i8* %25, align 8
6851 ; CHECK-NEXT: %27 = insertelement <16 x i8> %24, i8 %26, i32 8
6852 ; CHECK-NEXT: %28 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 9
6853 ; CHECK-NEXT: %29 = load volatile i8, i8* %28, align 1
6854 ; CHECK-NEXT: %30 = insertelement <16 x i8> %27, i8 %29, i32 9
6855 ; CHECK-NEXT: %31 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 10
6856 ; CHECK-NEXT: %32 = load volatile i8, i8* %31, align 2
6857 ; CHECK-NEXT: %33 = insertelement <16 x i8> %30, i8 %32, i32 10
6858 ; CHECK-NEXT: %34 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 11
6859 ; CHECK-NEXT: %35 = load volatile i8, i8* %34, align 1
6860 ; CHECK-NEXT: %36 = insertelement <16 x i8> %33, i8 %35, i32 11
6861 ; CHECK-NEXT: ret i32 0
6862 ; CHECK-NEXT: }
6863
6864 define i32 @volatile_load_from_12xi16_align_8(<12 x i16>*) {
6865 entry:
6866 %1 = load volatile <12 x i16>, <12 x i16>* %0, align 8
6867 ret i32 0
6868 }
6869 ; CHECK-LABEL: define i32 @volatile_load_from_12xi16_align_8(<12 x i16>*) {
6870 ; CHECK: entry:
6871 ; CHECK-NEXT: %1 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 0
6872 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
6873 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2, align 8
6874 ; CHECK-NEXT: %4 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 8
6875 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 8
6876 ; CHECK-NEXT: %6 = insertelement <8 x i16> undef, i16 %5, i32 0
6877 ; CHECK-NEXT: %7 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 9
6878 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 2
6879 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 1
6880 ; CHECK-NEXT: %10 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 10
6881 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 4
6882 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 2
6883 ; CHECK-NEXT: %13 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 11
6884 ; CHECK-NEXT: %14 = load volatile i16, i16* %13, align 2
6885 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 3
6886 ; CHECK-NEXT: ret i32 0
6887 ; CHECK-NEXT: }
6888
6889 define i32 @volatile_load_from_12xi32_align_8(<12 x i32>*) {
6890 entry:
6891 %1 = load volatile <12 x i32>, <12 x i32>* %0, align 8
6892 ret i32 0
6893 }
6894 ; CHECK-LABEL: define i32 @volatile_load_from_12xi32_align_8(<12 x i32>*) {
6895 ; CHECK: entry:
6896 ; CHECK-NEXT: %1 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 0
6897 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
6898 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 8
6899 ; CHECK-NEXT: %4 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 4
6900 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
6901 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 8
6902 ; CHECK-NEXT: %7 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 8
6903 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
6904 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8, align 8
6905 ; CHECK-NEXT: ret i32 0
6906 ; CHECK-NEXT: }
6907
6908 define i32 @volatile_load_from_12xi64_align_8(<12 x i64>*) {
6909 entry:
6910 %1 = load volatile <12 x i64>, <12 x i64>* %0, align 8
6911 ret i32 0
6912 }
6913 ; CHECK-LABEL: define i32 @volatile_load_from_12xi64_align_8(<12 x i64>*) {
6914 ; CHECK: entry:
6915 ; CHECK-NEXT: %1 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 0
6916 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
6917 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 8
6918 ; CHECK-NEXT: %4 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 2
6919 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
6920 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 8
6921 ; CHECK-NEXT: %7 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 4
6922 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
6923 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 8
6924 ; CHECK-NEXT: %10 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 6
6925 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
6926 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 8
6927 ; CHECK-NEXT: %13 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 8
6928 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
6929 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14, align 8
6930 ; CHECK-NEXT: %16 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 10
6931 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
6932 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17, align 8
6933 ; CHECK-NEXT: ret i32 0
6934 ; CHECK-NEXT: }
6935
6936 define i32 @volatile_load_from_12xi8ptr_align_8(<12 x i8*>*) {
6937 entry:
6938 %1 = load volatile <12 x i8*>, <12 x i8*>* %0, align 8
6939 ret i32 0
6940 }
6941 ; CHECK-LABEL: define i32 @volatile_load_from_12xi8ptr_align_8(<12 x i8*>*) {
6942 ; CHECK: entry:
6943 ; CHECK-NEXT: %1 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 0
6944 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
6945 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 8
6946 ; CHECK-NEXT: %4 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 4
6947 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
6948 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 8
6949 ; CHECK-NEXT: %7 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 8
6950 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
6951 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8, align 8
6952 ; CHECK-NEXT: ret i32 0
6953 ; CHECK-NEXT: }
6954
6955 define i32 @volatile_load_from_12xfloat_align_8(<12 x float>*) {
6956 entry:
6957 %1 = load volatile <12 x float>, <12 x float>* %0, align 8
6958 ret i32 0
6959 }
6960 ; CHECK-LABEL: define i32 @volatile_load_from_12xfloat_align_8(<12 x float>*) {
6961 ; CHECK: entry:
6962 ; CHECK-NEXT: %1 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 0
6963 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
6964 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 8
6965 ; CHECK-NEXT: %4 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 4
6966 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
6967 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 8
6968 ; CHECK-NEXT: %7 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 8
6969 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
6970 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8, align 8
6971 ; CHECK-NEXT: ret i32 0
6972 ; CHECK-NEXT: }
6973
6974 define i32 @volatile_load_from_12xdouble_align_8(<12 x double>*) {
6975 entry:
6976 %1 = load volatile <12 x double>, <12 x double>* %0, align 8
6977 ret i32 0
6978 }
6979 ; CHECK-LABEL: define i32 @volatile_load_from_12xdouble_align_8(<12 x double>*) {
6980 ; CHECK: entry:
6981 ; CHECK-NEXT: %1 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 0
6982 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
6983 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 8
6984 ; CHECK-NEXT: %4 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 2
6985 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
6986 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 8
6987 ; CHECK-NEXT: %7 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 4
6988 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
6989 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 8
6990 ; CHECK-NEXT: %10 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 6
6991 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
6992 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 8
6993 ; CHECK-NEXT: %13 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 8
6994 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
6995 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14, align 8
6996 ; CHECK-NEXT: %16 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 10
6997 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
6998 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17, align 8
6999 ; CHECK-NEXT: ret i32 0
7000 ; CHECK-NEXT: }
7001
7002 define i32 @volatile_load_from_16xi8_align_8(<16 x i8>*) {
7003 entry:
7004 %1 = load volatile <16 x i8>, <16 x i8>* %0, align 8
7005 ret i32 0
7006 }
7007 ; CHECK-LABEL: define i32 @volatile_load_from_16xi8_align_8(<16 x i8>*) {
7008 ; CHECK: entry:
7009 ; CHECK-NEXT: %1 = load volatile <16 x i8>, <16 x i8>* %0, align 8
7010 ; CHECK-NEXT: ret i32 0
7011 ; CHECK-NEXT: }
7012
7013 define i32 @volatile_load_from_16xi16_align_8(<16 x i16>*) {
7014 entry:
7015 %1 = load volatile <16 x i16>, <16 x i16>* %0, align 8
7016 ret i32 0
7017 }
7018 ; CHECK-LABEL: define i32 @volatile_load_from_16xi16_align_8(<16 x i16>*) {
7019 ; CHECK: entry:
7020 ; CHECK-NEXT: %1 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 0
7021 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
7022 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2, align 8
7023 ; CHECK-NEXT: %4 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 8
7024 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
7025 ; CHECK-NEXT: %6 = load volatile <8 x i16>, <8 x i16>* %5, align 8
7026 ; CHECK-NEXT: ret i32 0
7027 ; CHECK-NEXT: }
7028
7029 define i32 @volatile_load_from_16xi32_align_8(<16 x i32>*) {
7030 entry:
7031 %1 = load volatile <16 x i32>, <16 x i32>* %0, align 8
7032 ret i32 0
7033 }
7034 ; CHECK-LABEL: define i32 @volatile_load_from_16xi32_align_8(<16 x i32>*) {
7035 ; CHECK: entry:
7036 ; CHECK-NEXT: %1 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 0
7037 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
7038 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 8
7039 ; CHECK-NEXT: %4 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 4
7040 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
7041 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 8
7042 ; CHECK-NEXT: %7 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 8
7043 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
7044 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8, align 8
7045 ; CHECK-NEXT: %10 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 12
7046 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
7047 ; CHECK-NEXT: %12 = load volatile <4 x i32>, <4 x i32>* %11, align 8
7048 ; CHECK-NEXT: ret i32 0
7049 ; CHECK-NEXT: }
7050
7051 define i32 @volatile_load_from_16xi64_align_8(<16 x i64>*) {
7052 entry:
7053 %1 = load volatile <16 x i64>, <16 x i64>* %0, align 8
7054 ret i32 0
7055 }
7056 ; CHECK-LABEL: define i32 @volatile_load_from_16xi64_align_8(<16 x i64>*) {
7057 ; CHECK: entry:
7058 ; CHECK-NEXT: %1 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 0
7059 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
7060 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 8
7061 ; CHECK-NEXT: %4 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 2
7062 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
7063 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 8
7064 ; CHECK-NEXT: %7 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 4
7065 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
7066 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 8
7067 ; CHECK-NEXT: %10 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 6
7068 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
7069 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 8
7070 ; CHECK-NEXT: %13 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 8
7071 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
7072 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14, align 8
7073 ; CHECK-NEXT: %16 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 10
7074 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
7075 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17, align 8
7076 ; CHECK-NEXT: %19 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 12
7077 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
7078 ; CHECK-NEXT: %21 = load volatile <2 x i64>, <2 x i64>* %20, align 8
7079 ; CHECK-NEXT: %22 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 14
7080 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
7081 ; CHECK-NEXT: %24 = load volatile <2 x i64>, <2 x i64>* %23, align 8
7082 ; CHECK-NEXT: ret i32 0
7083 ; CHECK-NEXT: }
7084
7085 define i32 @volatile_load_from_16xi8ptr_align_8(<16 x i8*>*) {
7086 entry:
7087 %1 = load volatile <16 x i8*>, <16 x i8*>* %0, align 8
7088 ret i32 0
7089 }
7090 ; CHECK-LABEL: define i32 @volatile_load_from_16xi8ptr_align_8(<16 x i8*>*) {
7091 ; CHECK: entry:
7092 ; CHECK-NEXT: %1 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 0
7093 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
7094 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 8
7095 ; CHECK-NEXT: %4 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 4
7096 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
7097 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 8
7098 ; CHECK-NEXT: %7 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 8
7099 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
7100 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8, align 8
7101 ; CHECK-NEXT: %10 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 12
7102 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
7103 ; CHECK-NEXT: %12 = load volatile <4 x i8*>, <4 x i8*>* %11, align 8
7104 ; CHECK-NEXT: ret i32 0
7105 ; CHECK-NEXT: }
7106
7107 define i32 @volatile_load_from_16xfloat_align_8(<16 x float>*) {
7108 entry:
7109 %1 = load volatile <16 x float>, <16 x float>* %0, align 8
7110 ret i32 0
7111 }
7112 ; CHECK-LABEL: define i32 @volatile_load_from_16xfloat_align_8(<16 x float>*) {
7113 ; CHECK: entry:
7114 ; CHECK-NEXT: %1 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 0
7115 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
7116 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 8
7117 ; CHECK-NEXT: %4 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 4
7118 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
7119 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 8
7120 ; CHECK-NEXT: %7 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 8
7121 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
7122 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8, align 8
7123 ; CHECK-NEXT: %10 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 12
7124 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
7125 ; CHECK-NEXT: %12 = load volatile <4 x float>, <4 x float>* %11, align 8
7126 ; CHECK-NEXT: ret i32 0
7127 ; CHECK-NEXT: }
7128
7129 define i32 @volatile_load_from_16xdouble_align_8(<16 x double>*) {
7130 entry:
7131 %1 = load volatile <16 x double>, <16 x double>* %0, align 8
7132 ret i32 0
7133 }
7134 ; CHECK-LABEL: define i32 @volatile_load_from_16xdouble_align_8(<16 x double>*) {
7135 ; CHECK: entry:
7136 ; CHECK-NEXT: %1 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 0
7137 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
7138 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 8
7139 ; CHECK-NEXT: %4 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 2
7140 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
7141 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 8
7142 ; CHECK-NEXT: %7 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 4
7143 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
7144 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 8
7145 ; CHECK-NEXT: %10 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 6
7146 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
7147 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 8
7148 ; CHECK-NEXT: %13 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 8
7149 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
7150 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14, align 8
7151 ; CHECK-NEXT: %16 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 10
7152 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
7153 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17, align 8
7154 ; CHECK-NEXT: %19 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 12
7155 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
7156 ; CHECK-NEXT: %21 = load volatile <2 x double>, <2 x double>* %20, align 8
7157 ; CHECK-NEXT: %22 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 14
7158 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
7159 ; CHECK-NEXT: %24 = load volatile <2 x double>, <2 x double>* %23, align 8
7160 ; CHECK-NEXT: ret i32 0
7161 ; CHECK-NEXT: }
7162
7163 define i32 @volatile_load_from_20xi8_align_8(<20 x i8>*) {
7164 entry:
7165 %1 = load volatile <20 x i8>, <20 x i8>* %0, align 8
7166 ret i32 0
7167 }
7168 ; CHECK-LABEL: define i32 @volatile_load_from_20xi8_align_8(<20 x i8>*) {
7169 ; CHECK: entry:
7170 ; CHECK-NEXT: %1 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 0
7171 ; CHECK-NEXT: %2 = bitcast i8* %1 to <16 x i8>*
7172 ; CHECK-NEXT: %3 = load volatile <16 x i8>, <16 x i8>* %2, align 8
7173 ; CHECK-NEXT: %4 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 16
7174 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 8
7175 ; CHECK-NEXT: %6 = insertelement <16 x i8> undef, i8 %5, i32 0
7176 ; CHECK-NEXT: %7 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 17
7177 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 1
7178 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 1
7179 ; CHECK-NEXT: %10 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 18
7180 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 2
7181 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 2
7182 ; CHECK-NEXT: %13 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 19
7183 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 1
7184 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 3
7185 ; CHECK-NEXT: ret i32 0
7186 ; CHECK-NEXT: }
7187
7188 define i32 @volatile_load_from_20xi16_align_8(<20 x i16>*) {
7189 entry:
7190 %1 = load volatile <20 x i16>, <20 x i16>* %0, align 8
7191 ret i32 0
7192 }
7193 ; CHECK-LABEL: define i32 @volatile_load_from_20xi16_align_8(<20 x i16>*) {
7194 ; CHECK: entry:
7195 ; CHECK-NEXT: %1 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 0
7196 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
7197 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2, align 8
7198 ; CHECK-NEXT: %4 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 8
7199 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
7200 ; CHECK-NEXT: %6 = load volatile <8 x i16>, <8 x i16>* %5, align 8
7201 ; CHECK-NEXT: %7 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 16
7202 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 8
7203 ; CHECK-NEXT: %9 = insertelement <8 x i16> undef, i16 %8, i32 0
7204 ; CHECK-NEXT: %10 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 17
7205 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 2
7206 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 1
7207 ; CHECK-NEXT: %13 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 18
7208 ; CHECK-NEXT: %14 = load volatile i16, i16* %13, align 4
7209 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 2
7210 ; CHECK-NEXT: %16 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 19
7211 ; CHECK-NEXT: %17 = load volatile i16, i16* %16, align 2
7212 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 3
7213 ; CHECK-NEXT: ret i32 0
7214 ; CHECK-NEXT: }
7215
7216 define i32 @volatile_load_from_20xi32_align_8(<20 x i32>*) {
7217 entry:
7218 %1 = load volatile <20 x i32>, <20 x i32>* %0, align 8
7219 ret i32 0
7220 }
7221 ; CHECK-LABEL: define i32 @volatile_load_from_20xi32_align_8(<20 x i32>*) {
7222 ; CHECK: entry:
7223 ; CHECK-NEXT: %1 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 0
7224 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
7225 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 8
7226 ; CHECK-NEXT: %4 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 4
7227 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
7228 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 8
7229 ; CHECK-NEXT: %7 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 8
7230 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
7231 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8, align 8
7232 ; CHECK-NEXT: %10 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 12
7233 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
7234 ; CHECK-NEXT: %12 = load volatile <4 x i32>, <4 x i32>* %11, align 8
7235 ; CHECK-NEXT: %13 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 16
7236 ; CHECK-NEXT: %14 = bitcast i32* %13 to <4 x i32>*
7237 ; CHECK-NEXT: %15 = load volatile <4 x i32>, <4 x i32>* %14, align 8
7238 ; CHECK-NEXT: ret i32 0
7239 ; CHECK-NEXT: }
7240
7241 define i32 @volatile_load_from_20xi64_align_8(<20 x i64>*) {
7242 entry:
7243 %1 = load volatile <20 x i64>, <20 x i64>* %0, align 8
7244 ret i32 0
7245 }
7246 ; CHECK-LABEL: define i32 @volatile_load_from_20xi64_align_8(<20 x i64>*) {
7247 ; CHECK: entry:
7248 ; CHECK-NEXT: %1 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 0
7249 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
7250 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 8
7251 ; CHECK-NEXT: %4 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 2
7252 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
7253 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 8
7254 ; CHECK-NEXT: %7 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 4
7255 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
7256 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 8
7257 ; CHECK-NEXT: %10 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 6
7258 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
7259 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 8
7260 ; CHECK-NEXT: %13 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 8
7261 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
7262 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14, align 8
7263 ; CHECK-NEXT: %16 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 10
7264 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
7265 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17, align 8
7266 ; CHECK-NEXT: %19 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 12
7267 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
7268 ; CHECK-NEXT: %21 = load volatile <2 x i64>, <2 x i64>* %20, align 8
7269 ; CHECK-NEXT: %22 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 14
7270 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
7271 ; CHECK-NEXT: %24 = load volatile <2 x i64>, <2 x i64>* %23, align 8
7272 ; CHECK-NEXT: %25 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 16
7273 ; CHECK-NEXT: %26 = bitcast i64* %25 to <2 x i64>*
7274 ; CHECK-NEXT: %27 = load volatile <2 x i64>, <2 x i64>* %26, align 8
7275 ; CHECK-NEXT: %28 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 18
7276 ; CHECK-NEXT: %29 = bitcast i64* %28 to <2 x i64>*
7277 ; CHECK-NEXT: %30 = load volatile <2 x i64>, <2 x i64>* %29, align 8
7278 ; CHECK-NEXT: ret i32 0
7279 ; CHECK-NEXT: }
7280
7281 define i32 @volatile_load_from_20xi8ptr_align_8(<20 x i8*>*) {
7282 entry:
7283 %1 = load volatile <20 x i8*>, <20 x i8*>* %0, align 8
7284 ret i32 0
7285 }
7286 ; CHECK-LABEL: define i32 @volatile_load_from_20xi8ptr_align_8(<20 x i8*>*) {
7287 ; CHECK: entry:
7288 ; CHECK-NEXT: %1 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 0
7289 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
7290 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 8
7291 ; CHECK-NEXT: %4 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 4
7292 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
7293 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 8
7294 ; CHECK-NEXT: %7 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 8
7295 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
7296 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8, align 8
7297 ; CHECK-NEXT: %10 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 12
7298 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
7299 ; CHECK-NEXT: %12 = load volatile <4 x i8*>, <4 x i8*>* %11, align 8
7300 ; CHECK-NEXT: %13 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 16
7301 ; CHECK-NEXT: %14 = bitcast i8** %13 to <4 x i8*>*
7302 ; CHECK-NEXT: %15 = load volatile <4 x i8*>, <4 x i8*>* %14, align 8
7303 ; CHECK-NEXT: ret i32 0
7304 ; CHECK-NEXT: }
7305
7306 define i32 @volatile_load_from_20xfloat_align_8(<20 x float>*) {
7307 entry:
7308 %1 = load volatile <20 x float>, <20 x float>* %0, align 8
7309 ret i32 0
7310 }
7311 ; CHECK-LABEL: define i32 @volatile_load_from_20xfloat_align_8(<20 x float>*) {
7312 ; CHECK: entry:
7313 ; CHECK-NEXT: %1 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 0
7314 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
7315 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 8
7316 ; CHECK-NEXT: %4 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 4
7317 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
7318 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 8
7319 ; CHECK-NEXT: %7 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 8
7320 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
7321 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8, align 8
7322 ; CHECK-NEXT: %10 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 12
7323 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
7324 ; CHECK-NEXT: %12 = load volatile <4 x float>, <4 x float>* %11, align 8
7325 ; CHECK-NEXT: %13 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 16
7326 ; CHECK-NEXT: %14 = bitcast float* %13 to <4 x float>*
7327 ; CHECK-NEXT: %15 = load volatile <4 x float>, <4 x float>* %14, align 8
7328 ; CHECK-NEXT: ret i32 0
7329 ; CHECK-NEXT: }
7330
7331 define i32 @volatile_load_from_20xdouble_align_8(<20 x double>*) {
7332 entry:
7333 %1 = load volatile <20 x double>, <20 x double>* %0, align 8
7334 ret i32 0
7335 }
7336 ; CHECK-LABEL: define i32 @volatile_load_from_20xdouble_align_8(<20 x double>*) {
7337 ; CHECK: entry:
7338 ; CHECK-NEXT: %1 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 0
7339 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
7340 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 8
7341 ; CHECK-NEXT: %4 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 2
7342 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
7343 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 8
7344 ; CHECK-NEXT: %7 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 4
7345 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
7346 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 8
7347 ; CHECK-NEXT: %10 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 6
7348 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
7349 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 8
7350 ; CHECK-NEXT: %13 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 8
7351 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
7352 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14, align 8
7353 ; CHECK-NEXT: %16 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 10
7354 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
7355 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17, align 8
7356 ; CHECK-NEXT: %19 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 12
7357 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
7358 ; CHECK-NEXT: %21 = load volatile <2 x double>, <2 x double>* %20, align 8
7359 ; CHECK-NEXT: %22 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 14
7360 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
7361 ; CHECK-NEXT: %24 = load volatile <2 x double>, <2 x double>* %23, align 8
7362 ; CHECK-NEXT: %25 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 16
7363 ; CHECK-NEXT: %26 = bitcast double* %25 to <2 x double>*
7364 ; CHECK-NEXT: %27 = load volatile <2 x double>, <2 x double>* %26, align 8
7365 ; CHECK-NEXT: %28 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 18
7366 ; CHECK-NEXT: %29 = bitcast double* %28 to <2 x double>*
7367 ; CHECK-NEXT: %30 = load volatile <2 x double>, <2 x double>* %29, align 8
7368 ; CHECK-NEXT: ret i32 0
7369 ; CHECK-NEXT: }
7370
7371 define i32 @volatile_load_from_2xi8_align_32(<2 x i8>*) {
7372 entry:
7373 %1 = load volatile <2 x i8>, <2 x i8>* %0, align 32
7374 ret i32 0
7375 }
7376 ; CHECK-LABEL: define i32 @volatile_load_from_2xi8_align_32(<2 x i8>*) {
7377 ; CHECK: entry:
7378 ; CHECK-NEXT: %1 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 0
7379 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 32
7380 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
7381 ; CHECK-NEXT: %4 = getelementptr <2 x i8>, <2 x i8>* %0, i32 0, i32 1
7382 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
7383 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
7384 ; CHECK-NEXT: ret i32 0
7385 ; CHECK-NEXT: }
7386
7387 define i32 @volatile_load_from_2xi16_align_32(<2 x i16>*) {
7388 entry:
7389 %1 = load volatile <2 x i16>, <2 x i16>* %0, align 32
7390 ret i32 0
7391 }
7392 ; CHECK-LABEL: define i32 @volatile_load_from_2xi16_align_32(<2 x i16>*) {
7393 ; CHECK: entry:
7394 ; CHECK-NEXT: %1 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 0
7395 ; CHECK-NEXT: %2 = load volatile i16, i16* %1, align 32
7396 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
7397 ; CHECK-NEXT: %4 = getelementptr <2 x i16>, <2 x i16>* %0, i32 0, i32 1
7398 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 2
7399 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
7400 ; CHECK-NEXT: ret i32 0
7401 ; CHECK-NEXT: }
7402
7403 define i32 @volatile_load_from_2xi32_align_32(<2 x i32>*) {
7404 entry:
7405 %1 = load volatile <2 x i32>, <2 x i32>* %0, align 32
7406 ret i32 0
7407 }
7408 ; CHECK-LABEL: define i32 @volatile_load_from_2xi32_align_32(<2 x i32>*) {
7409 ; CHECK: entry:
7410 ; CHECK-NEXT: %1 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 0
7411 ; CHECK-NEXT: %2 = load volatile i32, i32* %1, align 32
7412 ; CHECK-NEXT: %3 = insertelement <4 x i32> undef, i32 %2, i32 0
7413 ; CHECK-NEXT: %4 = getelementptr <2 x i32>, <2 x i32>* %0, i32 0, i32 1
7414 ; CHECK-NEXT: %5 = load volatile i32, i32* %4, align 4
7415 ; CHECK-NEXT: %6 = insertelement <4 x i32> %3, i32 %5, i32 1
7416 ; CHECK-NEXT: ret i32 0
7417 ; CHECK-NEXT: }
7418
7419 define i32 @volatile_load_from_2xi64_align_32(<2 x i64>*) {
7420 entry:
7421 %1 = load volatile <2 x i64>, <2 x i64>* %0, align 32
7422 ret i32 0
7423 }
7424 ; CHECK-LABEL: define i32 @volatile_load_from_2xi64_align_32(<2 x i64>*) {
7425 ; CHECK: entry:
7426 ; CHECK-NEXT: %1 = load volatile <2 x i64>, <2 x i64>* %0, align 32
7427 ; CHECK-NEXT: ret i32 0
7428 ; CHECK-NEXT: }
7429
7430 define i32 @volatile_load_from_2xi8ptr_align_32(<2 x i8*>*) {
7431 entry:
7432 %1 = load volatile <2 x i8*>, <2 x i8*>* %0, align 32
7433 ret i32 0
7434 }
7435 ; CHECK-LABEL: define i32 @volatile_load_from_2xi8ptr_align_32(<2 x i8*>*) {
7436 ; CHECK: entry:
7437 ; CHECK-NEXT: %1 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 0
7438 ; CHECK-NEXT: %2 = load volatile i8*, i8** %1, align 32
7439 ; CHECK-NEXT: %3 = insertelement <4 x i8*> undef, i8* %2, i32 0
7440 ; CHECK-NEXT: %4 = getelementptr <2 x i8*>, <2 x i8*>* %0, i32 0, i32 1
7441 ; CHECK-NEXT: %5 = load volatile i8*, i8** %4, align 4
7442 ; CHECK-NEXT: %6 = insertelement <4 x i8*> %3, i8* %5, i32 1
7443 ; CHECK-NEXT: ret i32 0
7444 ; CHECK-NEXT: }
7445
7446 define i32 @volatile_load_from_2xfloat_align_32(<2 x float>*) {
7447 entry:
7448 %1 = load volatile <2 x float>, <2 x float>* %0, align 32
7449 ret i32 0
7450 }
7451 ; CHECK-LABEL: define i32 @volatile_load_from_2xfloat_align_32(<2 x float>*) {
7452 ; CHECK: entry:
7453 ; CHECK-NEXT: %1 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 0
7454 ; CHECK-NEXT: %2 = load volatile float, float* %1, align 32
7455 ; CHECK-NEXT: %3 = insertelement <4 x float> undef, float %2, i32 0
7456 ; CHECK-NEXT: %4 = getelementptr <2 x float>, <2 x float>* %0, i32 0, i32 1
7457 ; CHECK-NEXT: %5 = load volatile float, float* %4, align 4
7458 ; CHECK-NEXT: %6 = insertelement <4 x float> %3, float %5, i32 1
7459 ; CHECK-NEXT: ret i32 0
7460 ; CHECK-NEXT: }
7461
7462 define i32 @volatile_load_from_2xdouble_align_32(<2 x double>*) {
7463 entry:
7464 %1 = load volatile <2 x double>, <2 x double>* %0, align 32
7465 ret i32 0
7466 }
7467 ; CHECK-LABEL: define i32 @volatile_load_from_2xdouble_align_32(<2 x double>*) {
7468 ; CHECK: entry:
7469 ; CHECK-NEXT: %1 = load volatile <2 x double>, <2 x double>* %0, align 32
7470 ; CHECK-NEXT: ret i32 0
7471 ; CHECK-NEXT: }
7472
7473 define i32 @volatile_load_from_4xi8_align_32(<4 x i8>*) {
7474 entry:
7475 %1 = load volatile <4 x i8>, <4 x i8>* %0, align 32
7476 ret i32 0
7477 }
7478 ; CHECK-LABEL: define i32 @volatile_load_from_4xi8_align_32(<4 x i8>*) {
7479 ; CHECK: entry:
7480 ; CHECK-NEXT: %1 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 0
7481 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 32
7482 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
7483 ; CHECK-NEXT: %4 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 1
7484 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
7485 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
7486 ; CHECK-NEXT: %7 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 2
7487 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 2
7488 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
7489 ; CHECK-NEXT: %10 = getelementptr <4 x i8>, <4 x i8>* %0, i32 0, i32 3
7490 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
7491 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
7492 ; CHECK-NEXT: ret i32 0
7493 ; CHECK-NEXT: }
7494
7495 define i32 @volatile_load_from_4xi16_align_32(<4 x i16>*) {
7496 entry:
7497 %1 = load volatile <4 x i16>, <4 x i16>* %0, align 32
7498 ret i32 0
7499 }
7500 ; CHECK-LABEL: define i32 @volatile_load_from_4xi16_align_32(<4 x i16>*) {
7501 ; CHECK: entry:
7502 ; CHECK-NEXT: %1 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 0
7503 ; CHECK-NEXT: %2 = load volatile i16, i16* %1, align 32
7504 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
7505 ; CHECK-NEXT: %4 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 1
7506 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 2
7507 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
7508 ; CHECK-NEXT: %7 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 2
7509 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 4
7510 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
7511 ; CHECK-NEXT: %10 = getelementptr <4 x i16>, <4 x i16>* %0, i32 0, i32 3
7512 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 2
7513 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
7514 ; CHECK-NEXT: ret i32 0
7515 ; CHECK-NEXT: }
7516
7517 define i32 @volatile_load_from_4xi32_align_32(<4 x i32>*) {
7518 entry:
7519 %1 = load volatile <4 x i32>, <4 x i32>* %0, align 32
7520 ret i32 0
7521 }
7522 ; CHECK-LABEL: define i32 @volatile_load_from_4xi32_align_32(<4 x i32>*) {
7523 ; CHECK: entry:
7524 ; CHECK-NEXT: %1 = load volatile <4 x i32>, <4 x i32>* %0, align 32
7525 ; CHECK-NEXT: ret i32 0
7526 ; CHECK-NEXT: }
7527
7528 define i32 @volatile_load_from_4xi64_align_32(<4 x i64>*) {
7529 entry:
7530 %1 = load volatile <4 x i64>, <4 x i64>* %0, align 32
7531 ret i32 0
7532 }
7533 ; CHECK-LABEL: define i32 @volatile_load_from_4xi64_align_32(<4 x i64>*) {
7534 ; CHECK: entry:
7535 ; CHECK-NEXT: %1 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 0
7536 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
7537 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 32
7538 ; CHECK-NEXT: %4 = getelementptr <4 x i64>, <4 x i64>* %0, i32 0, i32 2
7539 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
7540 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 16
7541 ; CHECK-NEXT: ret i32 0
7542 ; CHECK-NEXT: }
7543
7544 define i32 @volatile_load_from_4xi8ptr_align_32(<4 x i8*>*) {
7545 entry:
7546 %1 = load volatile <4 x i8*>, <4 x i8*>* %0, align 32
7547 ret i32 0
7548 }
7549 ; CHECK-LABEL: define i32 @volatile_load_from_4xi8ptr_align_32(<4 x i8*>*) {
7550 ; CHECK: entry:
7551 ; CHECK-NEXT: %1 = load volatile <4 x i8*>, <4 x i8*>* %0, align 32
7552 ; CHECK-NEXT: ret i32 0
7553 ; CHECK-NEXT: }
7554
7555 define i32 @volatile_load_from_4xfloat_align_32(<4 x float>*) {
7556 entry:
7557 %1 = load volatile <4 x float>, <4 x float>* %0, align 32
7558 ret i32 0
7559 }
7560 ; CHECK-LABEL: define i32 @volatile_load_from_4xfloat_align_32(<4 x float>*) {
7561 ; CHECK: entry:
7562 ; CHECK-NEXT: %1 = load volatile <4 x float>, <4 x float>* %0, align 32
7563 ; CHECK-NEXT: ret i32 0
7564 ; CHECK-NEXT: }
7565
7566 define i32 @volatile_load_from_4xdouble_align_32(<4 x double>*) {
7567 entry:
7568 %1 = load volatile <4 x double>, <4 x double>* %0, align 32
7569 ret i32 0
7570 }
7571 ; CHECK-LABEL: define i32 @volatile_load_from_4xdouble_align_32(<4 x double>*) {
7572 ; CHECK: entry:
7573 ; CHECK-NEXT: %1 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 0
7574 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
7575 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 32
7576 ; CHECK-NEXT: %4 = getelementptr <4 x double>, <4 x double>* %0, i32 0, i32 2
7577 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
7578 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 16
7579 ; CHECK-NEXT: ret i32 0
7580 ; CHECK-NEXT: }
7581
7582 define i32 @volatile_load_from_6xi8_align_32(<6 x i8>*) {
7583 entry:
7584 %1 = load volatile <6 x i8>, <6 x i8>* %0, align 32
7585 ret i32 0
7586 }
7587 ; CHECK-LABEL: define i32 @volatile_load_from_6xi8_align_32(<6 x i8>*) {
7588 ; CHECK: entry:
7589 ; CHECK-NEXT: %1 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 0
7590 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 32
7591 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
7592 ; CHECK-NEXT: %4 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 1
7593 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
7594 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
7595 ; CHECK-NEXT: %7 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 2
7596 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 2
7597 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
7598 ; CHECK-NEXT: %10 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 3
7599 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
7600 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
7601 ; CHECK-NEXT: %13 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 4
7602 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 4
7603 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
7604 ; CHECK-NEXT: %16 = getelementptr <6 x i8>, <6 x i8>* %0, i32 0, i32 5
7605 ; CHECK-NEXT: %17 = load volatile i8, i8* %16, align 1
7606 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
7607 ; CHECK-NEXT: ret i32 0
7608 ; CHECK-NEXT: }
7609
7610 define i32 @volatile_load_from_6xi16_align_32(<6 x i16>*) {
7611 entry:
7612 %1 = load volatile <6 x i16>, <6 x i16>* %0, align 32
7613 ret i32 0
7614 }
7615 ; CHECK-LABEL: define i32 @volatile_load_from_6xi16_align_32(<6 x i16>*) {
7616 ; CHECK: entry:
7617 ; CHECK-NEXT: %1 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 0
7618 ; CHECK-NEXT: %2 = load volatile i16, i16* %1, align 32
7619 ; CHECK-NEXT: %3 = insertelement <8 x i16> undef, i16 %2, i32 0
7620 ; CHECK-NEXT: %4 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 1
7621 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 2
7622 ; CHECK-NEXT: %6 = insertelement <8 x i16> %3, i16 %5, i32 1
7623 ; CHECK-NEXT: %7 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 2
7624 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 4
7625 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 2
7626 ; CHECK-NEXT: %10 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 3
7627 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 2
7628 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 3
7629 ; CHECK-NEXT: %13 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 4
7630 ; CHECK-NEXT: %14 = load volatile i16, i16* %13, align 8
7631 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 4
7632 ; CHECK-NEXT: %16 = getelementptr <6 x i16>, <6 x i16>* %0, i32 0, i32 5
7633 ; CHECK-NEXT: %17 = load volatile i16, i16* %16, align 2
7634 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 5
7635 ; CHECK-NEXT: ret i32 0
7636 ; CHECK-NEXT: }
7637
7638 define i32 @volatile_load_from_6xi32_align_32(<6 x i32>*) {
7639 entry:
7640 %1 = load volatile <6 x i32>, <6 x i32>* %0, align 32
7641 ret i32 0
7642 }
7643 ; CHECK-LABEL: define i32 @volatile_load_from_6xi32_align_32(<6 x i32>*) {
7644 ; CHECK: entry:
7645 ; CHECK-NEXT: %1 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 0
7646 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
7647 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 32
7648 ; CHECK-NEXT: %4 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 4
7649 ; CHECK-NEXT: %5 = load volatile i32, i32* %4, align 16
7650 ; CHECK-NEXT: %6 = insertelement <4 x i32> undef, i32 %5, i32 0
7651 ; CHECK-NEXT: %7 = getelementptr <6 x i32>, <6 x i32>* %0, i32 0, i32 5
7652 ; CHECK-NEXT: %8 = load volatile i32, i32* %7, align 4
7653 ; CHECK-NEXT: %9 = insertelement <4 x i32> %6, i32 %8, i32 1
7654 ; CHECK-NEXT: ret i32 0
7655 ; CHECK-NEXT: }
7656
7657 define i32 @volatile_load_from_6xi64_align_32(<6 x i64>*) {
7658 entry:
7659 %1 = load volatile <6 x i64>, <6 x i64>* %0, align 32
7660 ret i32 0
7661 }
7662 ; CHECK-LABEL: define i32 @volatile_load_from_6xi64_align_32(<6 x i64>*) {
7663 ; CHECK: entry:
7664 ; CHECK-NEXT: %1 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 0
7665 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
7666 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 32
7667 ; CHECK-NEXT: %4 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 2
7668 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
7669 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 16
7670 ; CHECK-NEXT: %7 = getelementptr <6 x i64>, <6 x i64>* %0, i32 0, i32 4
7671 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
7672 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 32
7673 ; CHECK-NEXT: ret i32 0
7674 ; CHECK-NEXT: }
7675
7676 define i32 @volatile_load_from_6xi8ptr_align_32(<6 x i8*>*) {
7677 entry:
7678 %1 = load volatile <6 x i8*>, <6 x i8*>* %0, align 32
7679 ret i32 0
7680 }
7681 ; CHECK-LABEL: define i32 @volatile_load_from_6xi8ptr_align_32(<6 x i8*>*) {
7682 ; CHECK: entry:
7683 ; CHECK-NEXT: %1 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 0
7684 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
7685 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 32
7686 ; CHECK-NEXT: %4 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 4
7687 ; CHECK-NEXT: %5 = load volatile i8*, i8** %4, align 16
7688 ; CHECK-NEXT: %6 = insertelement <4 x i8*> undef, i8* %5, i32 0
7689 ; CHECK-NEXT: %7 = getelementptr <6 x i8*>, <6 x i8*>* %0, i32 0, i32 5
7690 ; CHECK-NEXT: %8 = load volatile i8*, i8** %7, align 4
7691 ; CHECK-NEXT: %9 = insertelement <4 x i8*> %6, i8* %8, i32 1
7692 ; CHECK-NEXT: ret i32 0
7693 ; CHECK-NEXT: }
7694
7695 define i32 @volatile_load_from_6xfloat_align_32(<6 x float>*) {
7696 entry:
7697 %1 = load volatile <6 x float>, <6 x float>* %0, align 32
7698 ret i32 0
7699 }
7700 ; CHECK-LABEL: define i32 @volatile_load_from_6xfloat_align_32(<6 x float>*) {
7701 ; CHECK: entry:
7702 ; CHECK-NEXT: %1 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 0
7703 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
7704 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 32
7705 ; CHECK-NEXT: %4 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 4
7706 ; CHECK-NEXT: %5 = load volatile float, float* %4, align 16
7707 ; CHECK-NEXT: %6 = insertelement <4 x float> undef, float %5, i32 0
7708 ; CHECK-NEXT: %7 = getelementptr <6 x float>, <6 x float>* %0, i32 0, i32 5
7709 ; CHECK-NEXT: %8 = load volatile float, float* %7, align 4
7710 ; CHECK-NEXT: %9 = insertelement <4 x float> %6, float %8, i32 1
7711 ; CHECK-NEXT: ret i32 0
7712 ; CHECK-NEXT: }
7713
7714 define i32 @volatile_load_from_6xdouble_align_32(<6 x double>*) {
7715 entry:
7716 %1 = load volatile <6 x double>, <6 x double>* %0, align 32
7717 ret i32 0
7718 }
7719 ; CHECK-LABEL: define i32 @volatile_load_from_6xdouble_align_32(<6 x double>*) {
7720 ; CHECK: entry:
7721 ; CHECK-NEXT: %1 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 0
7722 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
7723 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 32
7724 ; CHECK-NEXT: %4 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 2
7725 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
7726 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 16
7727 ; CHECK-NEXT: %7 = getelementptr <6 x double>, <6 x double>* %0, i32 0, i32 4
7728 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
7729 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 32
7730 ; CHECK-NEXT: ret i32 0
7731 ; CHECK-NEXT: }
7732
7733 define i32 @volatile_load_from_8xi8_align_32(<8 x i8>*) {
7734 entry:
7735 %1 = load volatile <8 x i8>, <8 x i8>* %0, align 32
7736 ret i32 0
7737 }
7738 ; CHECK-LABEL: define i32 @volatile_load_from_8xi8_align_32(<8 x i8>*) {
7739 ; CHECK: entry:
7740 ; CHECK-NEXT: %1 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 0
7741 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 32
7742 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
7743 ; CHECK-NEXT: %4 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 1
7744 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
7745 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
7746 ; CHECK-NEXT: %7 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 2
7747 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 2
7748 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
7749 ; CHECK-NEXT: %10 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 3
7750 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
7751 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
7752 ; CHECK-NEXT: %13 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 4
7753 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 4
7754 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
7755 ; CHECK-NEXT: %16 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 5
7756 ; CHECK-NEXT: %17 = load volatile i8, i8* %16, align 1
7757 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
7758 ; CHECK-NEXT: %19 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 6
7759 ; CHECK-NEXT: %20 = load volatile i8, i8* %19, align 2
7760 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
7761 ; CHECK-NEXT: %22 = getelementptr <8 x i8>, <8 x i8>* %0, i32 0, i32 7
7762 ; CHECK-NEXT: %23 = load volatile i8, i8* %22, align 1
7763 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
7764 ; CHECK-NEXT: ret i32 0
7765 ; CHECK-NEXT: }
7766
7767 define i32 @volatile_load_from_8xi16_align_32(<8 x i16>*) {
7768 entry:
7769 %1 = load volatile <8 x i16>, <8 x i16>* %0, align 32
7770 ret i32 0
7771 }
7772 ; CHECK-LABEL: define i32 @volatile_load_from_8xi16_align_32(<8 x i16>*) {
7773 ; CHECK: entry:
7774 ; CHECK-NEXT: %1 = load volatile <8 x i16>, <8 x i16>* %0, align 32
7775 ; CHECK-NEXT: ret i32 0
7776 ; CHECK-NEXT: }
7777
7778 define i32 @volatile_load_from_8xi32_align_32(<8 x i32>*) {
7779 entry:
7780 %1 = load volatile <8 x i32>, <8 x i32>* %0, align 32
7781 ret i32 0
7782 }
7783 ; CHECK-LABEL: define i32 @volatile_load_from_8xi32_align_32(<8 x i32>*) {
7784 ; CHECK: entry:
7785 ; CHECK-NEXT: %1 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 0
7786 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
7787 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 32
7788 ; CHECK-NEXT: %4 = getelementptr <8 x i32>, <8 x i32>* %0, i32 0, i32 4
7789 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
7790 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 16
7791 ; CHECK-NEXT: ret i32 0
7792 ; CHECK-NEXT: }
7793
7794 define i32 @volatile_load_from_8xi64_align_32(<8 x i64>*) {
7795 entry:
7796 %1 = load volatile <8 x i64>, <8 x i64>* %0, align 32
7797 ret i32 0
7798 }
7799 ; CHECK-LABEL: define i32 @volatile_load_from_8xi64_align_32(<8 x i64>*) {
7800 ; CHECK: entry:
7801 ; CHECK-NEXT: %1 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 0
7802 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
7803 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 32
7804 ; CHECK-NEXT: %4 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 2
7805 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
7806 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 16
7807 ; CHECK-NEXT: %7 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 4
7808 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
7809 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 32
7810 ; CHECK-NEXT: %10 = getelementptr <8 x i64>, <8 x i64>* %0, i32 0, i32 6
7811 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
7812 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 16
7813 ; CHECK-NEXT: ret i32 0
7814 ; CHECK-NEXT: }
7815
7816 define i32 @volatile_load_from_8xi8ptr_align_32(<8 x i8*>*) {
7817 entry:
7818 %1 = load volatile <8 x i8*>, <8 x i8*>* %0, align 32
7819 ret i32 0
7820 }
7821 ; CHECK-LABEL: define i32 @volatile_load_from_8xi8ptr_align_32(<8 x i8*>*) {
7822 ; CHECK: entry:
7823 ; CHECK-NEXT: %1 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 0
7824 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
7825 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 32
7826 ; CHECK-NEXT: %4 = getelementptr <8 x i8*>, <8 x i8*>* %0, i32 0, i32 4
7827 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
7828 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 16
7829 ; CHECK-NEXT: ret i32 0
7830 ; CHECK-NEXT: }
7831
7832 define i32 @volatile_load_from_8xfloat_align_32(<8 x float>*) {
7833 entry:
7834 %1 = load volatile <8 x float>, <8 x float>* %0, align 32
7835 ret i32 0
7836 }
7837 ; CHECK-LABEL: define i32 @volatile_load_from_8xfloat_align_32(<8 x float>*) {
7838 ; CHECK: entry:
7839 ; CHECK-NEXT: %1 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 0
7840 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
7841 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 32
7842 ; CHECK-NEXT: %4 = getelementptr <8 x float>, <8 x float>* %0, i32 0, i32 4
7843 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
7844 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 16
7845 ; CHECK-NEXT: ret i32 0
7846 ; CHECK-NEXT: }
7847
7848 define i32 @volatile_load_from_8xdouble_align_32(<8 x double>*) {
7849 entry:
7850 %1 = load volatile <8 x double>, <8 x double>* %0, align 32
7851 ret i32 0
7852 }
7853 ; CHECK-LABEL: define i32 @volatile_load_from_8xdouble_align_32(<8 x double>*) {
7854 ; CHECK: entry:
7855 ; CHECK-NEXT: %1 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 0
7856 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
7857 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 32
7858 ; CHECK-NEXT: %4 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 2
7859 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
7860 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 16
7861 ; CHECK-NEXT: %7 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 4
7862 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
7863 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 32
7864 ; CHECK-NEXT: %10 = getelementptr <8 x double>, <8 x double>* %0, i32 0, i32 6
7865 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
7866 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 16
7867 ; CHECK-NEXT: ret i32 0
7868 ; CHECK-NEXT: }
7869
7870 define i32 @volatile_load_from_12xi8_align_32(<12 x i8>*) {
7871 entry:
7872 %1 = load volatile <12 x i8>, <12 x i8>* %0, align 32
7873 ret i32 0
7874 }
7875 ; CHECK-LABEL: define i32 @volatile_load_from_12xi8_align_32(<12 x i8>*) {
7876 ; CHECK: entry:
7877 ; CHECK-NEXT: %1 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 0
7878 ; CHECK-NEXT: %2 = load volatile i8, i8* %1, align 32
7879 ; CHECK-NEXT: %3 = insertelement <16 x i8> undef, i8 %2, i32 0
7880 ; CHECK-NEXT: %4 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 1
7881 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 1
7882 ; CHECK-NEXT: %6 = insertelement <16 x i8> %3, i8 %5, i32 1
7883 ; CHECK-NEXT: %7 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 2
7884 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 2
7885 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 2
7886 ; CHECK-NEXT: %10 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 3
7887 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 1
7888 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 3
7889 ; CHECK-NEXT: %13 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 4
7890 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 4
7891 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 4
7892 ; CHECK-NEXT: %16 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 5
7893 ; CHECK-NEXT: %17 = load volatile i8, i8* %16, align 1
7894 ; CHECK-NEXT: %18 = insertelement <16 x i8> %15, i8 %17, i32 5
7895 ; CHECK-NEXT: %19 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 6
7896 ; CHECK-NEXT: %20 = load volatile i8, i8* %19, align 2
7897 ; CHECK-NEXT: %21 = insertelement <16 x i8> %18, i8 %20, i32 6
7898 ; CHECK-NEXT: %22 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 7
7899 ; CHECK-NEXT: %23 = load volatile i8, i8* %22, align 1
7900 ; CHECK-NEXT: %24 = insertelement <16 x i8> %21, i8 %23, i32 7
7901 ; CHECK-NEXT: %25 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 8
7902 ; CHECK-NEXT: %26 = load volatile i8, i8* %25, align 8
7903 ; CHECK-NEXT: %27 = insertelement <16 x i8> %24, i8 %26, i32 8
7904 ; CHECK-NEXT: %28 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 9
7905 ; CHECK-NEXT: %29 = load volatile i8, i8* %28, align 1
7906 ; CHECK-NEXT: %30 = insertelement <16 x i8> %27, i8 %29, i32 9
7907 ; CHECK-NEXT: %31 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 10
7908 ; CHECK-NEXT: %32 = load volatile i8, i8* %31, align 2
7909 ; CHECK-NEXT: %33 = insertelement <16 x i8> %30, i8 %32, i32 10
7910 ; CHECK-NEXT: %34 = getelementptr <12 x i8>, <12 x i8>* %0, i32 0, i32 11
7911 ; CHECK-NEXT: %35 = load volatile i8, i8* %34, align 1
7912 ; CHECK-NEXT: %36 = insertelement <16 x i8> %33, i8 %35, i32 11
7913 ; CHECK-NEXT: ret i32 0
7914 ; CHECK-NEXT: }
7915
7916 define i32 @volatile_load_from_12xi16_align_32(<12 x i16>*) {
7917 entry:
7918 %1 = load volatile <12 x i16>, <12 x i16>* %0, align 32
7919 ret i32 0
7920 }
7921 ; CHECK-LABEL: define i32 @volatile_load_from_12xi16_align_32(<12 x i16>*) {
7922 ; CHECK: entry:
7923 ; CHECK-NEXT: %1 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 0
7924 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
7925 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2, align 32
7926 ; CHECK-NEXT: %4 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 8
7927 ; CHECK-NEXT: %5 = load volatile i16, i16* %4, align 16
7928 ; CHECK-NEXT: %6 = insertelement <8 x i16> undef, i16 %5, i32 0
7929 ; CHECK-NEXT: %7 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 9
7930 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 2
7931 ; CHECK-NEXT: %9 = insertelement <8 x i16> %6, i16 %8, i32 1
7932 ; CHECK-NEXT: %10 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 10
7933 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 4
7934 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 2
7935 ; CHECK-NEXT: %13 = getelementptr <12 x i16>, <12 x i16>* %0, i32 0, i32 11
7936 ; CHECK-NEXT: %14 = load volatile i16, i16* %13, align 2
7937 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 3
7938 ; CHECK-NEXT: ret i32 0
7939 ; CHECK-NEXT: }
7940
7941 define i32 @volatile_load_from_12xi32_align_32(<12 x i32>*) {
7942 entry:
7943 %1 = load volatile <12 x i32>, <12 x i32>* %0, align 32
7944 ret i32 0
7945 }
7946 ; CHECK-LABEL: define i32 @volatile_load_from_12xi32_align_32(<12 x i32>*) {
7947 ; CHECK: entry:
7948 ; CHECK-NEXT: %1 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 0
7949 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
7950 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 32
7951 ; CHECK-NEXT: %4 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 4
7952 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
7953 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 16
7954 ; CHECK-NEXT: %7 = getelementptr <12 x i32>, <12 x i32>* %0, i32 0, i32 8
7955 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
7956 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8, align 32
7957 ; CHECK-NEXT: ret i32 0
7958 ; CHECK-NEXT: }
7959
7960 define i32 @volatile_load_from_12xi64_align_32(<12 x i64>*) {
7961 entry:
7962 %1 = load volatile <12 x i64>, <12 x i64>* %0, align 32
7963 ret i32 0
7964 }
7965 ; CHECK-LABEL: define i32 @volatile_load_from_12xi64_align_32(<12 x i64>*) {
7966 ; CHECK: entry:
7967 ; CHECK-NEXT: %1 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 0
7968 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
7969 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 32
7970 ; CHECK-NEXT: %4 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 2
7971 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
7972 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 16
7973 ; CHECK-NEXT: %7 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 4
7974 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
7975 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 32
7976 ; CHECK-NEXT: %10 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 6
7977 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
7978 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 16
7979 ; CHECK-NEXT: %13 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 8
7980 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
7981 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14, align 32
7982 ; CHECK-NEXT: %16 = getelementptr <12 x i64>, <12 x i64>* %0, i32 0, i32 10
7983 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
7984 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17, align 16
7985 ; CHECK-NEXT: ret i32 0
7986 ; CHECK-NEXT: }
7987
7988 define i32 @volatile_load_from_12xi8ptr_align_32(<12 x i8*>*) {
7989 entry:
7990 %1 = load volatile <12 x i8*>, <12 x i8*>* %0, align 32
7991 ret i32 0
7992 }
7993 ; CHECK-LABEL: define i32 @volatile_load_from_12xi8ptr_align_32(<12 x i8*>*) {
7994 ; CHECK: entry:
7995 ; CHECK-NEXT: %1 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 0
7996 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
7997 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 32
7998 ; CHECK-NEXT: %4 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 4
7999 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
8000 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 16
8001 ; CHECK-NEXT: %7 = getelementptr <12 x i8*>, <12 x i8*>* %0, i32 0, i32 8
8002 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
8003 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8, align 32
8004 ; CHECK-NEXT: ret i32 0
8005 ; CHECK-NEXT: }
8006
8007 define i32 @volatile_load_from_12xfloat_align_32(<12 x float>*) {
8008 entry:
8009 %1 = load volatile <12 x float>, <12 x float>* %0, align 32
8010 ret i32 0
8011 }
8012 ; CHECK-LABEL: define i32 @volatile_load_from_12xfloat_align_32(<12 x float>*) {
8013 ; CHECK: entry:
8014 ; CHECK-NEXT: %1 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 0
8015 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
8016 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 32
8017 ; CHECK-NEXT: %4 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 4
8018 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
8019 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 16
8020 ; CHECK-NEXT: %7 = getelementptr <12 x float>, <12 x float>* %0, i32 0, i32 8
8021 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
8022 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8, align 32
8023 ; CHECK-NEXT: ret i32 0
8024 ; CHECK-NEXT: }
8025
8026 define i32 @volatile_load_from_12xdouble_align_32(<12 x double>*) {
8027 entry:
8028 %1 = load volatile <12 x double>, <12 x double>* %0, align 32
8029 ret i32 0
8030 }
8031 ; CHECK-LABEL: define i32 @volatile_load_from_12xdouble_align_32(<12 x double>*) {
8032 ; CHECK: entry:
8033 ; CHECK-NEXT: %1 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 0
8034 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
8035 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 32
8036 ; CHECK-NEXT: %4 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 2
8037 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
8038 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 16
8039 ; CHECK-NEXT: %7 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i32 4
8040 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
8041 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 32
8042 ; CHECK-NEXT: %10 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 6
8043 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
8044 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 16
8045 ; CHECK-NEXT: %13 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 8
8046 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
8047 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14, align 32
8048 ; CHECK-NEXT: %16 = getelementptr <12 x double>, <12 x double>* %0, i32 0, i3 2 10
8049 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
8050 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17, align 16
8051 ; CHECK-NEXT: ret i32 0
8052 ; CHECK-NEXT: }
8053
8054 define i32 @volatile_load_from_16xi8_align_32(<16 x i8>*) {
8055 entry:
8056 %1 = load volatile <16 x i8>, <16 x i8>* %0, align 32
8057 ret i32 0
8058 }
8059 ; CHECK-LABEL: define i32 @volatile_load_from_16xi8_align_32(<16 x i8>*) {
8060 ; CHECK: entry:
8061 ; CHECK-NEXT: %1 = load volatile <16 x i8>, <16 x i8>* %0, align 32
8062 ; CHECK-NEXT: ret i32 0
8063 ; CHECK-NEXT: }
8064
8065 define i32 @volatile_load_from_16xi16_align_32(<16 x i16>*) {
8066 entry:
8067 %1 = load volatile <16 x i16>, <16 x i16>* %0, align 32
8068 ret i32 0
8069 }
8070 ; CHECK-LABEL: define i32 @volatile_load_from_16xi16_align_32(<16 x i16>*) {
8071 ; CHECK: entry:
8072 ; CHECK-NEXT: %1 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 0
8073 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
8074 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2, align 32
8075 ; CHECK-NEXT: %4 = getelementptr <16 x i16>, <16 x i16>* %0, i32 0, i32 8
8076 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
8077 ; CHECK-NEXT: %6 = load volatile <8 x i16>, <8 x i16>* %5, align 16
8078 ; CHECK-NEXT: ret i32 0
8079 ; CHECK-NEXT: }
8080
8081 define i32 @volatile_load_from_16xi32_align_32(<16 x i32>*) {
8082 entry:
8083 %1 = load volatile <16 x i32>, <16 x i32>* %0, align 32
8084 ret i32 0
8085 }
8086 ; CHECK-LABEL: define i32 @volatile_load_from_16xi32_align_32(<16 x i32>*) {
8087 ; CHECK: entry:
8088 ; CHECK-NEXT: %1 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 0
8089 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
8090 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 32
8091 ; CHECK-NEXT: %4 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 4
8092 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
8093 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 16
8094 ; CHECK-NEXT: %7 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 8
8095 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
8096 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8, align 32
8097 ; CHECK-NEXT: %10 = getelementptr <16 x i32>, <16 x i32>* %0, i32 0, i32 12
8098 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
8099 ; CHECK-NEXT: %12 = load volatile <4 x i32>, <4 x i32>* %11, align 16
8100 ; CHECK-NEXT: ret i32 0
8101 ; CHECK-NEXT: }
8102
8103 define i32 @volatile_load_from_16xi64_align_32(<16 x i64>*) {
8104 entry:
8105 %1 = load volatile <16 x i64>, <16 x i64>* %0, align 32
8106 ret i32 0
8107 }
8108 ; CHECK-LABEL: define i32 @volatile_load_from_16xi64_align_32(<16 x i64>*) {
8109 ; CHECK: entry:
8110 ; CHECK-NEXT: %1 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 0
8111 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
8112 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 32
8113 ; CHECK-NEXT: %4 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 2
8114 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
8115 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 16
8116 ; CHECK-NEXT: %7 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 4
8117 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
8118 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 32
8119 ; CHECK-NEXT: %10 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 6
8120 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
8121 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 16
8122 ; CHECK-NEXT: %13 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 8
8123 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
8124 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14, align 32
8125 ; CHECK-NEXT: %16 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 10
8126 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
8127 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17, align 16
8128 ; CHECK-NEXT: %19 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 12
8129 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
8130 ; CHECK-NEXT: %21 = load volatile <2 x i64>, <2 x i64>* %20, align 32
8131 ; CHECK-NEXT: %22 = getelementptr <16 x i64>, <16 x i64>* %0, i32 0, i32 14
8132 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
8133 ; CHECK-NEXT: %24 = load volatile <2 x i64>, <2 x i64>* %23, align 16
8134 ; CHECK-NEXT: ret i32 0
8135 ; CHECK-NEXT: }
8136
8137 define i32 @volatile_load_from_16xi8ptr_align_32(<16 x i8*>*) {
8138 entry:
8139 %1 = load volatile <16 x i8*>, <16 x i8*>* %0, align 32
8140 ret i32 0
8141 }
8142 ; CHECK-LABEL: define i32 @volatile_load_from_16xi8ptr_align_32(<16 x i8*>*) {
8143 ; CHECK: entry:
8144 ; CHECK-NEXT: %1 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 0
8145 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
8146 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 32
8147 ; CHECK-NEXT: %4 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 4
8148 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
8149 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 16
8150 ; CHECK-NEXT: %7 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 8
8151 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
8152 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8, align 32
8153 ; CHECK-NEXT: %10 = getelementptr <16 x i8*>, <16 x i8*>* %0, i32 0, i32 12
8154 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
8155 ; CHECK-NEXT: %12 = load volatile <4 x i8*>, <4 x i8*>* %11, align 16
8156 ; CHECK-NEXT: ret i32 0
8157 ; CHECK-NEXT: }
8158
8159 define i32 @volatile_load_from_16xfloat_align_32(<16 x float>*) {
8160 entry:
8161 %1 = load volatile <16 x float>, <16 x float>* %0, align 32
8162 ret i32 0
8163 }
8164 ; CHECK-LABEL: define i32 @volatile_load_from_16xfloat_align_32(<16 x float>*) {
8165 ; CHECK: entry:
8166 ; CHECK-NEXT: %1 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 0
8167 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
8168 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 32
8169 ; CHECK-NEXT: %4 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 4
8170 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
8171 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 16
8172 ; CHECK-NEXT: %7 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 8
8173 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
8174 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8, align 32
8175 ; CHECK-NEXT: %10 = getelementptr <16 x float>, <16 x float>* %0, i32 0, i32 12
8176 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
8177 ; CHECK-NEXT: %12 = load volatile <4 x float>, <4 x float>* %11, align 16
8178 ; CHECK-NEXT: ret i32 0
8179 ; CHECK-NEXT: }
8180
8181 define i32 @volatile_load_from_16xdouble_align_32(<16 x double>*) {
8182 entry:
8183 %1 = load volatile <16 x double>, <16 x double>* %0, align 32
8184 ret i32 0
8185 }
8186 ; CHECK-LABEL: define i32 @volatile_load_from_16xdouble_align_32(<16 x double>*) {
8187 ; CHECK: entry:
8188 ; CHECK-NEXT: %1 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 0
8189 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
8190 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 32
8191 ; CHECK-NEXT: %4 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 2
8192 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
8193 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 16
8194 ; CHECK-NEXT: %7 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i32 4
8195 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
8196 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 32
8197 ; CHECK-NEXT: %10 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 6
8198 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
8199 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 16
8200 ; CHECK-NEXT: %13 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 8
8201 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
8202 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14, align 32
8203 ; CHECK-NEXT: %16 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 10
8204 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
8205 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17, align 16
8206 ; CHECK-NEXT: %19 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 12
8207 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
8208 ; CHECK-NEXT: %21 = load volatile <2 x double>, <2 x double>* %20, align 32
8209 ; CHECK-NEXT: %22 = getelementptr <16 x double>, <16 x double>* %0, i32 0, i3 2 14
8210 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
8211 ; CHECK-NEXT: %24 = load volatile <2 x double>, <2 x double>* %23, align 16
8212 ; CHECK-NEXT: ret i32 0
8213 ; CHECK-NEXT: }
8214
8215 define i32 @volatile_load_from_20xi8_align_32(<20 x i8>*) {
8216 entry:
8217 %1 = load volatile <20 x i8>, <20 x i8>* %0, align 32
8218 ret i32 0
8219 }
8220 ; CHECK-LABEL: define i32 @volatile_load_from_20xi8_align_32(<20 x i8>*) {
8221 ; CHECK: entry:
8222 ; CHECK-NEXT: %1 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 0
8223 ; CHECK-NEXT: %2 = bitcast i8* %1 to <16 x i8>*
8224 ; CHECK-NEXT: %3 = load volatile <16 x i8>, <16 x i8>* %2, align 32
8225 ; CHECK-NEXT: %4 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 16
8226 ; CHECK-NEXT: %5 = load volatile i8, i8* %4, align 16
8227 ; CHECK-NEXT: %6 = insertelement <16 x i8> undef, i8 %5, i32 0
8228 ; CHECK-NEXT: %7 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 17
8229 ; CHECK-NEXT: %8 = load volatile i8, i8* %7, align 1
8230 ; CHECK-NEXT: %9 = insertelement <16 x i8> %6, i8 %8, i32 1
8231 ; CHECK-NEXT: %10 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 18
8232 ; CHECK-NEXT: %11 = load volatile i8, i8* %10, align 2
8233 ; CHECK-NEXT: %12 = insertelement <16 x i8> %9, i8 %11, i32 2
8234 ; CHECK-NEXT: %13 = getelementptr <20 x i8>, <20 x i8>* %0, i32 0, i32 19
8235 ; CHECK-NEXT: %14 = load volatile i8, i8* %13, align 1
8236 ; CHECK-NEXT: %15 = insertelement <16 x i8> %12, i8 %14, i32 3
8237 ; CHECK-NEXT: ret i32 0
8238 ; CHECK-NEXT: }
8239
8240 define i32 @volatile_load_from_20xi16_align_32(<20 x i16>*) {
8241 entry:
8242 %1 = load volatile <20 x i16>, <20 x i16>* %0, align 32
8243 ret i32 0
8244 }
8245 ; CHECK-LABEL: define i32 @volatile_load_from_20xi16_align_32(<20 x i16>*) {
8246 ; CHECK: entry:
8247 ; CHECK-NEXT: %1 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 0
8248 ; CHECK-NEXT: %2 = bitcast i16* %1 to <8 x i16>*
8249 ; CHECK-NEXT: %3 = load volatile <8 x i16>, <8 x i16>* %2, align 32
8250 ; CHECK-NEXT: %4 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 8
8251 ; CHECK-NEXT: %5 = bitcast i16* %4 to <8 x i16>*
8252 ; CHECK-NEXT: %6 = load volatile <8 x i16>, <8 x i16>* %5, align 16
8253 ; CHECK-NEXT: %7 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 16
8254 ; CHECK-NEXT: %8 = load volatile i16, i16* %7, align 32
8255 ; CHECK-NEXT: %9 = insertelement <8 x i16> undef, i16 %8, i32 0
8256 ; CHECK-NEXT: %10 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 17
8257 ; CHECK-NEXT: %11 = load volatile i16, i16* %10, align 2
8258 ; CHECK-NEXT: %12 = insertelement <8 x i16> %9, i16 %11, i32 1
8259 ; CHECK-NEXT: %13 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 18
8260 ; CHECK-NEXT: %14 = load volatile i16, i16* %13, align 4
8261 ; CHECK-NEXT: %15 = insertelement <8 x i16> %12, i16 %14, i32 2
8262 ; CHECK-NEXT: %16 = getelementptr <20 x i16>, <20 x i16>* %0, i32 0, i32 19
8263 ; CHECK-NEXT: %17 = load volatile i16, i16* %16, align 2
8264 ; CHECK-NEXT: %18 = insertelement <8 x i16> %15, i16 %17, i32 3
8265 ; CHECK-NEXT: ret i32 0
8266 ; CHECK-NEXT: }
8267
8268 define i32 @volatile_load_from_20xi32_align_32(<20 x i32>*) {
8269 entry:
8270 %1 = load volatile <20 x i32>, <20 x i32>* %0, align 32
8271 ret i32 0
8272 }
8273 ; CHECK-LABEL: define i32 @volatile_load_from_20xi32_align_32(<20 x i32>*) {
8274 ; CHECK: entry:
8275 ; CHECK-NEXT: %1 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 0
8276 ; CHECK-NEXT: %2 = bitcast i32* %1 to <4 x i32>*
8277 ; CHECK-NEXT: %3 = load volatile <4 x i32>, <4 x i32>* %2, align 32
8278 ; CHECK-NEXT: %4 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 4
8279 ; CHECK-NEXT: %5 = bitcast i32* %4 to <4 x i32>*
8280 ; CHECK-NEXT: %6 = load volatile <4 x i32>, <4 x i32>* %5, align 16
8281 ; CHECK-NEXT: %7 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 8
8282 ; CHECK-NEXT: %8 = bitcast i32* %7 to <4 x i32>*
8283 ; CHECK-NEXT: %9 = load volatile <4 x i32>, <4 x i32>* %8, align 32
8284 ; CHECK-NEXT: %10 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 12
8285 ; CHECK-NEXT: %11 = bitcast i32* %10 to <4 x i32>*
8286 ; CHECK-NEXT: %12 = load volatile <4 x i32>, <4 x i32>* %11, align 16
8287 ; CHECK-NEXT: %13 = getelementptr <20 x i32>, <20 x i32>* %0, i32 0, i32 16
8288 ; CHECK-NEXT: %14 = bitcast i32* %13 to <4 x i32>*
8289 ; CHECK-NEXT: %15 = load volatile <4 x i32>, <4 x i32>* %14, align 32
8290 ; CHECK-NEXT: ret i32 0
8291 ; CHECK-NEXT: }
8292
8293 define i32 @volatile_load_from_20xi64_align_32(<20 x i64>*) {
8294 entry:
8295 %1 = load volatile <20 x i64>, <20 x i64>* %0, align 32
8296 ret i32 0
8297 }
8298 ; CHECK-LABEL: define i32 @volatile_load_from_20xi64_align_32(<20 x i64>*) {
8299 ; CHECK: entry:
8300 ; CHECK-NEXT: %1 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 0
8301 ; CHECK-NEXT: %2 = bitcast i64* %1 to <2 x i64>*
8302 ; CHECK-NEXT: %3 = load volatile <2 x i64>, <2 x i64>* %2, align 32
8303 ; CHECK-NEXT: %4 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 2
8304 ; CHECK-NEXT: %5 = bitcast i64* %4 to <2 x i64>*
8305 ; CHECK-NEXT: %6 = load volatile <2 x i64>, <2 x i64>* %5, align 16
8306 ; CHECK-NEXT: %7 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 4
8307 ; CHECK-NEXT: %8 = bitcast i64* %7 to <2 x i64>*
8308 ; CHECK-NEXT: %9 = load volatile <2 x i64>, <2 x i64>* %8, align 32
8309 ; CHECK-NEXT: %10 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 6
8310 ; CHECK-NEXT: %11 = bitcast i64* %10 to <2 x i64>*
8311 ; CHECK-NEXT: %12 = load volatile <2 x i64>, <2 x i64>* %11, align 16
8312 ; CHECK-NEXT: %13 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 8
8313 ; CHECK-NEXT: %14 = bitcast i64* %13 to <2 x i64>*
8314 ; CHECK-NEXT: %15 = load volatile <2 x i64>, <2 x i64>* %14, align 32
8315 ; CHECK-NEXT: %16 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 10
8316 ; CHECK-NEXT: %17 = bitcast i64* %16 to <2 x i64>*
8317 ; CHECK-NEXT: %18 = load volatile <2 x i64>, <2 x i64>* %17, align 16
8318 ; CHECK-NEXT: %19 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 12
8319 ; CHECK-NEXT: %20 = bitcast i64* %19 to <2 x i64>*
8320 ; CHECK-NEXT: %21 = load volatile <2 x i64>, <2 x i64>* %20, align 32
8321 ; CHECK-NEXT: %22 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 14
8322 ; CHECK-NEXT: %23 = bitcast i64* %22 to <2 x i64>*
8323 ; CHECK-NEXT: %24 = load volatile <2 x i64>, <2 x i64>* %23, align 16
8324 ; CHECK-NEXT: %25 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 16
8325 ; CHECK-NEXT: %26 = bitcast i64* %25 to <2 x i64>*
8326 ; CHECK-NEXT: %27 = load volatile <2 x i64>, <2 x i64>* %26, align 32
8327 ; CHECK-NEXT: %28 = getelementptr <20 x i64>, <20 x i64>* %0, i32 0, i32 18
8328 ; CHECK-NEXT: %29 = bitcast i64* %28 to <2 x i64>*
8329 ; CHECK-NEXT: %30 = load volatile <2 x i64>, <2 x i64>* %29, align 16
8330 ; CHECK-NEXT: ret i32 0
8331 ; CHECK-NEXT: }
8332
8333 define i32 @volatile_load_from_20xi8ptr_align_32(<20 x i8*>*) {
8334 entry:
8335 %1 = load volatile <20 x i8*>, <20 x i8*>* %0, align 32
8336 ret i32 0
8337 }
8338 ; CHECK-LABEL: define i32 @volatile_load_from_20xi8ptr_align_32(<20 x i8*>*) {
8339 ; CHECK: entry:
8340 ; CHECK-NEXT: %1 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 0
8341 ; CHECK-NEXT: %2 = bitcast i8** %1 to <4 x i8*>*
8342 ; CHECK-NEXT: %3 = load volatile <4 x i8*>, <4 x i8*>* %2, align 32
8343 ; CHECK-NEXT: %4 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 4
8344 ; CHECK-NEXT: %5 = bitcast i8** %4 to <4 x i8*>*
8345 ; CHECK-NEXT: %6 = load volatile <4 x i8*>, <4 x i8*>* %5, align 16
8346 ; CHECK-NEXT: %7 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 8
8347 ; CHECK-NEXT: %8 = bitcast i8** %7 to <4 x i8*>*
8348 ; CHECK-NEXT: %9 = load volatile <4 x i8*>, <4 x i8*>* %8, align 32
8349 ; CHECK-NEXT: %10 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 12
8350 ; CHECK-NEXT: %11 = bitcast i8** %10 to <4 x i8*>*
8351 ; CHECK-NEXT: %12 = load volatile <4 x i8*>, <4 x i8*>* %11, align 16
8352 ; CHECK-NEXT: %13 = getelementptr <20 x i8*>, <20 x i8*>* %0, i32 0, i32 16
8353 ; CHECK-NEXT: %14 = bitcast i8** %13 to <4 x i8*>*
8354 ; CHECK-NEXT: %15 = load volatile <4 x i8*>, <4 x i8*>* %14, align 32
8355 ; CHECK-NEXT: ret i32 0
8356 ; CHECK-NEXT: }
8357
8358 define i32 @volatile_load_from_20xfloat_align_32(<20 x float>*) {
8359 entry:
8360 %1 = load volatile <20 x float>, <20 x float>* %0, align 32
8361 ret i32 0
8362 }
8363 ; CHECK-LABEL: define i32 @volatile_load_from_20xfloat_align_32(<20 x float>*) {
8364 ; CHECK: entry:
8365 ; CHECK-NEXT: %1 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 0
8366 ; CHECK-NEXT: %2 = bitcast float* %1 to <4 x float>*
8367 ; CHECK-NEXT: %3 = load volatile <4 x float>, <4 x float>* %2, align 32
8368 ; CHECK-NEXT: %4 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 4
8369 ; CHECK-NEXT: %5 = bitcast float* %4 to <4 x float>*
8370 ; CHECK-NEXT: %6 = load volatile <4 x float>, <4 x float>* %5, align 16
8371 ; CHECK-NEXT: %7 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 8
8372 ; CHECK-NEXT: %8 = bitcast float* %7 to <4 x float>*
8373 ; CHECK-NEXT: %9 = load volatile <4 x float>, <4 x float>* %8, align 32
8374 ; CHECK-NEXT: %10 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 12
8375 ; CHECK-NEXT: %11 = bitcast float* %10 to <4 x float>*
8376 ; CHECK-NEXT: %12 = load volatile <4 x float>, <4 x float>* %11, align 16
8377 ; CHECK-NEXT: %13 = getelementptr <20 x float>, <20 x float>* %0, i32 0, i32 16
8378 ; CHECK-NEXT: %14 = bitcast float* %13 to <4 x float>*
8379 ; CHECK-NEXT: %15 = load volatile <4 x float>, <4 x float>* %14, align 32
8380 ; CHECK-NEXT: ret i32 0
8381 ; CHECK-NEXT: }
8382
8383 define i32 @volatile_load_from_20xdouble_align_32(<20 x double>*) {
8384 entry:
8385 %1 = load volatile <20 x double>, <20 x double>* %0, align 32
8386 ret i32 0
8387 }
8388 ; CHECK-LABEL: define i32 @volatile_load_from_20xdouble_align_32(<20 x double>*) {
8389 ; CHECK: entry:
8390 ; CHECK-NEXT: %1 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 0
8391 ; CHECK-NEXT: %2 = bitcast double* %1 to <2 x double>*
8392 ; CHECK-NEXT: %3 = load volatile <2 x double>, <2 x double>* %2, align 32
8393 ; CHECK-NEXT: %4 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 2
8394 ; CHECK-NEXT: %5 = bitcast double* %4 to <2 x double>*
8395 ; CHECK-NEXT: %6 = load volatile <2 x double>, <2 x double>* %5, align 16
8396 ; CHECK-NEXT: %7 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i32 4
8397 ; CHECK-NEXT: %8 = bitcast double* %7 to <2 x double>*
8398 ; CHECK-NEXT: %9 = load volatile <2 x double>, <2 x double>* %8, align 32
8399 ; CHECK-NEXT: %10 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 6
8400 ; CHECK-NEXT: %11 = bitcast double* %10 to <2 x double>*
8401 ; CHECK-NEXT: %12 = load volatile <2 x double>, <2 x double>* %11, align 16
8402 ; CHECK-NEXT: %13 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 8
8403 ; CHECK-NEXT: %14 = bitcast double* %13 to <2 x double>*
8404 ; CHECK-NEXT: %15 = load volatile <2 x double>, <2 x double>* %14, align 32
8405 ; CHECK-NEXT: %16 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 10
8406 ; CHECK-NEXT: %17 = bitcast double* %16 to <2 x double>*
8407 ; CHECK-NEXT: %18 = load volatile <2 x double>, <2 x double>* %17, align 16
8408 ; CHECK-NEXT: %19 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 12
8409 ; CHECK-NEXT: %20 = bitcast double* %19 to <2 x double>*
8410 ; CHECK-NEXT: %21 = load volatile <2 x double>, <2 x double>* %20, align 32
8411 ; CHECK-NEXT: %22 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 14
8412 ; CHECK-NEXT: %23 = bitcast double* %22 to <2 x double>*
8413 ; CHECK-NEXT: %24 = load volatile <2 x double>, <2 x double>* %23, align 16
8414 ; CHECK-NEXT: %25 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 16
8415 ; CHECK-NEXT: %26 = bitcast double* %25 to <2 x double>*
8416 ; CHECK-NEXT: %27 = load volatile <2 x double>, <2 x double>* %26, align 32
8417 ; CHECK-NEXT: %28 = getelementptr <20 x double>, <20 x double>* %0, i32 0, i3 2 18
8418 ; CHECK-NEXT: %29 = bitcast double* %28 to <2 x double>*
8419 ; CHECK-NEXT: %30 = load volatile <2 x double>, <2 x double>* %29, align 16
8420 ; CHECK-NEXT: ret i32 0
8421 ; CHECK-NEXT: }
8422
OLDNEW
« no previous file with comments | « test/Transforms/NaCl/vector-canonicalization-inserts.ll ('k') | test/Transforms/NaCl/vector-canonicalization-phis.ll » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698