1 // WebAssemblyInstrSIMD.td - WebAssembly SIMD codegen support -*- tablegen -*-//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
10 /// WebAssembly SIMD operand code-gen constructs.
12 //===----------------------------------------------------------------------===//
14 // Instructions requiring HasSIMD128 and the simd128 prefix byte
15 multiclass SIMD_I<dag oops_r, dag iops_r, dag oops_s, dag iops_s,
16 list<dag> pattern_r, string asmstr_r = "",
17 string asmstr_s = "", bits<32> simdop = -1> {
18 defm "" : I<oops_r, iops_r, oops_s, iops_s, pattern_r, asmstr_r, asmstr_s,
19 !or(0xfd00, !and(0xff, simdop))>,
20 Requires<[HasSIMD128]>;
23 defm "" : ARGUMENT<V128, v16i8>;
24 defm "" : ARGUMENT<V128, v8i16>;
25 defm "" : ARGUMENT<V128, v4i32>;
26 defm "" : ARGUMENT<V128, v2i64>;
27 defm "" : ARGUMENT<V128, v4f32>;
28 defm "" : ARGUMENT<V128, v2f64>;
30 // Constrained immediate argument types
31 foreach SIZE = [8, 16] in
32 def ImmI#SIZE : ImmLeaf<i32,
33 "return -(1 << ("#SIZE#" - 1)) <= Imm && Imm < (1 << ("#SIZE#" - 1));"
35 foreach SIZE = [2, 4, 8, 16, 32] in
36 def LaneIdx#SIZE : ImmLeaf<i32, "return 0 <= Imm && Imm < "#SIZE#";">;
38 //===----------------------------------------------------------------------===//
40 //===----------------------------------------------------------------------===//
43 let mayLoad = 1, UseNamedOperandTable = 1 in {
45 SIMD_I<(outs V128:$dst), (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
46 (outs), (ins P2Align:$p2align, offset32_op:$off), [],
47 "v128.load\t$dst, ${off}(${addr})$p2align",
48 "v128.load\t$off$p2align", 0>;
50 SIMD_I<(outs V128:$dst), (ins P2Align:$p2align, offset64_op:$off, I64:$addr),
51 (outs), (ins P2Align:$p2align, offset64_op:$off), [],
52 "v128.load\t$dst, ${off}(${addr})$p2align",
53 "v128.load\t$off$p2align", 0>;
56 // Def load and store patterns from WebAssemblyInstrMemory.td for vector types
57 foreach vec_t = [v16i8, v8i16, v4i32, v2i64, v4f32, v2f64] in {
58 defm : LoadPatNoOffset<vec_t, load, "LOAD_V128">;
59 defm : LoadPatImmOff<vec_t, load, regPlusImm, "LOAD_V128">;
60 defm : LoadPatImmOff<vec_t, load, or_is_add, "LOAD_V128">;
61 defm : LoadPatOffsetOnly<vec_t, load, "LOAD_V128">;
62 defm : LoadPatGlobalAddrOffOnly<vec_t, load, "LOAD_V128">;
66 multiclass SIMDLoadSplat<string vec, bits<32> simdop> {
67 let mayLoad = 1, UseNamedOperandTable = 1 in {
68 defm LOAD_SPLAT_#vec#_A32 :
69 SIMD_I<(outs V128:$dst),
70 (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
72 (ins P2Align:$p2align, offset32_op:$off), [],
73 vec#".load_splat\t$dst, ${off}(${addr})$p2align",
74 vec#".load_splat\t$off$p2align", simdop>;
75 defm LOAD_SPLAT_#vec#_A64 :
76 SIMD_I<(outs V128:$dst),
77 (ins P2Align:$p2align, offset64_op:$off, I64:$addr),
79 (ins P2Align:$p2align, offset64_op:$off), [],
80 vec#".load_splat\t$dst, ${off}(${addr})$p2align",
81 vec#".load_splat\t$off$p2align", simdop>;
85 defm "" : SIMDLoadSplat<"v8x16", 7>;
86 defm "" : SIMDLoadSplat<"v16x8", 8>;
87 defm "" : SIMDLoadSplat<"v32x4", 9>;
88 defm "" : SIMDLoadSplat<"v64x2", 10>;
90 def wasm_load_splat_t : SDTypeProfile<1, 1, [SDTCisPtrTy<1>]>;
91 def wasm_load_splat : SDNode<"WebAssemblyISD::LOAD_SPLAT", wasm_load_splat_t,
92 [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
93 def load_splat : PatFrag<(ops node:$addr), (wasm_load_splat node:$addr)>;
95 foreach args = [["v16i8", "v8x16"], ["v8i16", "v16x8"], ["v4i32", "v32x4"],
96 ["v2i64", "v64x2"], ["v4f32", "v32x4"], ["v2f64", "v64x2"]] in {
97 defm : LoadPatNoOffset<!cast<ValueType>(args[0]),
99 "LOAD_SPLAT_"#args[1]>;
100 defm : LoadPatImmOff<!cast<ValueType>(args[0]),
103 "LOAD_SPLAT_"#args[1]>;
104 defm : LoadPatImmOff<!cast<ValueType>(args[0]),
107 "LOAD_SPLAT_"#args[1]>;
108 defm : LoadPatOffsetOnly<!cast<ValueType>(args[0]),
110 "LOAD_SPLAT_"#args[1]>;
111 defm : LoadPatGlobalAddrOffOnly<!cast<ValueType>(args[0]),
113 "LOAD_SPLAT_"#args[1]>;
117 multiclass SIMDLoadExtend<ValueType vec_t, string name, bits<32> simdop> {
118 let mayLoad = 1, UseNamedOperandTable = 1 in {
119 defm LOAD_EXTEND_S_#vec_t#_A32 :
120 SIMD_I<(outs V128:$dst),
121 (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
122 (outs), (ins P2Align:$p2align, offset32_op:$off), [],
123 name#"_s\t$dst, ${off}(${addr})$p2align",
124 name#"_s\t$off$p2align", simdop>;
125 defm LOAD_EXTEND_U_#vec_t#_A32 :
126 SIMD_I<(outs V128:$dst),
127 (ins P2Align:$p2align, offset32_op:$off, I32:$addr),
128 (outs), (ins P2Align:$p2align, offset32_op:$off), [],
129 name#"_u\t$dst, ${off}(${addr})$p2align",
130 name#"_u\t$off$p2align", !add(simdop, 1)>;
131 defm LOAD_EXTEND_S_#vec_t#_A64 :
132 SIMD_I<(outs V128:$dst),
133 (ins P2Align:$p2align, offset64_op:$off, I64:$addr),
134 (outs), (ins P2Align:$p2align, offset64_op:$off), [],
135 name#"_s\t$dst, ${off}(${addr})$p2align",
136 name#"_s\t$off$p2align", simdop>;
137 defm LOAD_EXTEND_U_#vec_t#_A64 :
138 SIMD_I<(outs V128:$dst),
139 (ins P2Align:$p2align, offset64_op:$off, I64:$addr),
140 (outs), (ins P2Align:$p2align, offset64_op:$off), [],
141 name#"_u\t$dst, ${off}(${addr})$p2align",
142 name#"_u\t$off$p2align", !add(simdop, 1)>;
146 defm "" : SIMDLoadExtend<v8i16, "i16x8.load8x8", 1>;
147 defm "" : SIMDLoadExtend<v4i32, "i32x4.load16x4", 3>;
148 defm "" : SIMDLoadExtend<v2i64, "i64x2.load32x2", 5>;
150 foreach types = [[v8i16, i8], [v4i32, i16], [v2i64, i32]] in
151 foreach exts = [["sextloadv", "_S"],
153 ["extloadv", "_U"]] in {
154 defm : LoadPatNoOffset<types[0], !cast<PatFrag>(exts[0]#types[1]),
155 "LOAD_EXTEND"#exts[1]#"_"#types[0]>;
156 defm : LoadPatImmOff<types[0], !cast<PatFrag>(exts[0]#types[1]), regPlusImm,
157 "LOAD_EXTEND"#exts[1]#"_"#types[0]>;
158 defm : LoadPatImmOff<types[0], !cast<PatFrag>(exts[0]#types[1]), or_is_add,
159 "LOAD_EXTEND"#exts[1]#"_"#types[0]>;
160 defm : LoadPatOffsetOnly<types[0], !cast<PatFrag>(exts[0]#types[1]),
161 "LOAD_EXTEND"#exts[1]#"_"#types[0]>;
162 defm : LoadPatGlobalAddrOffOnly<types[0], !cast<PatFrag>(exts[0]#types[1]),
163 "LOAD_EXTEND"#exts[1]#"_"#types[0]>;
168 let mayStore = 1, UseNamedOperandTable = 1 in {
169 defm STORE_V128_A32 :
170 SIMD_I<(outs), (ins P2Align:$p2align, offset32_op:$off, I32:$addr, V128:$vec),
171 (outs), (ins P2Align:$p2align, offset32_op:$off), [],
172 "v128.store\t${off}(${addr})$p2align, $vec",
173 "v128.store\t$off$p2align", 11>;
174 defm STORE_V128_A64 :
175 SIMD_I<(outs), (ins P2Align:$p2align, offset64_op:$off, I64:$addr, V128:$vec),
176 (outs), (ins P2Align:$p2align, offset64_op:$off), [],
177 "v128.store\t${off}(${addr})$p2align, $vec",
178 "v128.store\t$off$p2align", 11>;
180 foreach vec_t = [v16i8, v8i16, v4i32, v2i64, v4f32, v2f64] in {
181 // Def load and store patterns from WebAssemblyInstrMemory.td for vector types
182 defm : StorePatNoOffset<vec_t, store, "STORE_V128">;
183 defm : StorePatImmOff<vec_t, store, regPlusImm, "STORE_V128">;
184 defm : StorePatImmOff<vec_t, store, or_is_add, "STORE_V128">;
185 defm : StorePatOffsetOnly<vec_t, store, "STORE_V128">;
186 defm : StorePatGlobalAddrOffOnly<vec_t, store, "STORE_V128">;
189 //===----------------------------------------------------------------------===//
190 // Constructing SIMD values
191 //===----------------------------------------------------------------------===//
193 // Constant: v128.const
194 multiclass ConstVec<ValueType vec_t, dag ops, dag pat, string args> {
195 let isMoveImm = 1, isReMaterializable = 1,
196 Predicates = [HasUnimplementedSIMD128] in
197 defm CONST_V128_#vec_t : SIMD_I<(outs V128:$dst), ops, (outs), ops,
198 [(set V128:$dst, (vec_t pat))],
199 "v128.const\t$dst, "#args,
200 "v128.const\t"#args, 12>;
203 defm "" : ConstVec<v16i8,
204 (ins vec_i8imm_op:$i0, vec_i8imm_op:$i1,
205 vec_i8imm_op:$i2, vec_i8imm_op:$i3,
206 vec_i8imm_op:$i4, vec_i8imm_op:$i5,
207 vec_i8imm_op:$i6, vec_i8imm_op:$i7,
208 vec_i8imm_op:$i8, vec_i8imm_op:$i9,
209 vec_i8imm_op:$iA, vec_i8imm_op:$iB,
210 vec_i8imm_op:$iC, vec_i8imm_op:$iD,
211 vec_i8imm_op:$iE, vec_i8imm_op:$iF),
212 (build_vector ImmI8:$i0, ImmI8:$i1, ImmI8:$i2, ImmI8:$i3,
213 ImmI8:$i4, ImmI8:$i5, ImmI8:$i6, ImmI8:$i7,
214 ImmI8:$i8, ImmI8:$i9, ImmI8:$iA, ImmI8:$iB,
215 ImmI8:$iC, ImmI8:$iD, ImmI8:$iE, ImmI8:$iF),
216 !strconcat("$i0, $i1, $i2, $i3, $i4, $i5, $i6, $i7, ",
217 "$i8, $i9, $iA, $iB, $iC, $iD, $iE, $iF")>;
218 defm "" : ConstVec<v8i16,
219 (ins vec_i16imm_op:$i0, vec_i16imm_op:$i1,
220 vec_i16imm_op:$i2, vec_i16imm_op:$i3,
221 vec_i16imm_op:$i4, vec_i16imm_op:$i5,
222 vec_i16imm_op:$i6, vec_i16imm_op:$i7),
224 ImmI16:$i0, ImmI16:$i1, ImmI16:$i2, ImmI16:$i3,
225 ImmI16:$i4, ImmI16:$i5, ImmI16:$i6, ImmI16:$i7),
226 "$i0, $i1, $i2, $i3, $i4, $i5, $i6, $i7">;
227 let IsCanonical = 1 in
228 defm "" : ConstVec<v4i32,
229 (ins vec_i32imm_op:$i0, vec_i32imm_op:$i1,
230 vec_i32imm_op:$i2, vec_i32imm_op:$i3),
231 (build_vector (i32 imm:$i0), (i32 imm:$i1),
232 (i32 imm:$i2), (i32 imm:$i3)),
233 "$i0, $i1, $i2, $i3">;
234 defm "" : ConstVec<v2i64,
235 (ins vec_i64imm_op:$i0, vec_i64imm_op:$i1),
236 (build_vector (i64 imm:$i0), (i64 imm:$i1)),
238 defm "" : ConstVec<v4f32,
239 (ins f32imm_op:$i0, f32imm_op:$i1,
240 f32imm_op:$i2, f32imm_op:$i3),
241 (build_vector (f32 fpimm:$i0), (f32 fpimm:$i1),
242 (f32 fpimm:$i2), (f32 fpimm:$i3)),
243 "$i0, $i1, $i2, $i3">;
244 defm "" : ConstVec<v2f64,
245 (ins f64imm_op:$i0, f64imm_op:$i1),
246 (build_vector (f64 fpimm:$i0), (f64 fpimm:$i1)),
249 // Shuffle lanes: shuffle
251 SIMD_I<(outs V128:$dst),
252 (ins V128:$x, V128:$y,
253 vec_i8imm_op:$m0, vec_i8imm_op:$m1,
254 vec_i8imm_op:$m2, vec_i8imm_op:$m3,
255 vec_i8imm_op:$m4, vec_i8imm_op:$m5,
256 vec_i8imm_op:$m6, vec_i8imm_op:$m7,
257 vec_i8imm_op:$m8, vec_i8imm_op:$m9,
258 vec_i8imm_op:$mA, vec_i8imm_op:$mB,
259 vec_i8imm_op:$mC, vec_i8imm_op:$mD,
260 vec_i8imm_op:$mE, vec_i8imm_op:$mF),
263 vec_i8imm_op:$m0, vec_i8imm_op:$m1,
264 vec_i8imm_op:$m2, vec_i8imm_op:$m3,
265 vec_i8imm_op:$m4, vec_i8imm_op:$m5,
266 vec_i8imm_op:$m6, vec_i8imm_op:$m7,
267 vec_i8imm_op:$m8, vec_i8imm_op:$m9,
268 vec_i8imm_op:$mA, vec_i8imm_op:$mB,
269 vec_i8imm_op:$mC, vec_i8imm_op:$mD,
270 vec_i8imm_op:$mE, vec_i8imm_op:$mF),
272 "v8x16.shuffle\t$dst, $x, $y, "#
273 "$m0, $m1, $m2, $m3, $m4, $m5, $m6, $m7, "#
274 "$m8, $m9, $mA, $mB, $mC, $mD, $mE, $mF",
276 "$m0, $m1, $m2, $m3, $m4, $m5, $m6, $m7, "#
277 "$m8, $m9, $mA, $mB, $mC, $mD, $mE, $mF",
280 // Shuffles after custom lowering
281 def wasm_shuffle_t : SDTypeProfile<1, 18, []>;
282 def wasm_shuffle : SDNode<"WebAssemblyISD::SHUFFLE", wasm_shuffle_t>;
283 foreach vec_t = [v16i8, v8i16, v4i32, v2i64, v4f32, v2f64] in {
284 def : Pat<(vec_t (wasm_shuffle (vec_t V128:$x), (vec_t V128:$y),
285 (i32 LaneIdx32:$m0), (i32 LaneIdx32:$m1),
286 (i32 LaneIdx32:$m2), (i32 LaneIdx32:$m3),
287 (i32 LaneIdx32:$m4), (i32 LaneIdx32:$m5),
288 (i32 LaneIdx32:$m6), (i32 LaneIdx32:$m7),
289 (i32 LaneIdx32:$m8), (i32 LaneIdx32:$m9),
290 (i32 LaneIdx32:$mA), (i32 LaneIdx32:$mB),
291 (i32 LaneIdx32:$mC), (i32 LaneIdx32:$mD),
292 (i32 LaneIdx32:$mE), (i32 LaneIdx32:$mF))),
293 (vec_t (SHUFFLE (vec_t V128:$x), (vec_t V128:$y),
294 (i32 LaneIdx32:$m0), (i32 LaneIdx32:$m1),
295 (i32 LaneIdx32:$m2), (i32 LaneIdx32:$m3),
296 (i32 LaneIdx32:$m4), (i32 LaneIdx32:$m5),
297 (i32 LaneIdx32:$m6), (i32 LaneIdx32:$m7),
298 (i32 LaneIdx32:$m8), (i32 LaneIdx32:$m9),
299 (i32 LaneIdx32:$mA), (i32 LaneIdx32:$mB),
300 (i32 LaneIdx32:$mC), (i32 LaneIdx32:$mD),
301 (i32 LaneIdx32:$mE), (i32 LaneIdx32:$mF)))>;
304 // Swizzle lanes: v8x16.swizzle
305 def wasm_swizzle_t : SDTypeProfile<1, 2, []>;
306 def wasm_swizzle : SDNode<"WebAssemblyISD::SWIZZLE", wasm_swizzle_t>;
308 SIMD_I<(outs V128:$dst), (ins V128:$src, V128:$mask), (outs), (ins),
309 [(set (v16i8 V128:$dst),
310 (wasm_swizzle (v16i8 V128:$src), (v16i8 V128:$mask)))],
311 "v8x16.swizzle\t$dst, $src, $mask", "v8x16.swizzle", 14>;
313 def : Pat<(int_wasm_swizzle (v16i8 V128:$src), (v16i8 V128:$mask)),
314 (SWIZZLE V128:$src, V128:$mask)>;
316 // Create vector with identical lanes: splat
317 def splat2 : PatFrag<(ops node:$x), (build_vector node:$x, node:$x)>;
318 def splat4 : PatFrag<(ops node:$x), (build_vector
319 node:$x, node:$x, node:$x, node:$x)>;
320 def splat8 : PatFrag<(ops node:$x), (build_vector
321 node:$x, node:$x, node:$x, node:$x,
322 node:$x, node:$x, node:$x, node:$x)>;
323 def splat16 : PatFrag<(ops node:$x), (build_vector
324 node:$x, node:$x, node:$x, node:$x,
325 node:$x, node:$x, node:$x, node:$x,
326 node:$x, node:$x, node:$x, node:$x,
327 node:$x, node:$x, node:$x, node:$x)>;
329 multiclass Splat<ValueType vec_t, string vec, WebAssemblyRegClass reg_t,
330 PatFrag splat_pat, bits<32> simdop> {
331 defm SPLAT_#vec_t : SIMD_I<(outs V128:$dst), (ins reg_t:$x), (outs), (ins),
332 [(set (vec_t V128:$dst), (splat_pat reg_t:$x))],
333 vec#".splat\t$dst, $x", vec#".splat", simdop>;
336 defm "" : Splat<v16i8, "i8x16", I32, splat16, 15>;
337 defm "" : Splat<v8i16, "i16x8", I32, splat8, 16>;
338 defm "" : Splat<v4i32, "i32x4", I32, splat4, 17>;
339 defm "" : Splat<v2i64, "i64x2", I64, splat2, 18>;
340 defm "" : Splat<v4f32, "f32x4", F32, splat4, 19>;
341 defm "" : Splat<v2f64, "f64x2", F64, splat2, 20>;
343 // scalar_to_vector leaves high lanes undefined, so can be a splat
344 class ScalarSplatPat<ValueType vec_t, ValueType lane_t,
345 WebAssemblyRegClass reg_t> :
346 Pat<(vec_t (scalar_to_vector (lane_t reg_t:$x))),
347 (!cast<Instruction>("SPLAT_"#vec_t) reg_t:$x)>;
349 def : ScalarSplatPat<v16i8, i32, I32>;
350 def : ScalarSplatPat<v8i16, i32, I32>;
351 def : ScalarSplatPat<v4i32, i32, I32>;
352 def : ScalarSplatPat<v2i64, i64, I64>;
353 def : ScalarSplatPat<v4f32, f32, F32>;
354 def : ScalarSplatPat<v2f64, f64, F64>;
356 //===----------------------------------------------------------------------===//
358 //===----------------------------------------------------------------------===//
360 // Extract lane as a scalar: extract_lane / extract_lane_s / extract_lane_u
361 multiclass ExtractLane<ValueType vec_t, string vec, WebAssemblyRegClass reg_t,
362 bits<32> simdop, string suffix = ""> {
363 defm EXTRACT_LANE_#vec_t#suffix :
364 SIMD_I<(outs reg_t:$dst), (ins V128:$vec, vec_i8imm_op:$idx),
365 (outs), (ins vec_i8imm_op:$idx), [],
366 vec#".extract_lane"#suffix#"\t$dst, $vec, $idx",
367 vec#".extract_lane"#suffix#"\t$idx", simdop>;
370 defm "" : ExtractLane<v16i8, "i8x16", I32, 21, "_s">;
371 defm "" : ExtractLane<v16i8, "i8x16", I32, 22, "_u">;
372 defm "" : ExtractLane<v8i16, "i16x8", I32, 24, "_s">;
373 defm "" : ExtractLane<v8i16, "i16x8", I32, 25, "_u">;
374 defm "" : ExtractLane<v4i32, "i32x4", I32, 27>;
375 defm "" : ExtractLane<v2i64, "i64x2", I64, 29>;
376 defm "" : ExtractLane<v4f32, "f32x4", F32, 31>;
377 defm "" : ExtractLane<v2f64, "f64x2", F64, 33>;
379 def : Pat<(vector_extract (v16i8 V128:$vec), (i32 LaneIdx16:$idx)),
380 (EXTRACT_LANE_v16i8_u V128:$vec, imm:$idx)>;
381 def : Pat<(vector_extract (v8i16 V128:$vec), (i32 LaneIdx8:$idx)),
382 (EXTRACT_LANE_v8i16_u V128:$vec, imm:$idx)>;
383 def : Pat<(vector_extract (v4i32 V128:$vec), (i32 LaneIdx4:$idx)),
384 (EXTRACT_LANE_v4i32 V128:$vec, imm:$idx)>;
385 def : Pat<(vector_extract (v4f32 V128:$vec), (i32 LaneIdx4:$idx)),
386 (EXTRACT_LANE_v4f32 V128:$vec, imm:$idx)>;
387 def : Pat<(vector_extract (v2i64 V128:$vec), (i32 LaneIdx2:$idx)),
388 (EXTRACT_LANE_v2i64 V128:$vec, imm:$idx)>;
389 def : Pat<(vector_extract (v2f64 V128:$vec), (i32 LaneIdx2:$idx)),
390 (EXTRACT_LANE_v2f64 V128:$vec, imm:$idx)>;
393 (sext_inreg (vector_extract (v16i8 V128:$vec), (i32 LaneIdx16:$idx)), i8),
394 (EXTRACT_LANE_v16i8_s V128:$vec, imm:$idx)>;
396 (and (vector_extract (v16i8 V128:$vec), (i32 LaneIdx16:$idx)), (i32 0xff)),
397 (EXTRACT_LANE_v16i8_u V128:$vec, imm:$idx)>;
399 (sext_inreg (vector_extract (v8i16 V128:$vec), (i32 LaneIdx8:$idx)), i16),
400 (EXTRACT_LANE_v8i16_s V128:$vec, imm:$idx)>;
402 (and (vector_extract (v8i16 V128:$vec), (i32 LaneIdx8:$idx)), (i32 0xffff)),
403 (EXTRACT_LANE_v8i16_u V128:$vec, imm:$idx)>;
405 // Replace lane value: replace_lane
406 multiclass ReplaceLane<ValueType vec_t, string vec, ImmLeaf imm_t,
407 WebAssemblyRegClass reg_t, ValueType lane_t,
409 defm REPLACE_LANE_#vec_t :
410 SIMD_I<(outs V128:$dst), (ins V128:$vec, vec_i8imm_op:$idx, reg_t:$x),
411 (outs), (ins vec_i8imm_op:$idx),
412 [(set V128:$dst, (vector_insert
413 (vec_t V128:$vec), (lane_t reg_t:$x), (i32 imm_t:$idx)))],
414 vec#".replace_lane\t$dst, $vec, $idx, $x",
415 vec#".replace_lane\t$idx", simdop>;
418 defm "" : ReplaceLane<v16i8, "i8x16", LaneIdx16, I32, i32, 23>;
419 defm "" : ReplaceLane<v8i16, "i16x8", LaneIdx8, I32, i32, 26>;
420 defm "" : ReplaceLane<v4i32, "i32x4", LaneIdx4, I32, i32, 28>;
421 defm "" : ReplaceLane<v2i64, "i64x2", LaneIdx2, I64, i64, 30>;
422 defm "" : ReplaceLane<v4f32, "f32x4", LaneIdx4, F32, f32, 32>;
423 defm "" : ReplaceLane<v2f64, "f64x2", LaneIdx2, F64, f64, 34>;
425 // Lower undef lane indices to zero
426 def : Pat<(vector_insert (v16i8 V128:$vec), I32:$x, undef),
427 (REPLACE_LANE_v16i8 V128:$vec, 0, I32:$x)>;
428 def : Pat<(vector_insert (v8i16 V128:$vec), I32:$x, undef),
429 (REPLACE_LANE_v8i16 V128:$vec, 0, I32:$x)>;
430 def : Pat<(vector_insert (v4i32 V128:$vec), I32:$x, undef),
431 (REPLACE_LANE_v4i32 V128:$vec, 0, I32:$x)>;
432 def : Pat<(vector_insert (v2i64 V128:$vec), I64:$x, undef),
433 (REPLACE_LANE_v2i64 V128:$vec, 0, I64:$x)>;
434 def : Pat<(vector_insert (v4f32 V128:$vec), F32:$x, undef),
435 (REPLACE_LANE_v4f32 V128:$vec, 0, F32:$x)>;
436 def : Pat<(vector_insert (v2f64 V128:$vec), F64:$x, undef),
437 (REPLACE_LANE_v2f64 V128:$vec, 0, F64:$x)>;
439 //===----------------------------------------------------------------------===//
441 //===----------------------------------------------------------------------===//
443 multiclass SIMDCondition<ValueType vec_t, ValueType out_t, string vec,
444 string name, CondCode cond, bits<32> simdop> {
446 SIMD_I<(outs V128:$dst), (ins V128:$lhs, V128:$rhs), (outs), (ins),
447 [(set (out_t V128:$dst),
448 (setcc (vec_t V128:$lhs), (vec_t V128:$rhs), cond)
450 vec#"."#name#"\t$dst, $lhs, $rhs", vec#"."#name, simdop>;
453 multiclass SIMDConditionInt<string name, CondCode cond, bits<32> baseInst> {
454 defm "" : SIMDCondition<v16i8, v16i8, "i8x16", name, cond, baseInst>;
455 defm "" : SIMDCondition<v8i16, v8i16, "i16x8", name, cond,
457 defm "" : SIMDCondition<v4i32, v4i32, "i32x4", name, cond,
461 multiclass SIMDConditionFP<string name, CondCode cond, bits<32> baseInst> {
462 defm "" : SIMDCondition<v4f32, v4i32, "f32x4", name, cond, baseInst>;
463 defm "" : SIMDCondition<v2f64, v2i64, "f64x2", name, cond,
468 let isCommutable = 1 in {
469 defm EQ : SIMDConditionInt<"eq", SETEQ, 35>;
470 defm EQ : SIMDConditionFP<"eq", SETOEQ, 65>;
471 } // isCommutable = 1
474 let isCommutable = 1 in {
475 defm NE : SIMDConditionInt<"ne", SETNE, 36>;
476 defm NE : SIMDConditionFP<"ne", SETUNE, 66>;
477 } // isCommutable = 1
479 // Less than: lt_s / lt_u / lt
480 defm LT_S : SIMDConditionInt<"lt_s", SETLT, 37>;
481 defm LT_U : SIMDConditionInt<"lt_u", SETULT, 38>;
482 defm LT : SIMDConditionFP<"lt", SETOLT, 67>;
484 // Greater than: gt_s / gt_u / gt
485 defm GT_S : SIMDConditionInt<"gt_s", SETGT, 39>;
486 defm GT_U : SIMDConditionInt<"gt_u", SETUGT, 40>;
487 defm GT : SIMDConditionFP<"gt", SETOGT, 68>;
489 // Less than or equal: le_s / le_u / le
490 defm LE_S : SIMDConditionInt<"le_s", SETLE, 41>;
491 defm LE_U : SIMDConditionInt<"le_u", SETULE, 42>;
492 defm LE : SIMDConditionFP<"le", SETOLE, 69>;
494 // Greater than or equal: ge_s / ge_u / ge
495 defm GE_S : SIMDConditionInt<"ge_s", SETGE, 43>;
496 defm GE_U : SIMDConditionInt<"ge_u", SETUGE, 44>;
497 defm GE : SIMDConditionFP<"ge", SETOGE, 70>;
499 // Lower float comparisons that don't care about NaN to standard WebAssembly
500 // float comparisons. These instructions are generated with nnan and in the
501 // target-independent expansion of unordered comparisons and ordered ne.
502 foreach nodes = [[seteq, EQ_v4f32], [setne, NE_v4f32], [setlt, LT_v4f32],
503 [setgt, GT_v4f32], [setle, LE_v4f32], [setge, GE_v4f32]] in
504 def : Pat<(v4i32 (nodes[0] (v4f32 V128:$lhs), (v4f32 V128:$rhs))),
505 (v4i32 (nodes[1] (v4f32 V128:$lhs), (v4f32 V128:$rhs)))>;
507 foreach nodes = [[seteq, EQ_v2f64], [setne, NE_v2f64], [setlt, LT_v2f64],
508 [setgt, GT_v2f64], [setle, LE_v2f64], [setge, GE_v2f64]] in
509 def : Pat<(v2i64 (nodes[0] (v2f64 V128:$lhs), (v2f64 V128:$rhs))),
510 (v2i64 (nodes[1] (v2f64 V128:$lhs), (v2f64 V128:$rhs)))>;
513 //===----------------------------------------------------------------------===//
514 // Bitwise operations
515 //===----------------------------------------------------------------------===//
517 multiclass SIMDBinary<ValueType vec_t, string vec, SDNode node, string name,
519 defm _#vec_t : SIMD_I<(outs V128:$dst), (ins V128:$lhs, V128:$rhs),
521 [(set (vec_t V128:$dst),
522 (node (vec_t V128:$lhs), (vec_t V128:$rhs))
524 vec#"."#name#"\t$dst, $lhs, $rhs", vec#"."#name,
528 multiclass SIMDBitwise<SDNode node, string name, bits<32> simdop> {
529 defm "" : SIMDBinary<v16i8, "v128", node, name, simdop>;
530 defm "" : SIMDBinary<v8i16, "v128", node, name, simdop>;
531 defm "" : SIMDBinary<v4i32, "v128", node, name, simdop>;
532 defm "" : SIMDBinary<v2i64, "v128", node, name, simdop>;
535 multiclass SIMDUnary<ValueType vec_t, string vec, SDNode node, string name,
537 defm _#vec_t : SIMD_I<(outs V128:$dst), (ins V128:$vec), (outs), (ins),
538 [(set (vec_t V128:$dst),
539 (vec_t (node (vec_t V128:$vec)))
541 vec#"."#name#"\t$dst, $vec", vec#"."#name, simdop>;
544 // Bitwise logic: v128.not
545 foreach vec_t = [v16i8, v8i16, v4i32, v2i64] in
546 defm NOT: SIMDUnary<vec_t, "v128", vnot, "not", 77>;
548 // Bitwise logic: v128.and / v128.or / v128.xor
549 let isCommutable = 1 in {
550 defm AND : SIMDBitwise<and, "and", 78>;
551 defm OR : SIMDBitwise<or, "or", 80>;
552 defm XOR : SIMDBitwise<xor, "xor", 81>;
553 } // isCommutable = 1
555 // Bitwise logic: v128.andnot
556 def andnot : PatFrag<(ops node:$left, node:$right), (and $left, (vnot $right))>;
557 defm ANDNOT : SIMDBitwise<andnot, "andnot", 79>;
559 // Bitwise select: v128.bitselect
560 foreach vec_t = [v16i8, v8i16, v4i32, v2i64, v4f32, v2f64] in
561 defm BITSELECT_#vec_t :
562 SIMD_I<(outs V128:$dst), (ins V128:$v1, V128:$v2, V128:$c), (outs), (ins),
563 [(set (vec_t V128:$dst),
564 (vec_t (int_wasm_bitselect
565 (vec_t V128:$v1), (vec_t V128:$v2), (vec_t V128:$c)
568 "v128.bitselect\t$dst, $v1, $v2, $c", "v128.bitselect", 82>;
570 // Bitselect is equivalent to (c & v1) | (~c & v2)
571 foreach vec_t = [v16i8, v8i16, v4i32, v2i64] in
572 def : Pat<(vec_t (or (and (vec_t V128:$c), (vec_t V128:$v1)),
573 (and (vnot V128:$c), (vec_t V128:$v2)))),
574 (!cast<Instruction>("BITSELECT_"#vec_t)
575 V128:$v1, V128:$v2, V128:$c)>;
577 //===----------------------------------------------------------------------===//
578 // Integer unary arithmetic
579 //===----------------------------------------------------------------------===//
581 multiclass SIMDUnaryInt<SDNode node, string name, bits<32> baseInst> {
582 defm "" : SIMDUnary<v16i8, "i8x16", node, name, baseInst>;
583 defm "" : SIMDUnary<v8i16, "i16x8", node, name, !add(baseInst, 32)>;
584 defm "" : SIMDUnary<v4i32, "i32x4", node, name, !add(baseInst, 64)>;
585 defm "" : SIMDUnary<v2i64, "i64x2", node, name, !add(baseInst, 96)>;
588 multiclass SIMDReduceVec<ValueType vec_t, string vec, SDNode op, string name,
590 defm _#vec_t : SIMD_I<(outs I32:$dst), (ins V128:$vec), (outs), (ins),
591 [(set I32:$dst, (i32 (op (vec_t V128:$vec))))],
592 vec#"."#name#"\t$dst, $vec", vec#"."#name, simdop>;
595 multiclass SIMDReduce<SDNode op, string name, bits<32> baseInst> {
596 defm "" : SIMDReduceVec<v16i8, "i8x16", op, name, baseInst>;
597 defm "" : SIMDReduceVec<v8i16, "i16x8", op, name, !add(baseInst, 32)>;
598 defm "" : SIMDReduceVec<v4i32, "i32x4", op, name, !add(baseInst, 64)>;
599 defm "" : SIMDReduceVec<v2i64, "i64x2", op, name, !add(baseInst, 96)>;
602 // Integer vector negation
603 def ivneg : PatFrag<(ops node:$in), (sub immAllZerosV, node:$in)>;
605 // Integer absolute value: abs
606 defm ABS : SIMDUnaryInt<abs, "abs", 96>;
608 // Integer negation: neg
609 defm NEG : SIMDUnaryInt<ivneg, "neg", 97>;
611 // Any lane true: any_true
612 defm ANYTRUE : SIMDReduce<int_wasm_anytrue, "any_true", 98>;
614 // All lanes true: all_true
615 defm ALLTRUE : SIMDReduce<int_wasm_alltrue, "all_true", 99>;
617 // Reductions already return 0 or 1, so and 1, setne 0, and seteq 1
620 [["int_wasm_anytrue", "ANYTRUE"], ["int_wasm_alltrue", "ALLTRUE"]] in
621 foreach ty = [v16i8, v8i16, v4i32, v2i64] in {
623 (i32 (!cast<Intrinsic>(reduction[0]) (ty V128:$x))),
626 (i32 (!cast<NI>(reduction[1]#"_"#ty) (ty V128:$x)))>;
627 def : Pat<(i32 (setne
628 (i32 (!cast<Intrinsic>(reduction[0]) (ty V128:$x))),
631 (i32 (!cast<NI>(reduction[1]#"_"#ty) (ty V128:$x)))>;
632 def : Pat<(i32 (seteq
633 (i32 (!cast<Intrinsic>(reduction[0]) (ty V128:$x))),
636 (i32 (!cast<NI>(reduction[1]#"_"#ty) (ty V128:$x)))>;
639 multiclass SIMDBitmask<ValueType vec_t, string vec, bits<32> simdop> {
640 defm _#vec_t : SIMD_I<(outs I32:$dst), (ins V128:$vec), (outs), (ins),
642 (i32 (int_wasm_bitmask (vec_t V128:$vec)))
644 vec#".bitmask\t$dst, $vec", vec#".bitmask", simdop>;
647 defm BITMASK : SIMDBitmask<v16i8, "i8x16", 100>;
648 defm BITMASK : SIMDBitmask<v8i16, "i16x8", 132>;
649 defm BITMASK : SIMDBitmask<v4i32, "i32x4", 164>;
651 //===----------------------------------------------------------------------===//
653 //===----------------------------------------------------------------------===//
655 multiclass SIMDShift<ValueType vec_t, string vec, SDNode node, string name,
657 defm _#vec_t : SIMD_I<(outs V128:$dst), (ins V128:$vec, I32:$x),
659 [(set (vec_t V128:$dst), (node V128:$vec, I32:$x))],
660 vec#"."#name#"\t$dst, $vec, $x", vec#"."#name, simdop>;
663 multiclass SIMDShiftInt<SDNode node, string name, bits<32> baseInst> {
664 defm "" : SIMDShift<v16i8, "i8x16", node, name, baseInst>;
665 defm "" : SIMDShift<v8i16, "i16x8", node, name, !add(baseInst, 32)>;
666 defm "" : SIMDShift<v4i32, "i32x4", node, name, !add(baseInst, 64)>;
667 defm "" : SIMDShift<v2i64, "i64x2", node, name, !add(baseInst, 96)>;
670 // WebAssembly SIMD shifts are nonstandard in that the shift amount is
671 // an i32 rather than a vector, so they need custom nodes.
672 def wasm_shift_t : SDTypeProfile<1, 2,
673 [SDTCisVec<0>, SDTCisSameAs<0, 1>, SDTCisVT<2, i32>]
675 def wasm_shl : SDNode<"WebAssemblyISD::VEC_SHL", wasm_shift_t>;
676 def wasm_shr_s : SDNode<"WebAssemblyISD::VEC_SHR_S", wasm_shift_t>;
677 def wasm_shr_u : SDNode<"WebAssemblyISD::VEC_SHR_U", wasm_shift_t>;
679 // Left shift by scalar: shl
680 defm SHL : SIMDShiftInt<wasm_shl, "shl", 107>;
682 // Right shift by scalar: shr_s / shr_u
683 defm SHR_S : SIMDShiftInt<wasm_shr_s, "shr_s", 108>;
684 defm SHR_U : SIMDShiftInt<wasm_shr_u, "shr_u", 109>;
686 //===----------------------------------------------------------------------===//
687 // Integer binary arithmetic
688 //===----------------------------------------------------------------------===//
690 multiclass SIMDBinaryIntNoI8x16<SDNode node, string name, bits<32> baseInst> {
691 defm "" : SIMDBinary<v8i16, "i16x8", node, name, !add(baseInst, 32)>;
692 defm "" : SIMDBinary<v4i32, "i32x4", node, name, !add(baseInst, 64)>;
693 defm "" : SIMDBinary<v2i64, "i64x2", node, name, !add(baseInst, 96)>;
696 multiclass SIMDBinaryIntSmall<SDNode node, string name, bits<32> baseInst> {
697 defm "" : SIMDBinary<v16i8, "i8x16", node, name, baseInst>;
698 defm "" : SIMDBinary<v8i16, "i16x8", node, name, !add(baseInst, 32)>;
701 multiclass SIMDBinaryIntNoI64x2<SDNode node, string name, bits<32> baseInst> {
702 defm "" : SIMDBinaryIntSmall<node, name, baseInst>;
703 defm "" : SIMDBinary<v4i32, "i32x4", node, name, !add(baseInst, 64)>;
706 multiclass SIMDBinaryInt<SDNode node, string name, bits<32> baseInst> {
707 defm "" : SIMDBinaryIntNoI64x2<node, name, baseInst>;
708 defm "" : SIMDBinary<v2i64, "i64x2", node, name, !add(baseInst, 96)>;
711 // Integer addition: add / add_saturate_s / add_saturate_u
712 let isCommutable = 1 in {
713 defm ADD : SIMDBinaryInt<add, "add", 110>;
714 defm ADD_SAT_S : SIMDBinaryIntSmall<saddsat, "add_saturate_s", 111>;
715 defm ADD_SAT_U : SIMDBinaryIntSmall<uaddsat, "add_saturate_u", 112>;
716 } // isCommutable = 1
718 // Integer subtraction: sub / sub_saturate_s / sub_saturate_u
719 defm SUB : SIMDBinaryInt<sub, "sub", 113>;
721 SIMDBinaryIntSmall<int_wasm_sub_saturate_signed, "sub_saturate_s", 114>;
723 SIMDBinaryIntSmall<int_wasm_sub_saturate_unsigned, "sub_saturate_u", 115>;
725 // Integer multiplication: mul
726 let isCommutable = 1 in
727 defm MUL : SIMDBinaryIntNoI8x16<mul, "mul", 117>;
729 // Integer min_s / min_u / max_s / max_u
730 let isCommutable = 1 in {
731 defm MIN_S : SIMDBinaryIntNoI64x2<smin, "min_s", 118>;
732 defm MIN_U : SIMDBinaryIntNoI64x2<umin, "min_u", 119>;
733 defm MAX_S : SIMDBinaryIntNoI64x2<smax, "max_s", 120>;
734 defm MAX_U : SIMDBinaryIntNoI64x2<umax, "max_u", 121>;
735 } // isCommutable = 1
737 // Integer unsigned rounding average: avgr_u
738 let isCommutable = 1 in {
739 defm AVGR_U : SIMDBinary<v16i8, "i8x16", int_wasm_avgr_unsigned, "avgr_u", 123>;
740 defm AVGR_U : SIMDBinary<v8i16, "i16x8", int_wasm_avgr_unsigned, "avgr_u", 155>;
743 def add_nuw : PatFrag<(ops node:$lhs, node:$rhs),
744 (add node:$lhs, node:$rhs),
745 "return N->getFlags().hasNoUnsignedWrap();">;
747 foreach nodes = [[v16i8, splat16], [v8i16, splat8]] in
748 def : Pat<(wasm_shr_u
750 (add_nuw (nodes[0] V128:$lhs), (nodes[0] V128:$rhs)),
755 (!cast<NI>("AVGR_U_"#nodes[0]) V128:$lhs, V128:$rhs)>;
757 // Widening dot product: i32x4.dot_i16x8_s
758 let isCommutable = 1 in
759 defm DOT : SIMD_I<(outs V128:$dst), (ins V128:$lhs, V128:$rhs), (outs), (ins),
760 [(set V128:$dst, (int_wasm_dot V128:$lhs, V128:$rhs))],
761 "i32x4.dot_i16x8_s\t$dst, $lhs, $rhs", "i32x4.dot_i16x8_s",
764 //===----------------------------------------------------------------------===//
765 // Floating-point unary arithmetic
766 //===----------------------------------------------------------------------===//
768 multiclass SIMDUnaryFP<SDNode node, string name, bits<32> baseInst> {
769 defm "" : SIMDUnary<v4f32, "f32x4", node, name, baseInst>;
770 defm "" : SIMDUnary<v2f64, "f64x2", node, name, !add(baseInst, 12)>;
773 // Absolute value: abs
774 defm ABS : SIMDUnaryFP<fabs, "abs", 224>;
777 defm NEG : SIMDUnaryFP<fneg, "neg", 225>;
780 defm SQRT : SIMDUnaryFP<fsqrt, "sqrt", 227>;
782 // Rounding: ceil, floor, trunc, nearest
783 defm CEIL : SIMDUnary<v4f32, "f32x4", int_wasm_ceil, "ceil", 216>;
784 defm FLOOR : SIMDUnary<v4f32, "f32x4", int_wasm_floor, "floor", 217>;
785 defm TRUNC: SIMDUnary<v4f32, "f32x4", int_wasm_trunc, "trunc", 218>;
786 defm NEAREST: SIMDUnary<v4f32, "f32x4", int_wasm_nearest, "nearest", 219>;
787 defm CEIL : SIMDUnary<v2f64, "f64x2", int_wasm_ceil, "ceil", 220>;
788 defm FLOOR : SIMDUnary<v2f64, "f64x2", int_wasm_floor, "floor", 221>;
789 defm TRUNC: SIMDUnary<v2f64, "f64x2", int_wasm_trunc, "trunc", 222>;
790 defm NEAREST: SIMDUnary<v2f64, "f64x2", int_wasm_nearest, "nearest", 223>;
792 //===----------------------------------------------------------------------===//
793 // Floating-point binary arithmetic
794 //===----------------------------------------------------------------------===//
796 multiclass SIMDBinaryFP<SDNode node, string name, bits<32> baseInst> {
797 defm "" : SIMDBinary<v4f32, "f32x4", node, name, baseInst>;
798 defm "" : SIMDBinary<v2f64, "f64x2", node, name, !add(baseInst, 12)>;
802 let isCommutable = 1 in
803 defm ADD : SIMDBinaryFP<fadd, "add", 228>;
806 defm SUB : SIMDBinaryFP<fsub, "sub", 229>;
808 // Multiplication: mul
809 let isCommutable = 1 in
810 defm MUL : SIMDBinaryFP<fmul, "mul", 230>;
813 defm DIV : SIMDBinaryFP<fdiv, "div", 231>;
815 // NaN-propagating minimum: min
816 defm MIN : SIMDBinaryFP<fminimum, "min", 232>;
818 // NaN-propagating maximum: max
819 defm MAX : SIMDBinaryFP<fmaximum, "max", 233>;
821 // Pseudo-minimum: pmin
822 defm PMIN : SIMDBinaryFP<int_wasm_pmin, "pmin", 234>;
824 // Pseudo-maximum: pmax
825 defm PMAX : SIMDBinaryFP<int_wasm_pmax, "pmax", 235>;
827 //===----------------------------------------------------------------------===//
829 //===----------------------------------------------------------------------===//
831 multiclass SIMDConvert<ValueType vec_t, ValueType arg_t, SDNode op,
832 string name, bits<32> simdop> {
833 defm op#_#vec_t#_#arg_t :
834 SIMD_I<(outs V128:$dst), (ins V128:$vec), (outs), (ins),
835 [(set (vec_t V128:$dst), (vec_t (op (arg_t V128:$vec))))],
836 name#"\t$dst, $vec", name, simdop>;
839 // Floating point to integer with saturation: trunc_sat
840 defm "" : SIMDConvert<v4i32, v4f32, fp_to_sint, "i32x4.trunc_sat_f32x4_s", 248>;
841 defm "" : SIMDConvert<v4i32, v4f32, fp_to_uint, "i32x4.trunc_sat_f32x4_u", 249>;
843 // Integer to floating point: convert
844 defm "" : SIMDConvert<v4f32, v4i32, sint_to_fp, "f32x4.convert_i32x4_s", 250>;
845 defm "" : SIMDConvert<v4f32, v4i32, uint_to_fp, "f32x4.convert_i32x4_u", 251>;
847 // Widening operations
848 multiclass SIMDWiden<ValueType vec_t, string vec, ValueType arg_t, string arg,
850 defm "" : SIMDConvert<vec_t, arg_t, int_wasm_widen_low_signed,
851 vec#".widen_low_"#arg#"_s", baseInst>;
852 defm "" : SIMDConvert<vec_t, arg_t, int_wasm_widen_high_signed,
853 vec#".widen_high_"#arg#"_s", !add(baseInst, 1)>;
854 defm "" : SIMDConvert<vec_t, arg_t, int_wasm_widen_low_unsigned,
855 vec#".widen_low_"#arg#"_u", !add(baseInst, 2)>;
856 defm "" : SIMDConvert<vec_t, arg_t, int_wasm_widen_high_unsigned,
857 vec#".widen_high_"#arg#"_u", !add(baseInst, 3)>;
860 defm "" : SIMDWiden<v8i16, "i16x8", v16i8, "i8x16", 135>;
861 defm "" : SIMDWiden<v4i32, "i32x4", v8i16, "i16x8", 167>;
863 // Narrowing operations
864 multiclass SIMDNarrow<ValueType vec_t, string vec, ValueType arg_t, string arg,
866 defm NARROW_S_#vec_t :
867 SIMD_I<(outs V128:$dst), (ins V128:$low, V128:$high), (outs), (ins),
868 [(set (vec_t V128:$dst), (vec_t (int_wasm_narrow_signed
869 (arg_t V128:$low), (arg_t V128:$high))))],
870 vec#".narrow_"#arg#"_s\t$dst, $low, $high", vec#".narrow_"#arg#"_s",
872 defm NARROW_U_#vec_t :
873 SIMD_I<(outs V128:$dst), (ins V128:$low, V128:$high), (outs), (ins),
874 [(set (vec_t V128:$dst), (vec_t (int_wasm_narrow_unsigned
875 (arg_t V128:$low), (arg_t V128:$high))))],
876 vec#".narrow_"#arg#"_u\t$dst, $low, $high", vec#".narrow_"#arg#"_u",
880 defm "" : SIMDNarrow<v16i8, "i8x16", v8i16, "i16x8", 101>;
881 defm "" : SIMDNarrow<v8i16, "i16x8", v4i32, "i32x4", 133>;
883 // Lower llvm.wasm.trunc.saturate.* to saturating instructions
884 def : Pat<(v4i32 (int_wasm_trunc_saturate_signed (v4f32 V128:$src))),
885 (fp_to_sint_v4i32_v4f32 (v4f32 V128:$src))>;
886 def : Pat<(v4i32 (int_wasm_trunc_saturate_unsigned (v4f32 V128:$src))),
887 (fp_to_uint_v4i32_v4f32 (v4f32 V128:$src))>;
890 // Matching bitcast t1 to t1 causes strange errors, so avoid repeating types
891 foreach t1 = [v16i8, v8i16, v4i32, v2i64, v4f32, v2f64] in
893 []<ValueType>, [v16i8, v8i16, v4i32, v2i64, v4f32, v2f64],
894 acc, cur, !if(!eq(!cast<string>(t1), !cast<string>(cur)),
895 acc, !listconcat(acc, [cur])
898 def : Pat<(t1 (bitconvert (t2 V128:$v))), (t1 V128:$v)>;
900 //===----------------------------------------------------------------------===//
901 // Quasi-Fused Multiply- Add and Subtract (QFMA/QFMS)
902 //===----------------------------------------------------------------------===//
904 multiclass SIMDQFM<ValueType vec_t, string vec, bits<32> baseInst> {
906 SIMD_I<(outs V128:$dst), (ins V128:$a, V128:$b, V128:$c),
908 [(set (vec_t V128:$dst),
909 (int_wasm_qfma (vec_t V128:$a), (vec_t V128:$b), (vec_t V128:$c)))],
910 vec#".qfma\t$dst, $a, $b, $c", vec#".qfma", baseInst>;
912 SIMD_I<(outs V128:$dst), (ins V128:$a, V128:$b, V128:$c),
914 [(set (vec_t V128:$dst),
915 (int_wasm_qfms (vec_t V128:$a), (vec_t V128:$b), (vec_t V128:$c)))],
916 vec#".qfms\t$dst, $a, $b, $c", vec#".qfms", !add(baseInst, 1)>;
919 defm "" : SIMDQFM<v4f32, "f32x4", 252>;
920 defm "" : SIMDQFM<v2f64, "f64x2", 254>;