Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / d183d8c772b3029b0a5fbb219d7cfe27615004d9 / . / llvm / test / CodeGen / WebAssembly / offset-simd.ll
blob: fb78f6626a1665cd04d40e64cab52b0a1c123cc9 [file] [log] [blame]
Thomas Livelyd183d8c2018-08-30 21:36:48 +0000[diff] [blame^]1; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-keep-registers -wasm-disable-explicit-locals -wasm-enable-unimplemented-simd -mattr=+simd128,+sign-ext --show-mc-encoding | FileCheck %s --check-prefixes CHECK,SIMD128
2; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-keep-registers -wasm-disable-explicit-locals -mattr=+simd128,+sign-ext --show-mc-encoding | FileCheck %s --check-prefixes CHECK,SIMD128-VM
3; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-keep-registers -wasm-disable-explicit-locals -mattr=-simd128,+sign-ext --show-mc-encoding | FileCheck %s --check-prefixes CHECK,NO-SIMD128
4
5; Test SIMD loads and stores
6
7target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
8target triple = "wasm32-unknown-unknown"
9
10; ==============================================================================
11; 16 x i8
12; ==============================================================================
13; CHECK-LABEL: load_v16i8:
14; NO-SIMD128-NOT: v128
15; SIMD128: .param i32{{$}}
16; SIMD128: .result v128{{$}}
17; SIMD128: v128.load $push0=, 0($0):p2align=0
18; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
19; SIMD128: return $pop0 #
20define <16 x i8> @load_v16i8(<16 x i8>* %p) {
21 %v = load <16 x i8>, <16 x i8>* %p
22 ret <16 x i8> %v
23}
24
25; CHECK-LABEL: load_v16i8_with_folded_offset:
26; NO-SIMD128-NOT: v128
27; SIMD128: .param i32{{$}}
28; SIMD128: .result v128{{$}}
29; SIMD128: v128.load $push0=, 16($0):p2align=0
30; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
31; SIMD128: return $pop0 #
32define <16 x i8> @load_v16i8_with_folded_offset(<16 x i8>* %p) {
33 %q = ptrtoint <16 x i8>* %p to i32
34 %r = add nuw i32 %q, 16
35 %s = inttoptr i32 %r to <16 x i8>*
36 %v = load <16 x i8>, <16 x i8>* %s
37 ret <16 x i8> %v
38}
39
40; CHECK-LABEL: load_v16i8_with_folded_gep_offset:
41; NO-SIMD128-NOT: v128
42; SIMD128: .param i32{{$}}
43; SIMD128: .result v128{{$}}
44; SIMD128: v128.load $push0=, 16($0):p2align=0
45; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
46; SIMD128: return $pop0 #
47define <16 x i8> @load_v16i8_with_folded_gep_offset(<16 x i8>* %p) {
48 %s = getelementptr inbounds <16 x i8>, <16 x i8>* %p, i32 1
49 %v = load <16 x i8>, <16 x i8>* %s
50 ret <16 x i8> %v
51}
52
53; CHECK-LABEL: load_v16i8_with_unfolded_gep_negative_offset:
54; NO-SIMD128-NOT: v128
55; SIMD128: .param i32{{$}}
56; SIMD128: .result v128{{$}}
57; SIMD128: i32.const $push0=, -16 #
58; SIMD128: i32.add $push1=, $0, $pop0 #
59; SIMD128: v128.load $push2=, 0($pop1):p2align=0
60; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
61; SIMD128: return $pop2 #
62define <16 x i8> @load_v16i8_with_unfolded_gep_negative_offset(<16 x i8>* %p) {
63 %s = getelementptr inbounds <16 x i8>, <16 x i8>* %p, i32 -1
64 %v = load <16 x i8>, <16 x i8>* %s
65 ret <16 x i8> %v
66}
67
68; CHECK-LABEL: load_v16i8_with_unfolded_offset:
69; NO-SIMD128-NOT: v128
70; SIMD128: .param i32{{$}}
71; SIMD128: .result v128{{$}}
72; SIMD128: i32.const $push0=, 16 #
73; SIMD128: i32.add $push1=, $0, $pop0 #
74; SIMD128: v128.load $push2=, 0($pop1):p2align=0
75; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
76; SIMD128: return $pop2 #
77define <16 x i8> @load_v16i8_with_unfolded_offset(<16 x i8>* %p) {
78 %q = ptrtoint <16 x i8>* %p to i32
79 %r = add nsw i32 %q, 16
80 %s = inttoptr i32 %r to <16 x i8>*
81 %v = load <16 x i8>, <16 x i8>* %s
82 ret <16 x i8> %v
83}
84
85; CHECK-LABEL: load_v16i8_with_unfolded_gep_offset:
86; NO-SIMD128-NOT: v128
87; SIMD128: .param i32{{$}}
88; SIMD128: .result v128{{$}}
89; SIMD128: i32.const $push0=, 16 #
90; SIMD128: i32.add $push1=, $0, $pop0 #
91; SIMD128: v128.load $push2=, 0($pop1):p2align=0
92; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
93; SIMD128: return $pop2 #
94define <16 x i8> @load_v16i8_with_unfolded_gep_offset(<16 x i8>* %p) {
95 %s = getelementptr <16 x i8>, <16 x i8>* %p, i32 1
96 %v = load <16 x i8>, <16 x i8>* %s
97 ret <16 x i8> %v
98}
99
100; CHECK-LABEL: load_v16i8_from_numeric_address:
101; NO-SIMD128-NOT: v128
102; SIMD128: .result v128{{$}}
103; SIMD128: i32.const $push0=, 0 #
104; SIMD128: v128.load $push1=, 32($pop0):p2align=0
105; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x20]{{$}}
106; SIMD128: return $pop1 #
107define <16 x i8> @load_v16i8_from_numeric_address() {
108 %s = inttoptr i32 32 to <16 x i8>*
109 %v = load <16 x i8>, <16 x i8>* %s
110 ret <16 x i8> %v
111}
112
113; CHECK-LABEL: load_v16i8_from_global_address:
114; NO-SIMD128-NOT: v128
115; SIMD128: .result v128{{$}}
116; SIMD128: i32.const $push0=, 0 #
117; SIMD128: v128.load $push1=, gv_v16i8($pop0):p2align=0
118; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,
119; SIMD128: return $pop1 #
120@gv_v16i8 = global <16 x i8> <i8 42, i8 42, i8 42, i8 42, i8 42, i8 42, i8 42, i8 42, i8 42, i8 42, i8 42, i8 42, i8 42, i8 42, i8 42, i8 42>
121define <16 x i8> @load_v16i8_from_global_address() {
122 %v = load <16 x i8>, <16 x i8>* @gv_v16i8
123 ret <16 x i8> %v
124}
125
126; CHECK-LABEL: store_v16i8:
127; NO-SIMD128-NOT: v128
128; SIMD128: .param v128, i32{{$}}
129; SIMD128: v128.store 0($1):p2align=0, $0
130; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
131define void @store_v16i8(<16 x i8> %v, <16 x i8>* %p) {
132 store <16 x i8> %v , <16 x i8>* %p
133 ret void
134}
135
136; CHECK-LABEL: store_v16i8_with_folded_offset:
137; NO-SIMD128-NOT: v128
138; SIMD128: .param v128, i32{{$}}
139; SIMD128: v128.store 16($1):p2align=0, $0
140; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
141define void @store_v16i8_with_folded_offset(<16 x i8> %v, <16 x i8>* %p) {
142 %q = ptrtoint <16 x i8>* %p to i32
143 %r = add nuw i32 %q, 16
144 %s = inttoptr i32 %r to <16 x i8>*
145 store <16 x i8> %v , <16 x i8>* %s
146 ret void
147}
148
149; CHECK-LABEL: store_v16i8_with_folded_gep_offset:
150; NO-SIMD128-NOT: v128
151; SIMD128: .param v128, i32{{$}}
152; SIMD128: v128.store 16($1):p2align=0, $0
153; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
154define void @store_v16i8_with_folded_gep_offset(<16 x i8> %v, <16 x i8>* %p) {
155 %s = getelementptr inbounds <16 x i8>, <16 x i8>* %p, i32 1
156 store <16 x i8> %v , <16 x i8>* %s
157 ret void
158}
159
160; CHECK-LABEL: store_v16i8_with_unfolded_gep_negative_offset:
161; NO-SIMD128-NOT: v128
162; SIMD128: .param v128, i32{{$}}
163; SIMD128: i32.const $push0=, -16 #
164; SIMD128: i32.add $push1=, $1, $pop0 #
165; SIMD128: v128.store 0($pop1):p2align=0, $0
166; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
167define void @store_v16i8_with_unfolded_gep_negative_offset(<16 x i8> %v, <16 x i8>* %p) {
168 %s = getelementptr inbounds <16 x i8>, <16 x i8>* %p, i32 -1
169 store <16 x i8> %v , <16 x i8>* %s
170 ret void
171}
172
173; CHECK-LABEL: store_v16i8_with_unfolded_offset:
174; NO-SIMD128-NOT: v128
175; SIMD128: .param v128, i32{{$}}
176; SIMD128: i32.const $push0=, -16 #
177; SIMD128: i32.add $push1=, $1, $pop0 #
178; SIMD128: v128.store 0($pop1):p2align=0, $0
179; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
180define void @store_v16i8_with_unfolded_offset(<16 x i8> %v, <16 x i8>* %p) {
181 %s = getelementptr inbounds <16 x i8>, <16 x i8>* %p, i32 -1
182 store <16 x i8> %v , <16 x i8>* %s
183 ret void
184}
185
186; CHECK-LABEL: store_v16i8_with_unfolded_gep_offset:
187; NO-SIMD128-NOT: v128
188; SIMD128: .param v128, i32{{$}}
189; SIMD128: i32.const $push0=, 16 #
190; SIMD128: i32.add $push1=, $1, $pop0 #
191; SIMD128: v128.store 0($pop1):p2align=0, $0
192; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
193define void @store_v16i8_with_unfolded_gep_offset(<16 x i8> %v, <16 x i8>* %p) {
194 %s = getelementptr <16 x i8>, <16 x i8>* %p, i32 1
195 store <16 x i8> %v , <16 x i8>* %s
196 ret void
197}
198
199; CHECK-LABEL: store_v16i8_to_numeric_address:
200; NO-SIMD128-NOT: v128
201; SIMD128: .param v128{{$}}
202; SIMD128: i32.const $push0=, 0 #
203; SIMD128: v128.store 32($pop0):p2align=0, $0
204; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x20]{{$}}
205define void @store_v16i8_to_numeric_address(<16 x i8> %v) {
206 %s = inttoptr i32 32 to <16 x i8>*
207 store <16 x i8> %v , <16 x i8>* %s
208 ret void
209}
210
211; CHECK-LABEL: store_v16i8_to_global_address:
212; NO-SIMD128-NOT: v128
213; SIMD128: .param v128{{$}}
214; SIMD128: i32.const $push0=, 0 #
215; SIMD128: v128.store gv_v16i8($pop0):p2align=0, $0
216; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,
217define void @store_v16i8_to_global_address(<16 x i8> %v) {
218 store <16 x i8> %v , <16 x i8>* @gv_v16i8
219 ret void
220}
221
222; ==============================================================================
223; 8 x i16
224; ==============================================================================
225; CHECK-LABEL: load_v8i16:
226; NO-SIMD128-NOT: v128
227; SIMD128: .param i32{{$}}
228; SIMD128: .result v128{{$}}
229; SIMD128: v128.load $push0=, 0($0):p2align=0
230; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
231; SIMD128: return $pop0 #
232define <8 x i16> @load_v8i16(<8 x i16>* %p) {
233 %v = load <8 x i16>, <8 x i16>* %p
234 ret <8 x i16> %v
235}
236
237; CHECK-LABEL: load_v8i16_with_folded_offset:
238; NO-SIMD128-NOT: v128
239; SIMD128: .param i32{{$}}
240; SIMD128: .result v128{{$}}
241; SIMD128: v128.load $push0=, 16($0):p2align=0
242; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
243; SIMD128: return $pop0 #
244define <8 x i16> @load_v8i16_with_folded_offset(<8 x i16>* %p) {
245 %q = ptrtoint <8 x i16>* %p to i32
246 %r = add nuw i32 %q, 16
247 %s = inttoptr i32 %r to <8 x i16>*
248 %v = load <8 x i16>, <8 x i16>* %s
249 ret <8 x i16> %v
250}
251
252; CHECK-LABEL: load_v8i16_with_folded_gep_offset:
253; NO-SIMD128-NOT: v128
254; SIMD128: .param i32{{$}}
255; SIMD128: .result v128{{$}}
256; SIMD128: v128.load $push0=, 16($0):p2align=0
257; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
258; SIMD128: return $pop0 #
259define <8 x i16> @load_v8i16_with_folded_gep_offset(<8 x i16>* %p) {
260 %s = getelementptr inbounds <8 x i16>, <8 x i16>* %p, i32 1
261 %v = load <8 x i16>, <8 x i16>* %s
262 ret <8 x i16> %v
263}
264
265; CHECK-LABEL: load_v8i16_with_unfolded_gep_negative_offset:
266; NO-SIMD128-NOT: v128
267; SIMD128: .param i32{{$}}
268; SIMD128: .result v128{{$}}
269; SIMD128: i32.const $push0=, -16 #
270; SIMD128: i32.add $push1=, $0, $pop0 #
271; SIMD128: v128.load $push2=, 0($pop1):p2align=0
272; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
273; SIMD128: return $pop2 #
274define <8 x i16> @load_v8i16_with_unfolded_gep_negative_offset(<8 x i16>* %p) {
275 %s = getelementptr inbounds <8 x i16>, <8 x i16>* %p, i32 -1
276 %v = load <8 x i16>, <8 x i16>* %s
277 ret <8 x i16> %v
278}
279
280; CHECK-LABEL: load_v8i16_with_unfolded_offset:
281; NO-SIMD128-NOT: v128
282; SIMD128: .param i32{{$}}
283; SIMD128: .result v128{{$}}
284; SIMD128: i32.const $push0=, 16 #
285; SIMD128: i32.add $push1=, $0, $pop0 #
286; SIMD128: v128.load $push2=, 0($pop1):p2align=0
287; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
288; SIMD128: return $pop2 #
289define <8 x i16> @load_v8i16_with_unfolded_offset(<8 x i16>* %p) {
290 %q = ptrtoint <8 x i16>* %p to i32
291 %r = add nsw i32 %q, 16
292 %s = inttoptr i32 %r to <8 x i16>*
293 %v = load <8 x i16>, <8 x i16>* %s
294 ret <8 x i16> %v
295}
296
297; CHECK-LABEL: load_v8i16_with_unfolded_gep_offset:
298; NO-SIMD128-NOT: v128
299; SIMD128: .param i32{{$}}
300; SIMD128: .result v128{{$}}
301; SIMD128: i32.const $push0=, 16 #
302; SIMD128: i32.add $push1=, $0, $pop0 #
303; SIMD128: v128.load $push2=, 0($pop1):p2align=0
304; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
305; SIMD128: return $pop2 #
306define <8 x i16> @load_v8i16_with_unfolded_gep_offset(<8 x i16>* %p) {
307 %s = getelementptr <8 x i16>, <8 x i16>* %p, i32 1
308 %v = load <8 x i16>, <8 x i16>* %s
309 ret <8 x i16> %v
310}
311
312; CHECK-LABEL: load_v8i16_from_numeric_address:
313; NO-SIMD128-NOT: v128
314; SIMD128: .result v128{{$}}
315; SIMD128: i32.const $push0=, 0 #
316; SIMD128: v128.load $push1=, 32($pop0):p2align=0
317; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x20]{{$}}
318; SIMD128: return $pop1 #
319define <8 x i16> @load_v8i16_from_numeric_address() {
320 %s = inttoptr i32 32 to <8 x i16>*
321 %v = load <8 x i16>, <8 x i16>* %s
322 ret <8 x i16> %v
323}
324
325; CHECK-LABEL: load_v8i16_from_global_address:
326; NO-SIMD128-NOT: v128
327; SIMD128: .result v128{{$}}
328; SIMD128: i32.const $push0=, 0 #
329; SIMD128: v128.load $push1=, gv_v8i16($pop0):p2align=0
330; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,
331; SIMD128: return $pop1 #
332@gv_v8i16 = global <8 x i16> <i16 42, i16 42, i16 42, i16 42, i16 42, i16 42, i16 42, i16 42>
333define <8 x i16> @load_v8i16_from_global_address() {
334 %v = load <8 x i16>, <8 x i16>* @gv_v8i16
335 ret <8 x i16> %v
336}
337
338; CHECK-LABEL: store_v8i16:
339; NO-SIMD128-NOT: v128
340; SIMD128: .param v128, i32{{$}}
341; SIMD128: v128.store 0($1):p2align=0, $0
342; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
343define void @store_v8i16(<8 x i16> %v, <8 x i16>* %p) {
344 store <8 x i16> %v , <8 x i16>* %p
345 ret void
346}
347
348; CHECK-LABEL: store_v8i16_with_folded_offset:
349; NO-SIMD128-NOT: v128
350; SIMD128: .param v128, i32{{$}}
351; SIMD128: v128.store 16($1):p2align=0, $0
352; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
353define void @store_v8i16_with_folded_offset(<8 x i16> %v, <8 x i16>* %p) {
354 %q = ptrtoint <8 x i16>* %p to i32
355 %r = add nuw i32 %q, 16
356 %s = inttoptr i32 %r to <8 x i16>*
357 store <8 x i16> %v , <8 x i16>* %s
358 ret void
359}
360
361; CHECK-LABEL: store_v8i16_with_folded_gep_offset:
362; NO-SIMD128-NOT: v128
363; SIMD128: .param v128, i32{{$}}
364; SIMD128: v128.store 16($1):p2align=0, $0
365; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
366define void @store_v8i16_with_folded_gep_offset(<8 x i16> %v, <8 x i16>* %p) {
367 %s = getelementptr inbounds <8 x i16>, <8 x i16>* %p, i32 1
368 store <8 x i16> %v , <8 x i16>* %s
369 ret void
370}
371
372; CHECK-LABEL: store_v8i16_with_unfolded_gep_negative_offset:
373; NO-SIMD128-NOT: v128
374; SIMD128: .param v128, i32{{$}}
375; SIMD128: i32.const $push0=, -16 #
376; SIMD128: i32.add $push1=, $1, $pop0 #
377; SIMD128: v128.store 0($pop1):p2align=0, $0
378; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
379define void @store_v8i16_with_unfolded_gep_negative_offset(<8 x i16> %v, <8 x i16>* %p) {
380 %s = getelementptr inbounds <8 x i16>, <8 x i16>* %p, i32 -1
381 store <8 x i16> %v , <8 x i16>* %s
382 ret void
383}
384
385; CHECK-LABEL: store_v8i16_with_unfolded_offset:
386; NO-SIMD128-NOT: v128
387; SIMD128: .param v128, i32{{$}}
388; SIMD128: i32.const $push0=, -16 #
389; SIMD128: i32.add $push1=, $1, $pop0 #
390; SIMD128: v128.store 0($pop1):p2align=0, $0
391; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
392define void @store_v8i16_with_unfolded_offset(<8 x i16> %v, <8 x i16>* %p) {
393 %s = getelementptr inbounds <8 x i16>, <8 x i16>* %p, i32 -1
394 store <8 x i16> %v , <8 x i16>* %s
395 ret void
396}
397
398; CHECK-LABEL: store_v8i16_with_unfolded_gep_offset:
399; NO-SIMD128-NOT: v128
400; SIMD128: .param v128, i32{{$}}
401; SIMD128: i32.const $push0=, 16 #
402; SIMD128: i32.add $push1=, $1, $pop0 #
403; SIMD128: v128.store 0($pop1):p2align=0, $0
404; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
405define void @store_v8i16_with_unfolded_gep_offset(<8 x i16> %v, <8 x i16>* %p) {
406 %s = getelementptr <8 x i16>, <8 x i16>* %p, i32 1
407 store <8 x i16> %v , <8 x i16>* %s
408 ret void
409}
410
411; CHECK-LABEL: store_v8i16_to_numeric_address:
412; NO-SIMD128-NOT: v128
413; SIMD128: .param v128{{$}}
414; SIMD128: i32.const $push0=, 0 #
415; SIMD128: v128.store 32($pop0):p2align=0, $0
416; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x20]{{$}}
417define void @store_v8i16_to_numeric_address(<8 x i16> %v) {
418 %s = inttoptr i32 32 to <8 x i16>*
419 store <8 x i16> %v , <8 x i16>* %s
420 ret void
421}
422
423; CHECK-LABEL: store_v8i16_to_global_address:
424; NO-SIMD128-NOT: v128
425; SIMD128: .param v128{{$}}
426; SIMD128: i32.const $push0=, 0 #
427; SIMD128: v128.store gv_v8i16($pop0):p2align=0, $0
428; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,
429define void @store_v8i16_to_global_address(<8 x i16> %v) {
430 store <8 x i16> %v , <8 x i16>* @gv_v8i16
431 ret void
432}
433
434; ==============================================================================
435; 4 x i32
436; ==============================================================================
437; CHECK-LABEL: load_v4i32:
438; NO-SIMD128-NOT: v128
439; SIMD128: .param i32{{$}}
440; SIMD128: .result v128{{$}}
441; SIMD128: v128.load $push0=, 0($0):p2align=0
442; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
443; SIMD128: return $pop0 #
444define <4 x i32> @load_v4i32(<4 x i32>* %p) {
445 %v = load <4 x i32>, <4 x i32>* %p
446 ret <4 x i32> %v
447}
448
449; CHECK-LABEL: load_v4i32_with_folded_offset:
450; NO-SIMD128-NOT: v128
451; SIMD128: .param i32{{$}}
452; SIMD128: .result v128{{$}}
453; SIMD128: v128.load $push0=, 16($0):p2align=0
454; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
455; SIMD128: return $pop0 #
456define <4 x i32> @load_v4i32_with_folded_offset(<4 x i32>* %p) {
457 %q = ptrtoint <4 x i32>* %p to i32
458 %r = add nuw i32 %q, 16
459 %s = inttoptr i32 %r to <4 x i32>*
460 %v = load <4 x i32>, <4 x i32>* %s
461 ret <4 x i32> %v
462}
463
464; CHECK-LABEL: load_v4i32_with_folded_gep_offset:
465; NO-SIMD128-NOT: v128
466; SIMD128: .param i32{{$}}
467; SIMD128: .result v128{{$}}
468; SIMD128: v128.load $push0=, 16($0):p2align=0
469; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
470; SIMD128: return $pop0 #
471define <4 x i32> @load_v4i32_with_folded_gep_offset(<4 x i32>* %p) {
472 %s = getelementptr inbounds <4 x i32>, <4 x i32>* %p, i32 1
473 %v = load <4 x i32>, <4 x i32>* %s
474 ret <4 x i32> %v
475}
476
477; CHECK-LABEL: load_v4i32_with_unfolded_gep_negative_offset:
478; NO-SIMD128-NOT: v128
479; SIMD128: .param i32{{$}}
480; SIMD128: .result v128{{$}}
481; SIMD128: i32.const $push0=, -16 #
482; SIMD128: i32.add $push1=, $0, $pop0 #
483; SIMD128: v128.load $push2=, 0($pop1):p2align=0
484; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
485; SIMD128: return $pop2 #
486define <4 x i32> @load_v4i32_with_unfolded_gep_negative_offset(<4 x i32>* %p) {
487 %s = getelementptr inbounds <4 x i32>, <4 x i32>* %p, i32 -1
488 %v = load <4 x i32>, <4 x i32>* %s
489 ret <4 x i32> %v
490}
491
492; CHECK-LABEL: load_v4i32_with_unfolded_offset:
493; NO-SIMD128-NOT: v128
494; SIMD128: .param i32{{$}}
495; SIMD128: .result v128{{$}}
496; SIMD128: i32.const $push0=, 16 #
497; SIMD128: i32.add $push1=, $0, $pop0 #
498; SIMD128: v128.load $push2=, 0($pop1):p2align=0
499; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
500; SIMD128: return $pop2 #
501define <4 x i32> @load_v4i32_with_unfolded_offset(<4 x i32>* %p) {
502 %q = ptrtoint <4 x i32>* %p to i32
503 %r = add nsw i32 %q, 16
504 %s = inttoptr i32 %r to <4 x i32>*
505 %v = load <4 x i32>, <4 x i32>* %s
506 ret <4 x i32> %v
507}
508
509; CHECK-LABEL: load_v4i32_with_unfolded_gep_offset:
510; NO-SIMD128-NOT: v128
511; SIMD128: .param i32{{$}}
512; SIMD128: .result v128{{$}}
513; SIMD128: i32.const $push0=, 16 #
514; SIMD128: i32.add $push1=, $0, $pop0 #
515; SIMD128: v128.load $push2=, 0($pop1):p2align=0
516; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
517; SIMD128: return $pop2 #
518define <4 x i32> @load_v4i32_with_unfolded_gep_offset(<4 x i32>* %p) {
519 %s = getelementptr <4 x i32>, <4 x i32>* %p, i32 1
520 %v = load <4 x i32>, <4 x i32>* %s
521 ret <4 x i32> %v
522}
523
524; CHECK-LABEL: load_v4i32_from_numeric_address:
525; NO-SIMD128-NOT: v128
526; SIMD128: .result v128{{$}}
527; SIMD128: i32.const $push0=, 0 #
528; SIMD128: v128.load $push1=, 32($pop0):p2align=0
529; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x20]{{$}}
530; SIMD128: return $pop1 #
531define <4 x i32> @load_v4i32_from_numeric_address() {
532 %s = inttoptr i32 32 to <4 x i32>*
533 %v = load <4 x i32>, <4 x i32>* %s
534 ret <4 x i32> %v
535}
536
537; CHECK-LABEL: load_v4i32_from_global_address:
538; NO-SIMD128-NOT: v128
539; SIMD128: .result v128{{$}}
540; SIMD128: i32.const $push0=, 0 #
541; SIMD128: v128.load $push1=, gv_v4i32($pop0):p2align=0
542; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,
543; SIMD128: return $pop1 #
544@gv_v4i32 = global <4 x i32> <i32 42, i32 42, i32 42, i32 42>
545define <4 x i32> @load_v4i32_from_global_address() {
546 %v = load <4 x i32>, <4 x i32>* @gv_v4i32
547 ret <4 x i32> %v
548}
549
550; CHECK-LABEL: store_v4i32:
551; NO-SIMD128-NOT: v128
552; SIMD128: .param v128, i32{{$}}
553; SIMD128: v128.store 0($1):p2align=0, $0
554; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
555define void @store_v4i32(<4 x i32> %v, <4 x i32>* %p) {
556 store <4 x i32> %v , <4 x i32>* %p
557 ret void
558}
559
560; CHECK-LABEL: store_v4i32_with_folded_offset:
561; NO-SIMD128-NOT: v128
562; SIMD128: .param v128, i32{{$}}
563; SIMD128: v128.store 16($1):p2align=0, $0
564; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
565define void @store_v4i32_with_folded_offset(<4 x i32> %v, <4 x i32>* %p) {
566 %q = ptrtoint <4 x i32>* %p to i32
567 %r = add nuw i32 %q, 16
568 %s = inttoptr i32 %r to <4 x i32>*
569 store <4 x i32> %v , <4 x i32>* %s
570 ret void
571}
572
573; CHECK-LABEL: store_v4i32_with_folded_gep_offset:
574; NO-SIMD128-NOT: v128
575; SIMD128: .param v128, i32{{$}}
576; SIMD128: v128.store 16($1):p2align=0, $0
577; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
578define void @store_v4i32_with_folded_gep_offset(<4 x i32> %v, <4 x i32>* %p) {
579 %s = getelementptr inbounds <4 x i32>, <4 x i32>* %p, i32 1
580 store <4 x i32> %v , <4 x i32>* %s
581 ret void
582}
583
584; CHECK-LABEL: store_v4i32_with_unfolded_gep_negative_offset:
585; NO-SIMD128-NOT: v128
586; SIMD128: .param v128, i32{{$}}
587; SIMD128: i32.const $push0=, -16 #
588; SIMD128: i32.add $push1=, $1, $pop0 #
589; SIMD128: v128.store 0($pop1):p2align=0, $0
590; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
591define void @store_v4i32_with_unfolded_gep_negative_offset(<4 x i32> %v, <4 x i32>* %p) {
592 %s = getelementptr inbounds <4 x i32>, <4 x i32>* %p, i32 -1
593 store <4 x i32> %v , <4 x i32>* %s
594 ret void
595}
596
597; CHECK-LABEL: store_v4i32_with_unfolded_offset:
598; NO-SIMD128-NOT: v128
599; SIMD128: .param v128, i32{{$}}
600; SIMD128: i32.const $push0=, -16 #
601; SIMD128: i32.add $push1=, $1, $pop0 #
602; SIMD128: v128.store 0($pop1):p2align=0, $0
603; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
604define void @store_v4i32_with_unfolded_offset(<4 x i32> %v, <4 x i32>* %p) {
605 %s = getelementptr inbounds <4 x i32>, <4 x i32>* %p, i32 -1
606 store <4 x i32> %v , <4 x i32>* %s
607 ret void
608}
609
610; CHECK-LABEL: store_v4i32_with_unfolded_gep_offset:
611; NO-SIMD128-NOT: v128
612; SIMD128: .param v128, i32{{$}}
613; SIMD128: i32.const $push0=, 16 #
614; SIMD128: i32.add $push1=, $1, $pop0 #
615; SIMD128: v128.store 0($pop1):p2align=0, $0
616; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
617define void @store_v4i32_with_unfolded_gep_offset(<4 x i32> %v, <4 x i32>* %p) {
618 %s = getelementptr <4 x i32>, <4 x i32>* %p, i32 1
619 store <4 x i32> %v , <4 x i32>* %s
620 ret void
621}
622
623; CHECK-LABEL: store_v4i32_to_numeric_address:
624; NO-SIMD128-NOT: v128
625; SIMD128: .param v128{{$}}
626; SIMD128: i32.const $push0=, 0 #
627; SIMD128: v128.store 32($pop0):p2align=0, $0
628; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x20]{{$}}
629define void @store_v4i32_to_numeric_address(<4 x i32> %v) {
630 %s = inttoptr i32 32 to <4 x i32>*
631 store <4 x i32> %v , <4 x i32>* %s
632 ret void
633}
634
635; CHECK-LABEL: store_v4i32_to_global_address:
636; NO-SIMD128-NOT: v128
637; SIMD128: .param v128{{$}}
638; SIMD128: i32.const $push0=, 0 #
639; SIMD128: v128.store gv_v4i32($pop0):p2align=0, $0
640; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,
641define void @store_v4i32_to_global_address(<4 x i32> %v) {
642 store <4 x i32> %v , <4 x i32>* @gv_v4i32
643 ret void
644}
645
646; ==============================================================================
647; 2 x i64
648; ==============================================================================
649; CHECK-LABEL: load_v2i64:
650; NO-SIMD128-NOT: v128
651; SIMD128-VM-NOT: v128
652; SIMD128: .param i32{{$}}
653; SIMD128: .result v128{{$}}
654; SIMD128: v128.load $push0=, 0($0):p2align=0
655; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
656; SIMD128: return $pop0 #
657define <2 x i64> @load_v2i64(<2 x i64>* %p) {
658 %v = load <2 x i64>, <2 x i64>* %p
659 ret <2 x i64> %v
660}
661
662; CHECK-LABEL: load_v2i64_with_folded_offset:
663; NO-SIMD128-NOT: v128
664; SIMD128-VM-NOT: v128
665; SIMD128: .param i32{{$}}
666; SIMD128: .result v128{{$}}
667; SIMD128: v128.load $push0=, 16($0):p2align=0
668; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
669; SIMD128: return $pop0 #
670define <2 x i64> @load_v2i64_with_folded_offset(<2 x i64>* %p) {
671 %q = ptrtoint <2 x i64>* %p to i32
672 %r = add nuw i32 %q, 16
673 %s = inttoptr i32 %r to <2 x i64>*
674 %v = load <2 x i64>, <2 x i64>* %s
675 ret <2 x i64> %v
676}
677
678; CHECK-LABEL: load_v2i64_with_folded_gep_offset:
679; NO-SIMD128-NOT: v128
680; SIMD128-VM-NOT: v128
681; SIMD128: .param i32{{$}}
682; SIMD128: .result v128{{$}}
683; SIMD128: v128.load $push0=, 16($0):p2align=0
684; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
685; SIMD128: return $pop0 #
686define <2 x i64> @load_v2i64_with_folded_gep_offset(<2 x i64>* %p) {
687 %s = getelementptr inbounds <2 x i64>, <2 x i64>* %p, i32 1
688 %v = load <2 x i64>, <2 x i64>* %s
689 ret <2 x i64> %v
690}
691
692; CHECK-LABEL: load_v2i64_with_unfolded_gep_negative_offset:
693; NO-SIMD128-NOT: v128
694; SIMD128-VM-NOT: v128
695; SIMD128: .param i32{{$}}
696; SIMD128: .result v128{{$}}
697; SIMD128: i32.const $push0=, -16 #
698; SIMD128: i32.add $push1=, $0, $pop0 #
699; SIMD128: v128.load $push2=, 0($pop1):p2align=0
700; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
701; SIMD128: return $pop2 #
702define <2 x i64> @load_v2i64_with_unfolded_gep_negative_offset(<2 x i64>* %p) {
703 %s = getelementptr inbounds <2 x i64>, <2 x i64>* %p, i32 -1
704 %v = load <2 x i64>, <2 x i64>* %s
705 ret <2 x i64> %v
706}
707
708; CHECK-LABEL: load_v2i64_with_unfolded_offset:
709; NO-SIMD128-NOT: v128
710; SIMD128-VM-NOT: v128
711; SIMD128: .param i32{{$}}
712; SIMD128: .result v128{{$}}
713; SIMD128: i32.const $push0=, 16 #
714; SIMD128: i32.add $push1=, $0, $pop0 #
715; SIMD128: v128.load $push2=, 0($pop1):p2align=0
716; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
717; SIMD128: return $pop2 #
718define <2 x i64> @load_v2i64_with_unfolded_offset(<2 x i64>* %p) {
719 %q = ptrtoint <2 x i64>* %p to i32
720 %r = add nsw i32 %q, 16
721 %s = inttoptr i32 %r to <2 x i64>*
722 %v = load <2 x i64>, <2 x i64>* %s
723 ret <2 x i64> %v
724}
725
726; CHECK-LABEL: load_v2i64_with_unfolded_gep_offset:
727; NO-SIMD128-NOT: v128
728; SIMD128-VM-NOT: v128
729; SIMD128: .param i32{{$}}
730; SIMD128: .result v128{{$}}
731; SIMD128: i32.const $push0=, 16 #
732; SIMD128: i32.add $push1=, $0, $pop0 #
733; SIMD128: v128.load $push2=, 0($pop1):p2align=0
734; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
735; SIMD128: return $pop2 #
736define <2 x i64> @load_v2i64_with_unfolded_gep_offset(<2 x i64>* %p) {
737 %s = getelementptr <2 x i64>, <2 x i64>* %p, i32 1
738 %v = load <2 x i64>, <2 x i64>* %s
739 ret <2 x i64> %v
740}
741
742; CHECK-LABEL: load_v2i64_from_numeric_address:
743; NO-SIMD128-NOT: v128
744; SIMD128-VM-NOT: v128
745; SIMD128: .result v128{{$}}
746; SIMD128: i32.const $push0=, 0 #
747; SIMD128: v128.load $push1=, 32($pop0):p2align=0
748; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x20]{{$}}
749; SIMD128: return $pop1 #
750define <2 x i64> @load_v2i64_from_numeric_address() {
751 %s = inttoptr i32 32 to <2 x i64>*
752 %v = load <2 x i64>, <2 x i64>* %s
753 ret <2 x i64> %v
754}
755
756; CHECK-LABEL: load_v2i64_from_global_address:
757; NO-SIMD128-NOT: v128
758; SIMD128-VM-NOT: v128
759; SIMD128: .result v128{{$}}
760; SIMD128: i32.const $push0=, 0 #
761; SIMD128: v128.load $push1=, gv_v2i64($pop0):p2align=0
762; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,
763; SIMD128: return $pop1 #
764@gv_v2i64 = global <2 x i64> <i64 42, i64 42>
765define <2 x i64> @load_v2i64_from_global_address() {
766 %v = load <2 x i64>, <2 x i64>* @gv_v2i64
767 ret <2 x i64> %v
768}
769
770; CHECK-LABEL: store_v2i64:
771; NO-SIMD128-NOT: v128
772; SIMD128-VM-NOT: v128
773; SIMD128: .param v128, i32{{$}}
774; SIMD128: v128.store 0($1):p2align=0, $0
775; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
776define void @store_v2i64(<2 x i64> %v, <2 x i64>* %p) {
777 store <2 x i64> %v , <2 x i64>* %p
778 ret void
779}
780
781; CHECK-LABEL: store_v2i64_with_folded_offset:
782; NO-SIMD128-NOT: v128
783; SIMD128-VM-NOT: v128
784; SIMD128: .param v128, i32{{$}}
785; SIMD128: v128.store 16($1):p2align=0, $0
786; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
787define void @store_v2i64_with_folded_offset(<2 x i64> %v, <2 x i64>* %p) {
788 %q = ptrtoint <2 x i64>* %p to i32
789 %r = add nuw i32 %q, 16
790 %s = inttoptr i32 %r to <2 x i64>*
791 store <2 x i64> %v , <2 x i64>* %s
792 ret void
793}
794
795; CHECK-LABEL: store_v2i64_with_folded_gep_offset:
796; NO-SIMD128-NOT: v128
797; SIMD128-VM-NOT: v128
798; SIMD128: .param v128, i32{{$}}
799; SIMD128: v128.store 16($1):p2align=0, $0
800; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
801define void @store_v2i64_with_folded_gep_offset(<2 x i64> %v, <2 x i64>* %p) {
802 %s = getelementptr inbounds <2 x i64>, <2 x i64>* %p, i32 1
803 store <2 x i64> %v , <2 x i64>* %s
804 ret void
805}
806
807; CHECK-LABEL: store_v2i64_with_unfolded_gep_negative_offset:
808; NO-SIMD128-NOT: v128
809; SIMD128-VM-NOT: v128
810; SIMD128: .param v128, i32{{$}}
811; SIMD128: i32.const $push0=, -16 #
812; SIMD128: i32.add $push1=, $1, $pop0 #
813; SIMD128: v128.store 0($pop1):p2align=0, $0
814; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
815define void @store_v2i64_with_unfolded_gep_negative_offset(<2 x i64> %v, <2 x i64>* %p) {
816 %s = getelementptr inbounds <2 x i64>, <2 x i64>* %p, i32 -1
817 store <2 x i64> %v , <2 x i64>* %s
818 ret void
819}
820
821; CHECK-LABEL: store_v2i64_with_unfolded_offset:
822; NO-SIMD128-NOT: v128
823; SIMD128-VM-NOT: v128
824; SIMD128: .param v128, i32{{$}}
825; SIMD128: i32.const $push0=, -16 #
826; SIMD128: i32.add $push1=, $1, $pop0 #
827; SIMD128: v128.store 0($pop1):p2align=0, $0
828; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
829define void @store_v2i64_with_unfolded_offset(<2 x i64> %v, <2 x i64>* %p) {
830 %s = getelementptr inbounds <2 x i64>, <2 x i64>* %p, i32 -1
831 store <2 x i64> %v , <2 x i64>* %s
832 ret void
833}
834
835; CHECK-LABEL: store_v2i64_with_unfolded_gep_offset:
836; NO-SIMD128-NOT: v128
837; SIMD128-VM-NOT: v128
838; SIMD128: .param v128, i32{{$}}
839; SIMD128: i32.const $push0=, 16 #
840; SIMD128: i32.add $push1=, $1, $pop0 #
841; SIMD128: v128.store 0($pop1):p2align=0, $0
842; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
843define void @store_v2i64_with_unfolded_gep_offset(<2 x i64> %v, <2 x i64>* %p) {
844 %s = getelementptr <2 x i64>, <2 x i64>* %p, i32 1
845 store <2 x i64> %v , <2 x i64>* %s
846 ret void
847}
848
849; CHECK-LABEL: store_v2i64_to_numeric_address:
850; NO-SIMD128-NOT: v128
851; SIMD128-VM-NOT: v128
852; SIMD128: .param v128{{$}}
853; SIMD128: i32.const $push0=, 0 #
854; SIMD128: v128.store 32($pop0):p2align=0, $0
855; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x20]{{$}}
856define void @store_v2i64_to_numeric_address(<2 x i64> %v) {
857 %s = inttoptr i32 32 to <2 x i64>*
858 store <2 x i64> %v , <2 x i64>* %s
859 ret void
860}
861
862; CHECK-LABEL: store_v2i64_to_global_address:
863; NO-SIMD128-NOT: v128
864; SIMD128-VM-NOT: v128
865; SIMD128: .param v128{{$}}
866; SIMD128: i32.const $push0=, 0 #
867; SIMD128: v128.store gv_v2i64($pop0):p2align=0, $0
868; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,
869define void @store_v2i64_to_global_address(<2 x i64> %v) {
870 store <2 x i64> %v , <2 x i64>* @gv_v2i64
871 ret void
872}
873
874; ==============================================================================
875; 4 x float
876; ==============================================================================
877; CHECK-LABEL: load_v4f32:
878; NO-SIMD128-NOT: v128
879; SIMD128: .param i32{{$}}
880; SIMD128: .result v128{{$}}
881; SIMD128: v128.load $push0=, 0($0):p2align=0
882; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
883; SIMD128: return $pop0 #
884define <4 x float> @load_v4f32(<4 x float>* %p) {
885 %v = load <4 x float>, <4 x float>* %p
886 ret <4 x float> %v
887}
888
889; CHECK-LABEL: load_v4f32_with_folded_offset:
890; NO-SIMD128-NOT: v128
891; SIMD128: .param i32{{$}}
892; SIMD128: .result v128{{$}}
893; SIMD128: v128.load $push0=, 16($0):p2align=0
894; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
895; SIMD128: return $pop0 #
896define <4 x float> @load_v4f32_with_folded_offset(<4 x float>* %p) {
897 %q = ptrtoint <4 x float>* %p to i32
898 %r = add nuw i32 %q, 16
899 %s = inttoptr i32 %r to <4 x float>*
900 %v = load <4 x float>, <4 x float>* %s
901 ret <4 x float> %v
902}
903
904; CHECK-LABEL: load_v4f32_with_folded_gep_offset:
905; NO-SIMD128-NOT: v128
906; SIMD128: .param i32{{$}}
907; SIMD128: .result v128{{$}}
908; SIMD128: v128.load $push0=, 16($0):p2align=0
909; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
910; SIMD128: return $pop0 #
911define <4 x float> @load_v4f32_with_folded_gep_offset(<4 x float>* %p) {
912 %s = getelementptr inbounds <4 x float>, <4 x float>* %p, i32 1
913 %v = load <4 x float>, <4 x float>* %s
914 ret <4 x float> %v
915}
916
917; CHECK-LABEL: load_v4f32_with_unfolded_gep_negative_offset:
918; NO-SIMD128-NOT: v128
919; SIMD128: .param i32{{$}}
920; SIMD128: .result v128{{$}}
921; SIMD128: i32.const $push0=, -16 #
922; SIMD128: i32.add $push1=, $0, $pop0 #
923; SIMD128: v128.load $push2=, 0($pop1):p2align=0
924; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
925; SIMD128: return $pop2 #
926define <4 x float> @load_v4f32_with_unfolded_gep_negative_offset(<4 x float>* %p) {
927 %s = getelementptr inbounds <4 x float>, <4 x float>* %p, i32 -1
928 %v = load <4 x float>, <4 x float>* %s
929 ret <4 x float> %v
930}
931
932; CHECK-LABEL: load_v4f32_with_unfolded_offset:
933; NO-SIMD128-NOT: v128
934; SIMD128: .param i32{{$}}
935; SIMD128: .result v128{{$}}
936; SIMD128: i32.const $push0=, 16 #
937; SIMD128: i32.add $push1=, $0, $pop0 #
938; SIMD128: v128.load $push2=, 0($pop1):p2align=0
939; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
940; SIMD128: return $pop2 #
941define <4 x float> @load_v4f32_with_unfolded_offset(<4 x float>* %p) {
942 %q = ptrtoint <4 x float>* %p to i32
943 %r = add nsw i32 %q, 16
944 %s = inttoptr i32 %r to <4 x float>*
945 %v = load <4 x float>, <4 x float>* %s
946 ret <4 x float> %v
947}
948
949; CHECK-LABEL: load_v4f32_with_unfolded_gep_offset:
950; NO-SIMD128-NOT: v128
951; SIMD128: .param i32{{$}}
952; SIMD128: .result v128{{$}}
953; SIMD128: i32.const $push0=, 16 #
954; SIMD128: i32.add $push1=, $0, $pop0 #
955; SIMD128: v128.load $push2=, 0($pop1):p2align=0
956; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
957; SIMD128: return $pop2 #
958define <4 x float> @load_v4f32_with_unfolded_gep_offset(<4 x float>* %p) {
959 %s = getelementptr <4 x float>, <4 x float>* %p, i32 1
960 %v = load <4 x float>, <4 x float>* %s
961 ret <4 x float> %v
962}
963
964; CHECK-LABEL: load_v4f32_from_numeric_address:
965; NO-SIMD128-NOT: v128
966; SIMD128: .result v128{{$}}
967; SIMD128: i32.const $push0=, 0 #
968; SIMD128: v128.load $push1=, 32($pop0):p2align=0
969; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x20]{{$}}
970; SIMD128: return $pop1 #
971define <4 x float> @load_v4f32_from_numeric_address() {
972 %s = inttoptr i32 32 to <4 x float>*
973 %v = load <4 x float>, <4 x float>* %s
974 ret <4 x float> %v
975}
976
977; CHECK-LABEL: load_v4f32_from_global_address:
978; NO-SIMD128-NOT: v128
979; SIMD128: .result v128{{$}}
980; SIMD128: i32.const $push0=, 0 #
981; SIMD128: v128.load $push1=, gv_v4f32($pop0):p2align=0
982; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,
983; SIMD128: return $pop1 #
984@gv_v4f32 = global <4 x float> <float 42., float 42., float 42., float 42.>
985define <4 x float> @load_v4f32_from_global_address() {
986 %v = load <4 x float>, <4 x float>* @gv_v4f32
987 ret <4 x float> %v
988}
989
990; CHECK-LABEL: store_v4f32:
991; NO-SIMD128-NOT: v128
992; SIMD128: .param v128, i32{{$}}
993; SIMD128: v128.store 0($1):p2align=0, $0
994; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
995define void @store_v4f32(<4 x float> %v, <4 x float>* %p) {
996 store <4 x float> %v , <4 x float>* %p
997 ret void
998}
999
1000; CHECK-LABEL: store_v4f32_with_folded_offset:
1001; NO-SIMD128-NOT: v128
1002; SIMD128: .param v128, i32{{$}}
1003; SIMD128: v128.store 16($1):p2align=0, $0
1004; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
1005define void @store_v4f32_with_folded_offset(<4 x float> %v, <4 x float>* %p) {
1006 %q = ptrtoint <4 x float>* %p to i32
1007 %r = add nuw i32 %q, 16
1008 %s = inttoptr i32 %r to <4 x float>*
1009 store <4 x float> %v , <4 x float>* %s
1010 ret void
1011}
1012
1013; CHECK-LABEL: store_v4f32_with_folded_gep_offset:
1014; NO-SIMD128-NOT: v128
1015; SIMD128: .param v128, i32{{$}}
1016; SIMD128: v128.store 16($1):p2align=0, $0
1017; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
1018define void @store_v4f32_with_folded_gep_offset(<4 x float> %v, <4 x float>* %p) {
1019 %s = getelementptr inbounds <4 x float>, <4 x float>* %p, i32 1
1020 store <4 x float> %v , <4 x float>* %s
1021 ret void
1022}
1023
1024; CHECK-LABEL: store_v4f32_with_unfolded_gep_negative_offset:
1025; NO-SIMD128-NOT: v128
1026; SIMD128: .param v128, i32{{$}}
1027; SIMD128: i32.const $push0=, -16 #
1028; SIMD128: i32.add $push1=, $1, $pop0 #
1029; SIMD128: v128.store 0($pop1):p2align=0, $0
1030; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
1031define void @store_v4f32_with_unfolded_gep_negative_offset(<4 x float> %v, <4 x float>* %p) {
1032 %s = getelementptr inbounds <4 x float>, <4 x float>* %p, i32 -1
1033 store <4 x float> %v , <4 x float>* %s
1034 ret void
1035}
1036
1037; CHECK-LABEL: store_v4f32_with_unfolded_offset:
1038; NO-SIMD128-NOT: v128
1039; SIMD128: .param v128, i32{{$}}
1040; SIMD128: i32.const $push0=, -16 #
1041; SIMD128: i32.add $push1=, $1, $pop0 #
1042; SIMD128: v128.store 0($pop1):p2align=0, $0
1043; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
1044define void @store_v4f32_with_unfolded_offset(<4 x float> %v, <4 x float>* %p) {
1045 %s = getelementptr inbounds <4 x float>, <4 x float>* %p, i32 -1
1046 store <4 x float> %v , <4 x float>* %s
1047 ret void
1048}
1049
1050; CHECK-LABEL: store_v4f32_with_unfolded_gep_offset:
1051; NO-SIMD128-NOT: v128
1052; SIMD128: .param v128, i32{{$}}
1053; SIMD128: i32.const $push0=, 16 #
1054; SIMD128: i32.add $push1=, $1, $pop0 #
1055; SIMD128: v128.store 0($pop1):p2align=0, $0
1056; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
1057define void @store_v4f32_with_unfolded_gep_offset(<4 x float> %v, <4 x float>* %p) {
1058 %s = getelementptr <4 x float>, <4 x float>* %p, i32 1
1059 store <4 x float> %v , <4 x float>* %s
1060 ret void
1061}
1062
1063; CHECK-LABEL: store_v4f32_to_numeric_address:
1064; NO-SIMD128-NOT: v128
1065; SIMD128: .param v128{{$}}
1066; SIMD128: i32.const $push0=, 0 #
1067; SIMD128: v128.store 32($pop0):p2align=0, $0
1068; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x20]{{$}}
1069define void @store_v4f32_to_numeric_address(<4 x float> %v) {
1070 %s = inttoptr i32 32 to <4 x float>*
1071 store <4 x float> %v , <4 x float>* %s
1072 ret void
1073}
1074
1075; CHECK-LABEL: store_v4f32_to_global_address:
1076; NO-SIMD128-NOT: v128
1077; SIMD128: .param v128{{$}}
1078; SIMD128: i32.const $push0=, 0 #
1079; SIMD128: v128.store gv_v4f32($pop0):p2align=0, $0
1080; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,
1081define void @store_v4f32_to_global_address(<4 x float> %v) {
1082 store <4 x float> %v , <4 x float>* @gv_v4f32
1083 ret void
1084}
1085
1086; ==============================================================================
1087; 2 x double
1088; ==============================================================================
1089; CHECK-LABEL: load_v2f64:
1090; NO-SIMD128-NOT: v128
1091; SIMD128-VM-NOT: v128
1092; SIMD128: .param i32{{$}}
1093; SIMD128: .result v128{{$}}
1094; SIMD128: v128.load $push0=, 0($0):p2align=0
1095; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
1096; SIMD128: return $pop0 #
1097define <2 x double> @load_v2f64(<2 x double>* %p) {
1098 %v = load <2 x double>, <2 x double>* %p
1099 ret <2 x double> %v
1100}
1101
1102; CHECK-LABEL: load_v2f64_with_folded_offset:
1103; NO-SIMD128-NOT: v128
1104; SIMD128-VM-NOT: v128
1105; SIMD128: .param i32{{$}}
1106; SIMD128: .result v128{{$}}
1107; SIMD128: v128.load $push0=, 16($0):p2align=0
1108; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
1109; SIMD128: return $pop0 #
1110define <2 x double> @load_v2f64_with_folded_offset(<2 x double>* %p) {
1111 %q = ptrtoint <2 x double>* %p to i32
1112 %r = add nuw i32 %q, 16
1113 %s = inttoptr i32 %r to <2 x double>*
1114 %v = load <2 x double>, <2 x double>* %s
1115 ret <2 x double> %v
1116}
1117
1118; CHECK-LABEL: load_v2f64_with_folded_gep_offset:
1119; NO-SIMD128-NOT: v128
1120; SIMD128-VM-NOT: v128
1121; SIMD128: .param i32{{$}}
1122; SIMD128: .result v128{{$}}
1123; SIMD128: v128.load $push0=, 16($0):p2align=0
1124; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x10]{{$}}
1125; SIMD128: return $pop0 #
1126define <2 x double> @load_v2f64_with_folded_gep_offset(<2 x double>* %p) {
1127 %s = getelementptr inbounds <2 x double>, <2 x double>* %p, i32 1
1128 %v = load <2 x double>, <2 x double>* %s
1129 ret <2 x double> %v
1130}
1131
1132; CHECK-LABEL: load_v2f64_with_unfolded_gep_negative_offset:
1133; NO-SIMD128-NOT: v128
1134; SIMD128-VM-NOT: v128
1135; SIMD128: .param i32{{$}}
1136; SIMD128: .result v128{{$}}
1137; SIMD128: i32.const $push0=, -16 #
1138; SIMD128: i32.add $push1=, $0, $pop0 #
1139; SIMD128: v128.load $push2=, 0($pop1):p2align=0
1140; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
1141; SIMD128: return $pop2 #
1142define <2 x double> @load_v2f64_with_unfolded_gep_negative_offset(<2 x double>* %p) {
1143 %s = getelementptr inbounds <2 x double>, <2 x double>* %p, i32 -1
1144 %v = load <2 x double>, <2 x double>* %s
1145 ret <2 x double> %v
1146}
1147
1148; CHECK-LABEL: load_v2f64_with_unfolded_offset:
1149; NO-SIMD128-NOT: v128
1150; SIMD128-VM-NOT: v128
1151; SIMD128: .param i32{{$}}
1152; SIMD128: .result v128{{$}}
1153; SIMD128: i32.const $push0=, 16 #
1154; SIMD128: i32.add $push1=, $0, $pop0 #
1155; SIMD128: v128.load $push2=, 0($pop1):p2align=0
1156; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
1157; SIMD128: return $pop2 #
1158define <2 x double> @load_v2f64_with_unfolded_offset(<2 x double>* %p) {
1159 %q = ptrtoint <2 x double>* %p to i32
1160 %r = add nsw i32 %q, 16
1161 %s = inttoptr i32 %r to <2 x double>*
1162 %v = load <2 x double>, <2 x double>* %s
1163 ret <2 x double> %v
1164}
1165
1166; CHECK-LABEL: load_v2f64_with_unfolded_gep_offset:
1167; NO-SIMD128-NOT: v128
1168; SIMD128-VM-NOT: v128
1169; SIMD128: .param i32{{$}}
1170; SIMD128: .result v128{{$}}
1171; SIMD128: i32.const $push0=, 16 #
1172; SIMD128: i32.add $push1=, $0, $pop0 #
1173; SIMD128: v128.load $push2=, 0($pop1):p2align=0
1174; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x00]{{$}}
1175; SIMD128: return $pop2 #
1176define <2 x double> @load_v2f64_with_unfolded_gep_offset(<2 x double>* %p) {
1177 %s = getelementptr <2 x double>, <2 x double>* %p, i32 1
1178 %v = load <2 x double>, <2 x double>* %s
1179 ret <2 x double> %v
1180}
1181
1182; CHECK-LABEL: load_v2f64_from_numeric_address:
1183; NO-SIMD128-NOT: v128
1184; SIMD128-VM-NOT: v128
1185; SIMD128: .result v128{{$}}
1186; SIMD128: i32.const $push0=, 0 #
1187; SIMD128: v128.load $push1=, 32($pop0):p2align=0
1188; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,0x20]{{$}}
1189; SIMD128: return $pop1 #
1190define <2 x double> @load_v2f64_from_numeric_address() {
1191 %s = inttoptr i32 32 to <2 x double>*
1192 %v = load <2 x double>, <2 x double>* %s
1193 ret <2 x double> %v
1194}
1195
1196; CHECK-LABEL: load_v2f64_from_global_address:
1197; NO-SIMD128-NOT: v128
1198; SIMD128-VM-NOT: v128
1199; SIMD128: .result v128{{$}}
1200; SIMD128: i32.const $push0=, 0 #
1201; SIMD128: v128.load $push1=, gv_v2f64($pop0):p2align=0
1202; SIMD128-SAME: # encoding: [0xfd,0x01,0x00,
1203; SIMD128: return $pop1 #
1204@gv_v2f64 = global <2 x double> <double 42., double 42.>
1205define <2 x double> @load_v2f64_from_global_address() {
1206 %v = load <2 x double>, <2 x double>* @gv_v2f64
1207 ret <2 x double> %v
1208}
1209
1210; CHECK-LABEL: store_v2f64:
1211; NO-SIMD128-NOT: v128
1212; SIMD128-VM-NOT: v128
1213; SIMD128: .param v128, i32{{$}}
1214; SIMD128: v128.store 0($1):p2align=0, $0
1215; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
1216define void @store_v2f64(<2 x double> %v, <2 x double>* %p) {
1217 store <2 x double> %v , <2 x double>* %p
1218 ret void
1219}
1220
1221; CHECK-LABEL: store_v2f64_with_folded_offset:
1222; NO-SIMD128-NOT: v128
1223; SIMD128-VM-NOT: v128
1224; SIMD128: .param v128, i32{{$}}
1225; SIMD128: v128.store 16($1):p2align=0, $0
1226; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
1227define void @store_v2f64_with_folded_offset(<2 x double> %v, <2 x double>* %p) {
1228 %q = ptrtoint <2 x double>* %p to i32
1229 %r = add nuw i32 %q, 16
1230 %s = inttoptr i32 %r to <2 x double>*
1231 store <2 x double> %v , <2 x double>* %s
1232 ret void
1233}
1234
1235; CHECK-LABEL: store_v2f64_with_folded_gep_offset:
1236; NO-SIMD128-NOT: v128
1237; SIMD128-VM-NOT: v128
1238; SIMD128: .param v128, i32{{$}}
1239; SIMD128: v128.store 16($1):p2align=0, $0
1240; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x10]{{$}}
1241define void @store_v2f64_with_folded_gep_offset(<2 x double> %v, <2 x double>* %p) {
1242 %s = getelementptr inbounds <2 x double>, <2 x double>* %p, i32 1
1243 store <2 x double> %v , <2 x double>* %s
1244 ret void
1245}
1246
1247; CHECK-LABEL: store_v2f64_with_unfolded_gep_negative_offset:
1248; NO-SIMD128-NOT: v128
1249; SIMD128-VM-NOT: v128
1250; SIMD128: .param v128, i32{{$}}
1251; SIMD128: i32.const $push0=, -16 #
1252; SIMD128: i32.add $push1=, $1, $pop0 #
1253; SIMD128: v128.store 0($pop1):p2align=0, $0
1254; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
1255define void @store_v2f64_with_unfolded_gep_negative_offset(<2 x double> %v, <2 x double>* %p) {
1256 %s = getelementptr inbounds <2 x double>, <2 x double>* %p, i32 -1
1257 store <2 x double> %v , <2 x double>* %s
1258 ret void
1259}
1260
1261; CHECK-LABEL: store_v2f64_with_unfolded_offset:
1262; NO-SIMD128-NOT: v128
1263; SIMD128-VM-NOT: v128
1264; SIMD128: .param v128, i32{{$}}
1265; SIMD128: i32.const $push0=, -16 #
1266; SIMD128: i32.add $push1=, $1, $pop0 #
1267; SIMD128: v128.store 0($pop1):p2align=0, $0
1268; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
1269define void @store_v2f64_with_unfolded_offset(<2 x double> %v, <2 x double>* %p) {
1270 %s = getelementptr inbounds <2 x double>, <2 x double>* %p, i32 -1
1271 store <2 x double> %v , <2 x double>* %s
1272 ret void
1273}
1274
1275; CHECK-LABEL: store_v2f64_with_unfolded_gep_offset:
1276; NO-SIMD128-NOT: v128
1277; SIMD128-VM-NOT: v128
1278; SIMD128: .param v128, i32{{$}}
1279; SIMD128: i32.const $push0=, 16 #
1280; SIMD128: i32.add $push1=, $1, $pop0 #
1281; SIMD128: v128.store 0($pop1):p2align=0, $0
1282; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x00]{{$}}
1283define void @store_v2f64_with_unfolded_gep_offset(<2 x double> %v, <2 x double>* %p) {
1284 %s = getelementptr <2 x double>, <2 x double>* %p, i32 1
1285 store <2 x double> %v , <2 x double>* %s
1286 ret void
1287}
1288
1289; CHECK-LABEL: store_v2f64_to_numeric_address:
1290; NO-SIMD128-NOT: v128
1291; SIMD128-VM-NOT: v128
1292; SIMD128: .param v128{{$}}
1293; SIMD128: i32.const $push0=, 0 #
1294; SIMD128: v128.store 32($pop0):p2align=0, $0
1295; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,0x20]{{$}}
1296define void @store_v2f64_to_numeric_address(<2 x double> %v) {
1297 %s = inttoptr i32 32 to <2 x double>*
1298 store <2 x double> %v , <2 x double>* %s
1299 ret void
1300}
1301
1302; CHECK-LABEL: store_v2f64_to_global_address:
1303; NO-SIMD128-NOT: v128
1304; SIMD128-VM-NOT: v128
1305; SIMD128: .param v128{{$}}
1306; SIMD128: i32.const $push0=, 0 #
1307; SIMD128: v128.store gv_v2f64($pop0):p2align=0, $0
1308; SIMD128-SAME: # encoding: [0xfd,0x02,0x00,
1309define void @store_v2f64_to_global_address(<2 x double> %v) {
1310 store <2 x double> %v , <2 x double>* @gv_v2f64
1311 ret void
1312}