1; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -mattr=+unimplemented-simd128 | FileCheck %s
2
3; Test loads and stores with custom alignment values.
4
5target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
6target triple = "wasm32-unknown-unknown"
7
8; ==============================================================================
9; 16 x i8
10; ==============================================================================
11
12; CHECK-LABEL: load_v16i8_a1:
13; CHECK-NEXT: .functype load_v16i8_a1 (i32) -> (v128){{$}}
14; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
15; CHECK-NEXT: return $pop[[R]]{{$}}
16define <16 x i8> @load_v16i8_a1(<16 x i8> *%p) {
17  %v = load <16 x i8>, <16 x i8>* %p, align 1
18  ret <16 x i8> %v
19}
20
21; CHECK-LABEL: load_v16i8_a4:
22; CHECK-NEXT: .functype load_v16i8_a4 (i32) -> (v128){{$}}
23; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
24; CHECK-NEXT: return $pop[[R]]{{$}}
25define <16 x i8> @load_v16i8_a4(<16 x i8> *%p) {
26  %v = load <16 x i8>, <16 x i8>* %p, align 4
27  ret <16 x i8> %v
28}
29
30; 16 is the default alignment for v128 so no attribute is needed.
31
32; CHECK-LABEL: load_v16i8_a16:
33; CHECK-NEXT: .functype load_v16i8_a16 (i32) -> (v128){{$}}
34; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
35; CHECK-NEXT: return $pop[[R]]{{$}}
36define <16 x i8> @load_v16i8_a16(<16 x i8> *%p) {
37  %v = load <16 x i8>, <16 x i8>* %p, align 16
38  ret <16 x i8> %v
39}
40
41; 32 is greater than the default alignment so it is ignored.
42
43; CHECK-LABEL: load_v16i8_a32:
44; CHECK-NEXT: .functype load_v16i8_a32 (i32) -> (v128){{$}}
45; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
46; CHECK-NEXT: return $pop[[R]]{{$}}
47define <16 x i8> @load_v16i8_a32(<16 x i8> *%p) {
48  %v = load <16 x i8>, <16 x i8>* %p, align 32
49  ret <16 x i8> %v
50}
51
52; CHECK-LABEL: store_v16i8_a1:
53; CHECK-NEXT: .functype store_v16i8_a1 (i32, v128) -> (){{$}}
54; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
55; CHECK-NEXT: return{{$}}
56define void @store_v16i8_a1(<16 x i8> *%p, <16 x i8> %v) {
57  store <16 x i8> %v, <16 x i8>* %p, align 1
58  ret void
59}
60
61; CHECK-LABEL: store_v16i8_a4:
62; CHECK-NEXT: .functype store_v16i8_a4 (i32, v128) -> (){{$}}
63; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
64; CHECK-NEXT: return{{$}}
65define void @store_v16i8_a4(<16 x i8> *%p, <16 x i8> %v) {
66  store <16 x i8> %v, <16 x i8>* %p, align 4
67  ret void
68}
69
70; 16 is the default alignment for v128 so no attribute is needed.
71
72; CHECK-LABEL: store_v16i8_a16:
73; CHECK-NEXT: .functype store_v16i8_a16 (i32, v128) -> (){{$}}
74; CHECK-NEXT: v128.store 0($0), $1{{$}}
75; CHECK-NEXT: return{{$}}
76define void @store_v16i8_a16(<16 x i8> *%p, <16 x i8> %v) {
77  store <16 x i8> %v, <16 x i8>* %p, align 16
78  ret void
79}
80
81; 32 is greater than the default alignment so it is ignored.
82
83; CHECK-LABEL: store_v16i8_a32:
84; CHECK-NEXT: .functype store_v16i8_a32 (i32, v128) -> (){{$}}
85; CHECK-NEXT: v128.store 0($0), $1{{$}}
86; CHECK-NEXT: return{{$}}
87define void @store_v16i8_a32(<16 x i8> *%p, <16 x i8> %v) {
88  store <16 x i8> %v, <16 x i8>* %p, align 32
89  ret void
90}
91
92; ==============================================================================
93; 8 x i16
94; ==============================================================================
95
96; CHECK-LABEL: load_v8i16_a1:
97; CHECK-NEXT: .functype load_v8i16_a1 (i32) -> (v128){{$}}
98; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
99; CHECK-NEXT: return $pop[[R]]{{$}}
100define <8 x i16> @load_v8i16_a1(<8 x i16> *%p) {
101  %v = load <8 x i16>, <8 x i16>* %p, align 1
102  ret <8 x i16> %v
103}
104
105; CHECK-LABEL: load_v8i16_a4:
106; CHECK-NEXT: .functype load_v8i16_a4 (i32) -> (v128){{$}}
107; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
108; CHECK-NEXT: return $pop[[R]]{{$}}
109define <8 x i16> @load_v8i16_a4(<8 x i16> *%p) {
110  %v = load <8 x i16>, <8 x i16>* %p, align 4
111  ret <8 x i16> %v
112}
113
114; 8 is the default alignment for v128 so no attribute is needed.
115
116; CHECK-LABEL: load_v8i16_a16:
117; CHECK-NEXT: .functype load_v8i16_a16 (i32) -> (v128){{$}}
118; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
119; CHECK-NEXT: return $pop[[R]]{{$}}
120define <8 x i16> @load_v8i16_a16(<8 x i16> *%p) {
121  %v = load <8 x i16>, <8 x i16>* %p, align 16
122  ret <8 x i16> %v
123}
124
125; 32 is greater than the default alignment so it is ignored.
126
127; CHECK-LABEL: load_v8i16_a32:
128; CHECK-NEXT: .functype load_v8i16_a32 (i32) -> (v128){{$}}
129; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
130; CHECK-NEXT: return $pop[[R]]{{$}}
131define <8 x i16> @load_v8i16_a32(<8 x i16> *%p) {
132  %v = load <8 x i16>, <8 x i16>* %p, align 32
133  ret <8 x i16> %v
134}
135
136; CHECK-LABEL: store_v8i16_a1:
137; CHECK-NEXT: .functype store_v8i16_a1 (i32, v128) -> (){{$}}
138; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
139; CHECK-NEXT: return{{$}}
140define void @store_v8i16_a1(<8 x i16> *%p, <8 x i16> %v) {
141  store <8 x i16> %v, <8 x i16>* %p, align 1
142  ret void
143}
144
145; CHECK-LABEL: store_v8i16_a4:
146; CHECK-NEXT: .functype store_v8i16_a4 (i32, v128) -> (){{$}}
147; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
148; CHECK-NEXT: return{{$}}
149define void @store_v8i16_a4(<8 x i16> *%p, <8 x i16> %v) {
150  store <8 x i16> %v, <8 x i16>* %p, align 4
151  ret void
152}
153
154; 16 is the default alignment for v128 so no attribute is needed.
155
156; CHECK-LABEL: store_v8i16_a16:
157; CHECK-NEXT: .functype store_v8i16_a16 (i32, v128) -> (){{$}}
158; CHECK-NEXT: v128.store 0($0), $1{{$}}
159; CHECK-NEXT: return{{$}}
160define void @store_v8i16_a16(<8 x i16> *%p, <8 x i16> %v) {
161  store <8 x i16> %v, <8 x i16>* %p, align 16
162  ret void
163}
164
165; 32 is greater than the default alignment so it is ignored.
166
167; CHECK-LABEL: store_v8i16_a32:
168; CHECK-NEXT: .functype store_v8i16_a32 (i32, v128) -> (){{$}}
169; CHECK-NEXT: v128.store 0($0), $1{{$}}
170; CHECK-NEXT: return{{$}}
171define void @store_v8i16_a32(<8 x i16> *%p, <8 x i16> %v) {
172  store <8 x i16> %v, <8 x i16>* %p, align 32
173  ret void
174}
175
176; ==============================================================================
177; 4 x i32
178; ==============================================================================
179
180; CHECK-LABEL: load_v4i32_a1:
181; CHECK-NEXT: .functype load_v4i32_a1 (i32) -> (v128){{$}}
182; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
183; CHECK-NEXT: return $pop[[R]]{{$}}
184define <4 x i32> @load_v4i32_a1(<4 x i32> *%p) {
185  %v = load <4 x i32>, <4 x i32>* %p, align 1
186  ret <4 x i32> %v
187}
188
189; CHECK-LABEL: load_v4i32_a4:
190; CHECK-NEXT: .functype load_v4i32_a4 (i32) -> (v128){{$}}
191; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
192; CHECK-NEXT: return $pop[[R]]{{$}}
193define <4 x i32> @load_v4i32_a4(<4 x i32> *%p) {
194  %v = load <4 x i32>, <4 x i32>* %p, align 4
195  ret <4 x i32> %v
196}
197
198; 4 is the default alignment for v128 so no attribute is needed.
199
200; CHECK-LABEL: load_v4i32_a16:
201; CHECK-NEXT: .functype load_v4i32_a16 (i32) -> (v128){{$}}
202; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
203; CHECK-NEXT: return $pop[[R]]{{$}}
204define <4 x i32> @load_v4i32_a16(<4 x i32> *%p) {
205  %v = load <4 x i32>, <4 x i32>* %p, align 16
206  ret <4 x i32> %v
207}
208
209; 32 is greater than the default alignment so it is ignored.
210
211; CHECK-LABEL: load_v4i32_a32:
212; CHECK-NEXT: .functype load_v4i32_a32 (i32) -> (v128){{$}}
213; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
214; CHECK-NEXT: return $pop[[R]]{{$}}
215define <4 x i32> @load_v4i32_a32(<4 x i32> *%p) {
216  %v = load <4 x i32>, <4 x i32>* %p, align 32
217  ret <4 x i32> %v
218}
219
220; CHECK-LABEL: store_v4i32_a1:
221; CHECK-NEXT: .functype store_v4i32_a1 (i32, v128) -> (){{$}}
222; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
223; CHECK-NEXT: return{{$}}
224define void @store_v4i32_a1(<4 x i32> *%p, <4 x i32> %v) {
225  store <4 x i32> %v, <4 x i32>* %p, align 1
226  ret void
227}
228
229; CHECK-LABEL: store_v4i32_a4:
230; CHECK-NEXT: .functype store_v4i32_a4 (i32, v128) -> (){{$}}
231; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
232; CHECK-NEXT: return{{$}}
233define void @store_v4i32_a4(<4 x i32> *%p, <4 x i32> %v) {
234  store <4 x i32> %v, <4 x i32>* %p, align 4
235  ret void
236}
237
238; 16 is the default alignment for v128 so no attribute is needed.
239
240; CHECK-LABEL: store_v4i32_a16:
241; CHECK-NEXT: .functype store_v4i32_a16 (i32, v128) -> (){{$}}
242; CHECK-NEXT: v128.store 0($0), $1{{$}}
243; CHECK-NEXT: return{{$}}
244define void @store_v4i32_a16(<4 x i32> *%p, <4 x i32> %v) {
245  store <4 x i32> %v, <4 x i32>* %p, align 16
246  ret void
247}
248
249; 32 is greater than the default alignment so it is ignored.
250
251; CHECK-LABEL: store_v4i32_a32:
252; CHECK-NEXT: .functype store_v4i32_a32 (i32, v128) -> (){{$}}
253; CHECK-NEXT: v128.store 0($0), $1{{$}}
254; CHECK-NEXT: return{{$}}
255define void @store_v4i32_a32(<4 x i32> *%p, <4 x i32> %v) {
256  store <4 x i32> %v, <4 x i32>* %p, align 32
257  ret void
258}
259
260; ==============================================================================
261; 2 x i64
262; ==============================================================================
263
264; CHECK-LABEL: load_v2i64_a1:
265; CHECK-NEXT: .functype load_v2i64_a1 (i32) -> (v128){{$}}
266; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
267; CHECK-NEXT: return $pop[[R]]{{$}}
268define <2 x i64> @load_v2i64_a1(<2 x i64> *%p) {
269  %v = load <2 x i64>, <2 x i64>* %p, align 1
270  ret <2 x i64> %v
271}
272
273; CHECK-LABEL: load_v2i64_a4:
274; CHECK-NEXT: .functype load_v2i64_a4 (i32) -> (v128){{$}}
275; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
276; CHECK-NEXT: return $pop[[R]]{{$}}
277define <2 x i64> @load_v2i64_a4(<2 x i64> *%p) {
278  %v = load <2 x i64>, <2 x i64>* %p, align 4
279  ret <2 x i64> %v
280}
281
282; 2 is the default alignment for v128 so no attribute is needed.
283
284; CHECK-LABEL: load_v2i64_a16:
285; CHECK-NEXT: .functype load_v2i64_a16 (i32) -> (v128){{$}}
286; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
287; CHECK-NEXT: return $pop[[R]]{{$}}
288define <2 x i64> @load_v2i64_a16(<2 x i64> *%p) {
289  %v = load <2 x i64>, <2 x i64>* %p, align 16
290  ret <2 x i64> %v
291}
292
293; 32 is greater than the default alignment so it is ignored.
294
295; CHECK-LABEL: load_v2i64_a32:
296; CHECK-NEXT: .functype load_v2i64_a32 (i32) -> (v128){{$}}
297; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
298; CHECK-NEXT: return $pop[[R]]{{$}}
299define <2 x i64> @load_v2i64_a32(<2 x i64> *%p) {
300  %v = load <2 x i64>, <2 x i64>* %p, align 32
301  ret <2 x i64> %v
302}
303
304; CHECK-LABEL: store_v2i64_a1:
305; CHECK-NEXT: .functype store_v2i64_a1 (i32, v128) -> (){{$}}
306; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
307; CHECK-NEXT: return{{$}}
308define void @store_v2i64_a1(<2 x i64> *%p, <2 x i64> %v) {
309  store <2 x i64> %v, <2 x i64>* %p, align 1
310  ret void
311}
312
313; CHECK-LABEL: store_v2i64_a4:
314; CHECK-NEXT: .functype store_v2i64_a4 (i32, v128) -> (){{$}}
315; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
316; CHECK-NEXT: return{{$}}
317define void @store_v2i64_a4(<2 x i64> *%p, <2 x i64> %v) {
318  store <2 x i64> %v, <2 x i64>* %p, align 4
319  ret void
320}
321
322; 16 is the default alignment for v128 so no attribute is needed.
323
324; CHECK-LABEL: store_v2i64_a16:
325; CHECK-NEXT: .functype store_v2i64_a16 (i32, v128) -> (){{$}}
326; CHECK-NEXT: v128.store 0($0), $1{{$}}
327; CHECK-NEXT: return{{$}}
328define void @store_v2i64_a16(<2 x i64> *%p, <2 x i64> %v) {
329  store <2 x i64> %v, <2 x i64>* %p, align 16
330  ret void
331}
332
333; 32 is greater than the default alignment so it is ignored.
334
335; CHECK-LABEL: store_v2i64_a32:
336; CHECK-NEXT: .functype store_v2i64_a32 (i32, v128) -> (){{$}}
337; CHECK-NEXT: v128.store 0($0), $1{{$}}
338; CHECK-NEXT: return{{$}}
339define void @store_v2i64_a32(<2 x i64> *%p, <2 x i64> %v) {
340  store <2 x i64> %v, <2 x i64>* %p, align 32
341  ret void
342}
343
344; ==============================================================================
345; 4 x float
346; ==============================================================================
347
348; CHECK-LABEL: load_v4f32_a1:
349; CHECK-NEXT: .functype load_v4f32_a1 (i32) -> (v128){{$}}
350; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
351; CHECK-NEXT: return $pop[[R]]{{$}}
352define <4 x float> @load_v4f32_a1(<4 x float> *%p) {
353  %v = load <4 x float>, <4 x float>* %p, align 1
354  ret <4 x float> %v
355}
356
357; CHECK-LABEL: load_v4f32_a4:
358; CHECK-NEXT: .functype load_v4f32_a4 (i32) -> (v128){{$}}
359; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
360; CHECK-NEXT: return $pop[[R]]{{$}}
361define <4 x float> @load_v4f32_a4(<4 x float> *%p) {
362  %v = load <4 x float>, <4 x float>* %p, align 4
363  ret <4 x float> %v
364}
365
366; 4 is the default alignment for v128 so no attribute is needed.
367
368; CHECK-LABEL: load_v4f32_a16:
369; CHECK-NEXT: .functype load_v4f32_a16 (i32) -> (v128){{$}}
370; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
371; CHECK-NEXT: return $pop[[R]]{{$}}
372define <4 x float> @load_v4f32_a16(<4 x float> *%p) {
373  %v = load <4 x float>, <4 x float>* %p, align 16
374  ret <4 x float> %v
375}
376
377; 32 is greater than the default alignment so it is ignored.
378
379; CHECK-LABEL: load_v4f32_a32:
380; CHECK-NEXT: .functype load_v4f32_a32 (i32) -> (v128){{$}}
381; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
382; CHECK-NEXT: return $pop[[R]]{{$}}
383define <4 x float> @load_v4f32_a32(<4 x float> *%p) {
384  %v = load <4 x float>, <4 x float>* %p, align 32
385  ret <4 x float> %v
386}
387
388; CHECK-LABEL: store_v4f32_a1:
389; CHECK-NEXT: .functype store_v4f32_a1 (i32, v128) -> (){{$}}
390; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
391; CHECK-NEXT: return{{$}}
392define void @store_v4f32_a1(<4 x float> *%p, <4 x float> %v) {
393  store <4 x float> %v, <4 x float>* %p, align 1
394  ret void
395}
396
397; CHECK-LABEL: store_v4f32_a4:
398; CHECK-NEXT: .functype store_v4f32_a4 (i32, v128) -> (){{$}}
399; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
400; CHECK-NEXT: return{{$}}
401define void @store_v4f32_a4(<4 x float> *%p, <4 x float> %v) {
402  store <4 x float> %v, <4 x float>* %p, align 4
403  ret void
404}
405
406; 16 is the default alignment for v128 so no attribute is needed.
407
408; CHECK-LABEL: store_v4f32_a16:
409; CHECK-NEXT: .functype store_v4f32_a16 (i32, v128) -> (){{$}}
410; CHECK-NEXT: v128.store 0($0), $1{{$}}
411; CHECK-NEXT: return{{$}}
412define void @store_v4f32_a16(<4 x float> *%p, <4 x float> %v) {
413  store <4 x float> %v, <4 x float>* %p, align 16
414  ret void
415}
416
417; 32 is greater than the default alignment so it is ignored.
418
419; CHECK-LABEL: store_v4f32_a32:
420; CHECK-NEXT: .functype store_v4f32_a32 (i32, v128) -> (){{$}}
421; CHECK-NEXT: v128.store 0($0), $1{{$}}
422; CHECK-NEXT: return{{$}}
423define void @store_v4f32_a32(<4 x float> *%p, <4 x float> %v) {
424  store <4 x float> %v, <4 x float>* %p, align 32
425  ret void
426}
427
428; ==============================================================================
429; 2 x double
430; ==============================================================================
431
432; CHECK-LABEL: load_v2f64_a1:
433; CHECK-NEXT: .functype load_v2f64_a1 (i32) -> (v128){{$}}
434; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=0{{$}}
435; CHECK-NEXT: return $pop[[R]]{{$}}
436define <2 x double> @load_v2f64_a1(<2 x double> *%p) {
437  %v = load <2 x double>, <2 x double>* %p, align 1
438  ret <2 x double> %v
439}
440
441; CHECK-LABEL: load_v2f64_a4:
442; CHECK-NEXT: .functype load_v2f64_a4 (i32) -> (v128){{$}}
443; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0):p2align=2{{$}}
444; CHECK-NEXT: return $pop[[R]]{{$}}
445define <2 x double> @load_v2f64_a4(<2 x double> *%p) {
446  %v = load <2 x double>, <2 x double>* %p, align 4
447  ret <2 x double> %v
448}
449
450; 2 is the default alignment for v128 so no attribute is needed.
451
452; CHECK-LABEL: load_v2f64_a16:
453; CHECK-NEXT: .functype load_v2f64_a16 (i32) -> (v128){{$}}
454; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
455; CHECK-NEXT: return $pop[[R]]{{$}}
456define <2 x double> @load_v2f64_a16(<2 x double> *%p) {
457  %v = load <2 x double>, <2 x double>* %p, align 16
458  ret <2 x double> %v
459}
460
461; 32 is greater than the default alignment so it is ignored.
462
463; CHECK-LABEL: load_v2f64_a32:
464; CHECK-NEXT: .functype load_v2f64_a32 (i32) -> (v128){{$}}
465; CHECK-NEXT: v128.load $push[[R:[0-9]+]]=, 0($0){{$}}
466; CHECK-NEXT: return $pop[[R]]{{$}}
467define <2 x double> @load_v2f64_a32(<2 x double> *%p) {
468  %v = load <2 x double>, <2 x double>* %p, align 32
469  ret <2 x double> %v
470}
471
472; CHECK-LABEL: store_v2f64_a1:
473; CHECK-NEXT: .functype store_v2f64_a1 (i32, v128) -> (){{$}}
474; CHECK-NEXT: v128.store 0($0):p2align=0, $1{{$}}
475; CHECK-NEXT: return{{$}}
476define void @store_v2f64_a1(<2 x double> *%p, <2 x double> %v) {
477  store <2 x double> %v, <2 x double>* %p, align 1
478  ret void
479}
480
481; CHECK-LABEL: store_v2f64_a4:
482; CHECK-NEXT: .functype store_v2f64_a4 (i32, v128) -> (){{$}}
483; CHECK-NEXT: v128.store 0($0):p2align=2, $1{{$}}
484; CHECK-NEXT: return{{$}}
485define void @store_v2f64_a4(<2 x double> *%p, <2 x double> %v) {
486  store <2 x double> %v, <2 x double>* %p, align 4
487  ret void
488}
489
490; 16 is the default alignment for v128 so no attribute is needed.
491
492; CHECK-LABEL: store_v2f64_a16:
493; CHECK-NEXT: .functype store_v2f64_a16 (i32, v128) -> (){{$}}
494; CHECK-NEXT: v128.store 0($0), $1{{$}}
495; CHECK-NEXT: return{{$}}
496define void @store_v2f64_a16(<2 x double> *%p, <2 x double> %v) {
497  store <2 x double> %v, <2 x double>* %p, align 16
498  ret void
499}
500
501; 32 is greater than the default alignment so it is ignored.
502
503; CHECK-LABEL: store_v2f64_a32:
504; CHECK-NEXT: .functype store_v2f64_a32 (i32, v128) -> (){{$}}
505; CHECK-NEXT: v128.store 0($0), $1{{$}}
506; CHECK-NEXT: return{{$}}
507define void @store_v2f64_a32(<2 x double> *%p, <2 x double> %v) {
508  store <2 x double> %v, <2 x double>* %p, align 32
509  ret void
510}
511