Lines Matching refs:SIMD128

1 …eep-registers -mattr=+unimplemented-simd128,+sign-ext | FileCheck %s --check-prefixes CHECK,SIMD128
2 …als -wasm-keep-registers -mattr=+simd128,+sign-ext | FileCheck %s --check-prefixes CHECK,SIMD128-VM
3 …-wasm-disable-explicit-locals -wasm-keep-registers | FileCheck %s --check-prefixes CHECK,NO-SIMD128
5 ; Test that basic SIMD128 vector manipulation operations assemble as expected.
14 ; NO-SIMD128-NOT: i8x16
15 ; SIMD128-VM-NOT: v128.const
16 ; SIMD128-NEXT: .functype const_v16i8 () -> (v128){{$}}
17 ; SIMD128-NEXT: v128.const $push[[R:[0-9]+]]=,
18 ; SIMD128-SAME: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
19 ; SIMD128-NEXT: return $pop[[R]]{{$}}
26 ; NO-SIMD128-NOT: i8x16
27 ; SIMD128-NEXT: .functype splat_v16i8 (i32) -> (v128){{$}}
28 ; SIMD128-NEXT: i8x16.splat $push[[R:[0-9]+]]=, $0{{$}}
29 ; SIMD128-NEXT: return $pop[[R]]{{$}}
39 ; SIMD128: v128.const $push0=, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42{{$}}
46 ; NO-SIMD128-NOT: i8x16
47 ; SIMD128-NEXT: .functype extract_v16i8_s (v128) -> (i32){{$}}
48 ; SIMD128-NEXT: i8x16.extract_lane_s $push[[R:[0-9]+]]=, $0, 13{{$}}
49 ; SIMD128-NEXT: return $pop[[R]]{{$}}
57 ; NO-SIMD128-NOT: i8x16
58 ; SIMD128-NEXT: .functype extract_var_v16i8_s (v128, i32) -> (i32){{$}}
59 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer
60 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16
61 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]
62 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]
63 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0
64 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 15
65 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]
66 ; SIMD128-NEXT: i32.or $push[[L6:[0-9]+]]=, $2, $pop[[L5]]
67 ; SIMD128-NEXT: i32.load8_s $push[[R:[0-9]+]]=, 0($pop[[L6]])
68 ; SIMD128-NEXT: return $pop[[R]]
76 ; NO-SIMD128-NOT: i8x16
77 ; SIMD128-NEXT: .functype extract_undef_v16i8_s (v128) -> (i32){{$}}
78 ; SIMD128-NEXT: i8x16.extract_lane_s $push[[R:[0-9]+]]=, $0, 0{{$}}
79 ; SIMD128-NEXT: return $pop[[R]]{{$}}
87 ; NO-SIMD128-NOT: i8x16
88 ; SIMD128-NEXT: .functype extract_v16i8_u (v128) -> (i32){{$}}
89 ; SIMD128-NEXT: i8x16.extract_lane_u $push[[R:[0-9]+]]=, $0, 13{{$}}
90 ; SIMD128-NEXT: return $pop[[R]]{{$}}
98 ; NO-SIMD128-NOT: i8x16
99 ; SIMD128-NEXT: .functype extract_var_v16i8_u (v128, i32) -> (i32){{$}}
100 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
101 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
102 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
103 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}}
104 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
105 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 15{{$}}
106 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}}
107 ; SIMD128-NEXT: i32.or $push[[L6:[0-9]+]]=, $2, $pop[[L5]]{{$}}
108 ; SIMD128-NEXT: i32.load8_u $push[[R:[0-9]+]]=, 0($pop[[L6]]){{$}}
109 ; SIMD128-NEXT: return $pop[[R]]{{$}}
117 ; NO-SIMD128-NOT: i8x16
118 ; SIMD128-NEXT: .functype extract_undef_v16i8_u (v128) -> (i32){{$}}
119 ; SIMD128-NEXT: i8x16.extract_lane_u $push[[R:[0-9]+]]=, $0, 0{{$}}
120 ; SIMD128-NEXT: return $pop[[R]]{{$}}
128 ; NO-SIMD128-NOT: i8x16
129 ; SIMD128-NEXT: .functype extract_v16i8 (v128) -> (i32){{$}}
130 ; SIMD128-NEXT: i8x16.extract_lane_u $push[[R:[0-9]+]]=, $0, 13{{$}}
131 ; SIMD128-NEXT: return $pop[[R]]{{$}}
138 ; NO-SIMD128-NOT: i8x16
139 ; SIMD128-NEXT: .functype extract_var_v16i8 (v128, i32) -> (i32){{$}}
140 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
141 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
142 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
143 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}}
144 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
145 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 15{{$}}
146 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}}
147 ; SIMD128-NEXT: i32.or $push[[L6:[0-9]+]]=, $2, $pop[[L5]]{{$}}
148 ; SIMD128-NEXT: i32.load8_u $push[[R:[0-9]+]]=, 0($pop[[L6]]){{$}}
149 ; SIMD128-NEXT: return $pop[[R]]{{$}}
156 ; NO-SIMD128-NOT: i8x16
157 ; SIMD128-NEXT: .functype extract_undef_v16i8 (v128) -> (i32){{$}}
158 ; SIMD128-NEXT: i8x16.extract_lane_u $push[[R:[0-9]+]]=, $0, 0{{$}}
159 ; SIMD128-NEXT: return $pop[[R]]{{$}}
166 ; NO-SIMD128-NOT: i8x16
167 ; SIMD128-NEXT: .functype replace_v16i8 (v128, i32) -> (v128){{$}}
168 ; SIMD128-NEXT: i8x16.replace_lane $push[[R:[0-9]+]]=, $0, 11, $1{{$}}
169 ; SIMD128-NEXT: return $pop[[R]]{{$}}
176 ; NO-SIMD128-NOT: i8x16
177 ; SIMD128-NEXT: .functype replace_var_v16i8 (v128, i32, i32) -> (v128){{$}}
178 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
179 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
180 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
181 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}}
182 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
183 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 15{{$}}
184 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}}
185 ; SIMD128-NEXT: i32.or $push[[L6:[0-9]+]]=, $3, $pop[[L5]]{{$}}
186 ; SIMD128-NEXT: i32.store8 0($pop[[L6]]), $2{{$}}
187 ; SIMD128-NEXT: v128.load $push[[R:[0-9]+]]=, 0($3){{$}}
188 ; SIMD128-NEXT: return $pop[[R]]{{$}}
195 ; NO-SIMD128-NOT: i8x16
196 ; SIMD128-NEXT: .functype replace_zero_v16i8 (v128, i32) -> (v128){{$}}
197 ; SIMD128-NEXT: i8x16.replace_lane $push[[R:[0-9]+]]=, $0, 0, $1{{$}}
198 ; SIMD128-NEXT: return $pop[[R]]{{$}}
205 ; NO-SIMD128-NOT: v8x16
206 ; SIMD128-NEXT: .functype shuffle_v16i8 (v128, v128) -> (v128){{$}}
207 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $1,
208 ; SIMD128-SAME: 0, 17, 2, 19, 4, 21, 6, 23, 8, 25, 10, 27, 12, 29, 14, 31{{$}}
209 ; SIMD128-NEXT: return $pop[[R]]{{$}}
218 ; NO-SIMD128-NOT: v8x16
219 ; SIMD128-NEXT: .functype shuffle_undef_v16i8 (v128, v128) -> (v128){{$}}
220 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $0,
221 ; SIMD128-SAME: 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0{{$}}
222 ; SIMD128-NEXT: return $pop[[R]]{{$}}
233 ; NO-SIMD128-NOT: i8x16
234 ; SIMD128-NEXT: .functype build_v16i8 (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, …
235 ; SIMD128-NEXT: i8x16.splat $push[[L0:[0-9]+]]=, $0{{$}}
236 ; SIMD128-NEXT: i8x16.replace_lane $push[[L1:[0-9]+]]=, $pop[[L0]], 1, $1{{$}}
237 ; SIMD128-NEXT: i8x16.replace_lane $push[[L2:[0-9]+]]=, $pop[[L1]], 2, $2{{$}}
238 ; SIMD128-NEXT: i8x16.replace_lane $push[[L3:[0-9]+]]=, $pop[[L2]], 3, $3{{$}}
239 ; SIMD128-NEXT: i8x16.replace_lane $push[[L4:[0-9]+]]=, $pop[[L3]], 4, $4{{$}}
240 ; SIMD128-NEXT: i8x16.replace_lane $push[[L5:[0-9]+]]=, $pop[[L4]], 5, $5{{$}}
241 ; SIMD128-NEXT: i8x16.replace_lane $push[[L6:[0-9]+]]=, $pop[[L5]], 6, $6{{$}}
242 ; SIMD128-NEXT: i8x16.replace_lane $push[[L7:[0-9]+]]=, $pop[[L6]], 7, $7{{$}}
243 ; SIMD128-NEXT: i8x16.replace_lane $push[[L8:[0-9]+]]=, $pop[[L7]], 8, $8{{$}}
244 ; SIMD128-NEXT: i8x16.replace_lane $push[[L9:[0-9]+]]=, $pop[[L8]], 9, $9{{$}}
245 ; SIMD128-NEXT: i8x16.replace_lane $push[[L10:[0-9]+]]=, $pop[[L9]], 10, $10{{$}}
246 ; SIMD128-NEXT: i8x16.replace_lane $push[[L11:[0-9]+]]=, $pop[[L10]], 11, $11{{$}}
247 ; SIMD128-NEXT: i8x16.replace_lane $push[[L12:[0-9]+]]=, $pop[[L11]], 12, $12{{$}}
248 ; SIMD128-NEXT: i8x16.replace_lane $push[[L13:[0-9]+]]=, $pop[[L12]], 13, $13{{$}}
249 ; SIMD128-NEXT: i8x16.replace_lane $push[[L14:[0-9]+]]=, $pop[[L13]], 14, $14{{$}}
250 ; SIMD128-NEXT: i8x16.replace_lane $push[[R:[0-9]+]]=, $pop[[L14]], 15, $15{{$}}
251 ; SIMD128-NEXT: return $pop[[R]]{{$}}
279 ; NO-SIMD128-NOT: i16x8
280 ; SIMD128-VM-NOT: v128.const
281 ; SIMD128-NEXT: .functype const_v8i16 () -> (v128){{$}}
282 ; SIMD128-NEXT: v128.const $push[[R:[0-9]+]]=, 256, 770, 1284, 1798, 2312, 2826, 3340, 3854{{$}}
283 ; SIMD128-NEXT: return $pop[[R]]{{$}}
290 ; NO-SIMD128-NOT: i16x8
291 ; SIMD128-NEXT: .functype splat_v8i16 (i32) -> (v128){{$}}
292 ; SIMD128-NEXT: i16x8.splat $push[[R:[0-9]+]]=, $0{{$}}
293 ; SIMD128-NEXT: return $pop[[R]]{{$}}
302 ; SIMD128: v128.const $push0=, 42, 42, 42, 42, 42, 42, 42, 42{{$}}
308 ; NO-SIMD128-NOT: i16x8
309 ; SIMD128-NEXT: .functype extract_v8i16_s (v128) -> (i32){{$}}
310 ; SIMD128-NEXT: i16x8.extract_lane_s $push[[R:[0-9]+]]=, $0, 5{{$}}
311 ; SIMD128-NEXT: return $pop[[R]]{{$}}
319 ; NO-SIMD128-NOT: i16x8
320 ; SIMD128-NEXT: .functype extract_var_v8i16_s (v128, i32) -> (i32){{$}}
321 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
322 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
323 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
324 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}}
325 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
326 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 7{{$}}
327 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}}
328 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 1{{$}}
329 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
330 ; SIMD128-NEXT: i32.or $push[[L8:[0-9]+]]=, $2, $pop[[L7]]{{$}}
331 ; SIMD128-NEXT: i32.load16_s $push[[R:[0-9]+]]=, 0($pop[[L8]]){{$}}
332 ; SIMD128-NEXT: return $pop[[R]]{{$}}
340 ; NO-SIMD128-NOT: i16x8
341 ; SIMD128-NEXT: .functype extract_undef_v8i16_s (v128) -> (i32){{$}}
342 ; SIMD128-NEXT: i16x8.extract_lane_s $push[[R:[0-9]+]]=, $0, 0{{$}}
343 ; SIMD128-NEXT: return $pop[[R]]{{$}}
351 ; NO-SIMD128-NOT: i16x8
352 ; SIMD128-NEXT: .functype extract_v8i16_u (v128) -> (i32){{$}}
353 ; SIMD128-NEXT: i16x8.extract_lane_u $push[[R:[0-9]+]]=, $0, 5{{$}}
354 ; SIMD128-NEXT: return $pop[[R]]{{$}}
362 ; NO-SIMD128-NOT: i16x8
363 ; SIMD128-NEXT: .functype extract_var_v8i16_u (v128, i32) -> (i32){{$}}
364 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
365 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
366 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
367 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}}
368 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
369 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 7{{$}}
370 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}}
371 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 1{{$}}
372 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
373 ; SIMD128-NEXT: i32.or $push[[L8:[0-9]+]]=, $2, $pop[[L7]]{{$}}
374 ; SIMD128-NEXT: i32.load16_u $push[[R:[0-9]+]]=, 0($pop[[L8]]){{$}}
375 ; SIMD128-NEXT: return $pop[[R]]{{$}}
383 ; NO-SIMD128-NOT: i16x8
384 ; SIMD128-NEXT: .functype extract_undef_v8i16_u (v128) -> (i32){{$}}
385 ; SIMD128-NEXT: i16x8.extract_lane_u $push[[R:[0-9]+]]=, $0, 0{{$}}
386 ; SIMD128-NEXT: return $pop[[R]]{{$}}
394 ; NO-SIMD128-NOT: i16x8
395 ; SIMD128-NEXT: .functype extract_v8i16 (v128) -> (i32){{$}}
396 ; SIMD128-NEXT: i16x8.extract_lane_u $push[[R:[0-9]+]]=, $0, 5{{$}}
397 ; SIMD128-NEXT: return $pop[[R]]{{$}}
404 ; NO-SIMD128-NOT: i16x8
405 ; SIMD128-NEXT: .functype extract_var_v8i16 (v128, i32) -> (i32){{$}}
406 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
407 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
408 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
409 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}}
410 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
411 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 7{{$}}
412 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}}
413 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 1{{$}}
414 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
415 ; SIMD128-NEXT: i32.or $push[[L8:[0-9]+]]=, $2, $pop[[L7]]{{$}}
416 ; SIMD128-NEXT: i32.load16_u $push[[R:[0-9]+]]=, 0($pop[[L8]]){{$}}
417 ; SIMD128-NEXT: return $pop[[R]]{{$}}
424 ; NO-SIMD128-NOT: i16x8
425 ; SIMD128-NEXT: .functype extract_undef_v8i16 (v128) -> (i32){{$}}
426 ; SIMD128-NEXT: i16x8.extract_lane_u $push[[R:[0-9]+]]=, $0, 0{{$}}
427 ; SIMD128-NEXT: return $pop[[R]]{{$}}
434 ; NO-SIMD128-NOT: i16x8
435 ; SIMD128-NEXT: .functype replace_v8i16 (v128, i32) -> (v128){{$}}
436 ; SIMD128-NEXT: i16x8.replace_lane $push[[R:[0-9]+]]=, $0, 7, $1{{$}}
437 ; SIMD128-NEXT: return $pop[[R]]{{$}}
444 ; NO-SIMD128-NOT: i16x8
445 ; SIMD128-NEXT: .functype replace_var_v8i16 (v128, i32, i32) -> (v128){{$}}
446 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
447 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
448 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
449 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}}
450 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
451 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 7{{$}}
452 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}}
453 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 1{{$}}
454 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
455 ; SIMD128-NEXT: i32.or $push[[L8:[0-9]+]]=, $3, $pop[[L7]]{{$}}
456 ; SIMD128-NEXT: i32.store16 0($pop[[L8]]), $2{{$}}
457 ; SIMD128-NEXT: v128.load $push[[R:[0-9]+]]=, 0($3){{$}}
458 ; SIMD128-NEXT: return $pop[[R]]{{$}}
465 ; NO-SIMD128-NOT: i16x8
466 ; SIMD128-NEXT: .functype replace_zero_v8i16 (v128, i32) -> (v128){{$}}
467 ; SIMD128-NEXT: i16x8.replace_lane $push[[R:[0-9]+]]=, $0, 0, $1{{$}}
468 ; SIMD128-NEXT: return $pop[[R]]{{$}}
475 ; NO-SIMD128-NOT: v8x16
476 ; SIMD128-NEXT: .functype shuffle_v8i16 (v128, v128) -> (v128){{$}}
477 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $1,
478 ; SIMD128-SAME: 0, 1, 18, 19, 4, 5, 22, 23, 8, 9, 26, 27, 12, 13, 30, 31{{$}}
479 ; SIMD128-NEXT: return $pop[[R]]{{$}}
487 ; NO-SIMD128-NOT: v8x16
488 ; SIMD128-NEXT: .functype shuffle_undef_v8i16 (v128, v128) -> (v128){{$}}
489 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $0,
490 ; SIMD128-SAME: 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0{{$}}
491 ; SIMD128-NEXT: return $pop[[R]]{{$}}
500 ; NO-SIMD128-NOT: i16x8
501 ; SIMD128-NEXT: .functype build_v8i16 (i32, i32, i32, i32, i32, i32, i32, i32) -> (v128){{$}}
502 ; SIMD128-NEXT: i16x8.splat $push[[L0:[0-9]+]]=, $0{{$}}
503 ; SIMD128-NEXT: i16x8.replace_lane $push[[L1:[0-9]+]]=, $pop[[L0]], 1, $1{{$}}
504 ; SIMD128-NEXT: i16x8.replace_lane $push[[L2:[0-9]+]]=, $pop[[L1]], 2, $2{{$}}
505 ; SIMD128-NEXT: i16x8.replace_lane $push[[L3:[0-9]+]]=, $pop[[L2]], 3, $3{{$}}
506 ; SIMD128-NEXT: i16x8.replace_lane $push[[L4:[0-9]+]]=, $pop[[L3]], 4, $4{{$}}
507 ; SIMD128-NEXT: i16x8.replace_lane $push[[L5:[0-9]+]]=, $pop[[L4]], 5, $5{{$}}
508 ; SIMD128-NEXT: i16x8.replace_lane $push[[L6:[0-9]+]]=, $pop[[L5]], 6, $6{{$}}
509 ; SIMD128-NEXT: i16x8.replace_lane $push[[R:[0-9]+]]=, $pop[[L6]], 7, $7{{$}}
510 ; SIMD128-NEXT: return $pop[[R]]{{$}}
528 ; NO-SIMD128-NOT: i32x4
529 ; SIMD128-VM-NOT: v128.const
530 ; SIMD128-NEXT: .functype const_v4i32 () -> (v128){{$}}
531 ; SIMD128-NEXT: v128.const $push[[R:[0-9]+]]=, 50462976, 117835012, 185207048, 252579084{{$}}
532 ; SIMD128-NEXT: return $pop[[R]]{{$}}
538 ; NO-SIMD128-NOT: i32x4
539 ; SIMD128-NEXT: .functype splat_v4i32 (i32) -> (v128){{$}}
540 ; SIMD128-NEXT: i32x4.splat $push[[R:[0-9]+]]=, $0{{$}}
541 ; SIMD128-NEXT: return $pop[[R]]{{$}}
550 ; SIMD128: v128.const $push0=, 42, 42, 42, 42{{$}}
556 ; NO-SIMD128-NOT: i32x4
557 ; SIMD128-NEXT: .functype extract_v4i32 (v128) -> (i32){{$}}
558 ; SIMD128-NEXT: i32x4.extract_lane $push[[R:[0-9]+]]=, $0, 3{{$}}
559 ; SIMD128-NEXT: return $pop[[R]]{{$}}
566 ; NO-SIMD128-NOT: i32x4
567 ; SIMD128-NEXT: .functype extract_var_v4i32 (v128, i32) -> (i32){{$}}
568 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
569 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
570 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
571 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}}
572 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
573 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 3{{$}}
574 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}}
575 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 2{{$}}
576 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
577 ; SIMD128-NEXT: i32.or $push[[L4:[0-9]+]]=, $2, $pop[[L7]]{{$}}
578 ; SIMD128-NEXT: i32.load $push[[R:[0-9]+]]=, 0($pop[[L4]]){{$}}
579 ; SIMD128-NEXT: return $pop[[R]]{{$}}
586 ; NO-SIMD128-NOT: i32x4
587 ; SIMD128-NEXT: .functype extract_zero_v4i32 (v128) -> (i32){{$}}
588 ; SIMD128-NEXT: i32x4.extract_lane $push[[R:[0-9]+]]=, $0, 0{{$}}
589 ; SIMD128-NEXT: return $pop[[R]]{{$}}
596 ; NO-SIMD128-NOT: i32x4
597 ; SIMD128-NEXT: .functype replace_v4i32 (v128, i32) -> (v128){{$}}
598 ; SIMD128-NEXT: i32x4.replace_lane $push[[R:[0-9]+]]=, $0, 2, $1{{$}}
599 ; SIMD128-NEXT: return $pop[[R]]{{$}}
606 ; NO-SIMD128-NOT: i32x4
607 ; SIMD128-NEXT: .functype replace_var_v4i32 (v128, i32, i32) -> (v128){{$}}
608 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
609 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
610 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
611 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}}
612 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
613 ; SIMD128-NEXT: i32.const $push[[L4:[0-9]+]]=, 3{{$}}
614 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L4]]{{$}}
615 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 2{{$}}
616 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
617 ; SIMD128-NEXT: i32.or $push[[L4:[0-9]+]]=, $3, $pop[[L7]]{{$}}
618 ; SIMD128-NEXT: i32.store 0($pop[[L4]]), $2{{$}}
619 ; SIMD128-NEXT: v128.load $push[[R:[0-9]+]]=, 0($3){{$}}
620 ; SIMD128-NEXT: return $pop[[R]]{{$}}
627 ; NO-SIMD128-NOT: i32x4
628 ; SIMD128-NEXT: .functype replace_zero_v4i32 (v128, i32) -> (v128){{$}}
629 ; SIMD128-NEXT: i32x4.replace_lane $push[[R:[0-9]+]]=, $0, 0, $1{{$}}
630 ; SIMD128-NEXT: return $pop[[R]]{{$}}
637 ; NO-SIMD128-NOT: v8x16
638 ; SIMD128-NEXT: .functype shuffle_v4i32 (v128, v128) -> (v128){{$}}
639 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $1,
640 ; SIMD128-SAME: 0, 1, 2, 3, 20, 21, 22, 23, 8, 9, 10, 11, 28, 29, 30, 31{{$}}
641 ; SIMD128-NEXT: return $pop[[R]]{{$}}
649 ; NO-SIMD128-NOT: v8x16
650 ; SIMD128-NEXT: .functype shuffle_undef_v4i32 (v128, v128) -> (v128){{$}}
651 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $0,
652 ; SIMD128-SAME: 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0{{$}}
653 ; SIMD128-NEXT: return $pop[[R]]{{$}}
661 ; NO-SIMD128-NOT: i32x4
662 ; SIMD128-NEXT: .functype build_v4i32 (i32, i32, i32, i32) -> (v128){{$}}
663 ; SIMD128-NEXT: i32x4.splat $push[[L0:[0-9]+]]=, $0{{$}}
664 ; SIMD128-NEXT: i32x4.replace_lane $push[[L1:[0-9]+]]=, $pop[[L0]], 1, $1{{$}}
665 ; SIMD128-NEXT: i32x4.replace_lane $push[[L2:[0-9]+]]=, $pop[[L1]], 2, $2{{$}}
666 ; SIMD128-NEXT: i32x4.replace_lane $push[[R:[0-9]+]]=, $pop[[L2]], 3, $3{{$}}
667 ; SIMD128-NEXT: return $pop[[R]]{{$}}
680 ; NO-SIMD128-NOT: i64x2
681 ; SIMD128-VM-NOT: v128.const
682 ; SIMD128-NEXT: .functype const_v2i64 () -> (v128){{$}}
683 ; SIMD128-NEXT: v128.const $push[[R:[0-9]+]]=, 506097522914230528, 1084818905618843912{{$}}
684 ; SIMD128-NEXT: return $pop[[R]]{{$}}
690 ; NO-SIMD128-NOT: i64x2
691 ; SIMD128-NEXT: .functype splat_v2i64 (i64) -> (v128){{$}}
692 ; SIMD128-NEXT: i64x2.splat $push[[R:[0-9]+]]=, $0{{$}}
693 ; SIMD128-NEXT: return $pop[[R]]{{$}}
701 ; SIMD128: v128.const $push0=, 42, 42{{$}}
707 ; NO-SIMD128-NOT: i64x2
708 ; SIMD128-NEXT: .functype extract_v2i64 (v128) -> (i64){{$}}
709 ; SIMD128-NEXT: i64x2.extract_lane $push[[R:[0-9]+]]=, $0, 1{{$}}
710 ; SIMD128-NEXT: return $pop[[R]]{{$}}
717 ; NO-SIMD128-NOT: i64x2
718 ; SIMD128-NEXT: .functype extract_var_v2i64 (v128, i32) -> (i64){{$}}
719 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
720 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
721 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
722 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}}
723 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
724 ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 1{{$}}
725 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}}
726 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 3{{$}}
727 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
728 ; SIMD128-NEXT: i32.or $push[[L2:[0-9]+]]=, $2, $pop[[L7]]{{$}}
729 ; SIMD128-NEXT: i64.load $push[[R:[0-9]+]]=, 0($pop[[L2]]){{$}}
730 ; SIMD128-NEXT: return $pop[[R]]{{$}}
737 ; NO-SIMD128-NOT: i64x2
738 ; SIMD128-NEXT: .functype extract_zero_v2i64 (v128) -> (i64){{$}}
739 ; SIMD128-NEXT: i64x2.extract_lane $push[[R:[0-9]+]]=, $0, 0{{$}}
740 ; SIMD128-NEXT: return $pop[[R]]{{$}}
747 ; NO-SIMD128-NOT: i64x2
748 ; SIMD128-NEXT: .functype replace_v2i64 (v128, i64) -> (v128){{$}}
749 ; SIMD128-NEXT: i64x2.replace_lane $push[[R:[0-9]+]]=, $0, 0, $1{{$}}
750 ; SIMD128-NEXT: return $pop[[R]]{{$}}
757 ; NO-SIMD128-NOT: i64x2
758 ; SIMD128-NEXT: .functype replace_var_v2i64 (v128, i32, i64) -> (v128){{$}}
759 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
760 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
761 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
762 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}}
763 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
764 ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 1{{$}}
765 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}}
766 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 3{{$}}
767 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
768 ; SIMD128-NEXT: i32.or $push[[L2:[0-9]+]]=, $3, $pop[[L7]]{{$}}
769 ; SIMD128-NEXT: i64.store 0($pop[[L2]]), $2{{$}}
770 ; SIMD128-NEXT: v128.load $push[[R:[0-9]+]]=, 0($3){{$}}
771 ; SIMD128-NEXT: return $pop[[R]]{{$}}
778 ; NO-SIMD128-NOT: i64x2
779 ; SIMD128-NEXT: .functype replace_zero_v2i64 (v128, i64) -> (v128){{$}}
780 ; SIMD128-NEXT: i64x2.replace_lane $push[[R:[0-9]+]]=, $0, 0, $1{{$}}
781 ; SIMD128-NEXT: return $pop[[R]]{{$}}
788 ; NO-SIMD128-NOT: v8x16
789 ; SIMD128-NEXT: .functype shuffle_v2i64 (v128, v128) -> (v128){{$}}
790 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $1,
791 ; SIMD128-SAME: 0, 1, 2, 3, 4, 5, 6, 7, 24, 25, 26, 27, 28, 29, 30, 31{{$}}
792 ; SIMD128-NEXT: return $pop[[R]]{{$}}
799 ; NO-SIMD128-NOT: v8x16
800 ; SIMD128-NEXT: .functype shuffle_undef_v2i64 (v128, v128) -> (v128){{$}}
801 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $0,
802 ; SIMD128-SAME: 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0{{$}}
803 ; SIMD128-NEXT: return $pop[[R]]{{$}}
811 ; NO-SIMD128-NOT: i64x2
812 ; SIMD128-NEXT: .functype build_v2i64 (i64, i64) -> (v128){{$}}
813 ; SIMD128-NEXT: i64x2.splat $push[[L0:[0-9]+]]=, $0{{$}}
814 ; SIMD128-NEXT: i64x2.replace_lane $push[[R:[0-9]+]]=, $pop[[L0]], 1, $1{{$}}
815 ; SIMD128-NEXT: return $pop[[R]]{{$}}
826 ; NO-SIMD128-NOT: f32x4
827 ; SIMD128-VM-NOT: v128.const
828 ; SIMD128-NEXT: .functype const_v4f32 () -> (v128){{$}}
829 ; SIMD128-NEXT: v128.const $push[[R:[0-9]+]]=,
830 ; SIMD128-SAME: 0x1.0402p-121, 0x1.0c0a08p-113, 0x1.14121p-105, 0x1.1c1a18p-97{{$}}
831 ; SIMD128-NEXT: return $pop[[R]]{{$}}
838 ; NO-SIMD128-NOT: f32x4
839 ; SIMD128-NEXT: .functype splat_v4f32 (f32) -> (v128){{$}}
840 ; SIMD128-NEXT: f32x4.splat $push[[R:[0-9]+]]=, $0{{$}}
841 ; SIMD128-NEXT: return $pop[[R]]{{$}}
850 ; SIMD128: v128.const $push0=, 0x1.5p5, 0x1.5p5, 0x1.5p5, 0x1.5p5{{$}}
856 ; NO-SIMD128-NOT: f32x4
857 ; SIMD128-NEXT: .functype extract_v4f32 (v128) -> (f32){{$}}
858 ; SIMD128-NEXT: f32x4.extract_lane $push[[R:[0-9]+]]=, $0, 3{{$}}
859 ; SIMD128-NEXT: return $pop[[R]]{{$}}
866 ; NO-SIMD128-NOT: i64x2
867 ; SIMD128-NEXT: .functype extract_var_v4f32 (v128, i32) -> (f32){{$}}
868 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
869 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
870 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
871 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}}
872 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
873 ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 3{{$}}
874 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}}
875 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 2{{$}}
876 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
877 ; SIMD128-NEXT: i32.or $push[[L2:[0-9]+]]=, $2, $pop[[L7]]{{$}}
878 ; SIMD128-NEXT: f32.load $push[[R:[0-9]+]]=, 0($pop[[L2]]){{$}}
879 ; SIMD128-NEXT: return $pop[[R]]{{$}}
886 ; NO-SIMD128-NOT: f32x4
887 ; SIMD128-NEXT: .functype extract_zero_v4f32 (v128) -> (f32){{$}}
888 ; SIMD128-NEXT: f32x4.extract_lane $push[[R:[0-9]+]]=, $0, 0{{$}}
889 ; SIMD128-NEXT: return $pop[[R]]{{$}}
896 ; NO-SIMD128-NOT: f32x4
897 ; SIMD128-NEXT: .functype replace_v4f32 (v128, f32) -> (v128){{$}}
898 ; SIMD128-NEXT: f32x4.replace_lane $push[[R:[0-9]+]]=, $0, 2, $1{{$}}
899 ; SIMD128-NEXT: return $pop[[R]]{{$}}
906 ; NO-SIMD128-NOT: f32x4
907 ; SIMD128-NEXT: .functype replace_var_v4f32 (v128, i32, f32) -> (v128){{$}}
908 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
909 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
910 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
911 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}}
912 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
913 ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 3{{$}}
914 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}}
915 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 2{{$}}
916 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
917 ; SIMD128-NEXT: i32.or $push[[L2:[0-9]+]]=, $3, $pop[[L7]]{{$}}
918 ; SIMD128-NEXT: f32.store 0($pop[[L2]]), $2{{$}}
919 ; SIMD128-NEXT: v128.load $push[[R:[0-9]+]]=, 0($3){{$}}
920 ; SIMD128-NEXT: return $pop[[R]]{{$}}
927 ; NO-SIMD128-NOT: f32x4
928 ; SIMD128-NEXT: .functype replace_zero_v4f32 (v128, f32) -> (v128){{$}}
929 ; SIMD128-NEXT: f32x4.replace_lane $push[[R:[0-9]+]]=, $0, 0, $1{{$}}
930 ; SIMD128-NEXT: return $pop[[R]]{{$}}
937 ; NO-SIMD128-NOT: v8x16
938 ; SIMD128-NEXT: .functype shuffle_v4f32 (v128, v128) -> (v128){{$}}
939 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $1,
940 ; SIMD128-SAME: 0, 1, 2, 3, 20, 21, 22, 23, 8, 9, 10, 11, 28, 29, 30, 31{{$}}
941 ; SIMD128-NEXT: return $pop[[R]]{{$}}
949 ; NO-SIMD128-NOT: v8x16
950 ; SIMD128-NEXT: .functype shuffle_undef_v4f32 (v128, v128) -> (v128){{$}}
951 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $0,
952 ; SIMD128-SAME: 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0{{$}}
953 ; SIMD128-NEXT: return $pop[[R]]{{$}}
961 ; NO-SIMD128-NOT: f32x4
962 ; SIMD128-NEXT: .functype build_v4f32 (f32, f32, f32, f32) -> (v128){{$}}
963 ; SIMD128-NEXT: f32x4.splat $push[[L0:[0-9]+]]=, $0{{$}}
964 ; SIMD128-NEXT: f32x4.replace_lane $push[[L1:[0-9]+]]=, $pop[[L0]], 1, $1{{$}}
965 ; SIMD128-NEXT: f32x4.replace_lane $push[[L2:[0-9]+]]=, $pop[[L1]], 2, $2{{$}}
966 ; SIMD128-NEXT: f32x4.replace_lane $push[[R:[0-9]+]]=, $pop[[L2]], 3, $3{{$}}
967 ; SIMD128-NEXT: return $pop[[R]]{{$}}
980 ; NO-SIMD128-NOT: f64x2
981 ; SIMD128-VM-NOT: v128.const
982 ; SIMD128-NEXT: .functype const_v2f64 () -> (v128){{$}}
983 ; SIMD128-NEXT: v128.const $push[[R:[0-9]+]]=, 0x1.60504030201p-911, 0x1.e0d0c0b0a0908p-783{{$}}
984 ; SIMD128-NEXT: return $pop[[R]]{{$}}
990 ; NO-SIMD128-NOT: f64x2
991 ; SIMD128-NEXT: .functype splat_v2f64 (f64) -> (v128){{$}}
992 ; SIMD128-NEXT: f64x2.splat $push[[R:[0-9]+]]=, $0{{$}}
993 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1001 ; SIMD128: v128.const $push0=, 0x1.5p5, 0x1.5p5{{$}}
1007 ; NO-SIMD128-NOT: f64x2
1008 ; SIMD128-NEXT: .functype extract_v2f64 (v128) -> (f64){{$}}
1009 ; SIMD128-NEXT: f64x2.extract_lane $push[[R:[0-9]+]]=, $0, 1{{$}}
1010 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1017 ; NO-SIMD128-NOT: i62x2
1018 ; SIMD128-NEXT: .functype extract_var_v2f64 (v128, i32) -> (f64){{$}}
1019 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
1020 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
1021 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
1022 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $2=, $pop[[L2]]{{$}}
1023 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
1024 ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 1{{$}}
1025 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}}
1026 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 3{{$}}
1027 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
1028 ; SIMD128-NEXT: i32.or $push[[L2:[0-9]+]]=, $2, $pop[[L7]]{{$}}
1029 ; SIMD128-NEXT: f64.load $push[[R:[0-9]+]]=, 0($pop[[L2]]){{$}}
1030 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1037 ; NO-SIMD128-NOT: f64x2
1038 ; SIMD128-NEXT: .functype extract_zero_v2f64 (v128) -> (f64){{$}}
1039 ; SIMD128-NEXT: f64x2.extract_lane $push[[R:[0-9]+]]=, $0, 0{{$}}
1040 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1047 ; NO-SIMD128-NOT: f64x2
1048 ; SIMD128-NEXT: .functype replace_v2f64 (v128, f64) -> (v128){{$}}
1049 ; SIMD128-NEXT: f64x2.replace_lane $push[[R:[0-9]+]]=, $0, 0, $1{{$}}
1050 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1057 ; NO-SIMD128-NOT: f64x2
1058 ; SIMD128-NEXT: .functype replace_var_v2f64 (v128, i32, f64) -> (v128){{$}}
1059 ; SIMD128-NEXT: global.get $push[[L0:[0-9]+]]=, __stack_pointer{{$}}
1060 ; SIMD128-NEXT: i32.const $push[[L1:[0-9]+]]=, 16{{$}}
1061 ; SIMD128-NEXT: i32.sub $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}}
1062 ; SIMD128-NEXT: local.tee $push[[L3:[0-9]+]]=, $3=, $pop[[L2]]{{$}}
1063 ; SIMD128-NEXT: v128.store 0($pop[[L3]]), $0{{$}}
1064 ; SIMD128-NEXT: i32.const $push[[L2:[0-9]+]]=, 1{{$}}
1065 ; SIMD128-NEXT: i32.and $push[[L5:[0-9]+]]=, $1, $pop[[L2]]{{$}}
1066 ; SIMD128-NEXT: i32.const $push[[L6:[0-9]+]]=, 3{{$}}
1067 ; SIMD128-NEXT: i32.shl $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}}
1068 ; SIMD128-NEXT: i32.or $push[[L2:[0-9]+]]=, $3, $pop[[L7]]{{$}}
1069 ; SIMD128-NEXT: f64.store 0($pop[[L2]]), $2{{$}}
1070 ; SIMD128-NEXT: v128.load $push[[R:[0-9]+]]=, 0($3){{$}}
1071 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1078 ; NO-SIMD128-NOT: f64x2
1079 ; SIMD128-NEXT: .functype replace_zero_v2f64 (v128, f64) -> (v128){{$}}
1080 ; SIMD128-NEXT: f64x2.replace_lane $push[[R:[0-9]+]]=, $0, 0, $1{{$}}
1081 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1088 ; NO-SIMD128-NOT: v8x16
1089 ; SIMD128-NEXT: .functype shuffle_v2f64 (v128, v128) -> (v128){{$}}
1090 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $1,
1091 ; SIMD128-SAME: 0, 1, 2, 3, 4, 5, 6, 7, 24, 25, 26, 27, 28, 29, 30, 31{{$}}
1092 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1100 ; NO-SIMD128-NOT: v8x16
1101 ; SIMD128-NEXT: .functype shuffle_undef_v2f64 (v128, v128) -> (v128){{$}}
1102 ; SIMD128-NEXT: v8x16.shuffle $push[[R:[0-9]+]]=, $0, $0,
1103 ; SIMD128-SAME: 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0{{$}}
1104 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1112 ; NO-SIMD128-NOT: f64x2
1113 ; SIMD128-NEXT: .functype build_v2f64 (f64, f64) -> (v128){{$}}
1114 ; SIMD128-NEXT: f64x2.splat $push[[L0:[0-9]+]]=, $0{{$}}
1115 ; SIMD128-NEXT: f64x2.replace_lane $push[[R:[0-9]+]]=, $pop[[L0]], 1, $1{{$}}
1116 ; SIMD128-NEXT: return $pop[[R]]{{$}}