1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* "Fast" Instruction Selector for the WebAssembly target *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9
10// FastEmit Immediate Predicate functions.
11static bool Predicate_ImmI8(int64_t Imm) {
12return -(1 << (8 - 1)) <= Imm && Imm < (1 << 8);
13}
14static bool Predicate_ImmI16(int64_t Imm) {
15return -(1 << (16 - 1)) <= Imm && Imm < (1 << 16);
16}
17static bool Predicate_LaneIdx32(int64_t Imm) {
18return 0 <= Imm && Imm < 32;
19}
20static bool Predicate_LaneIdx16(int64_t Imm) {
21return 0 <= Imm && Imm < 16;
22}
23static bool Predicate_LaneIdx8(int64_t Imm) {
24return 0 <= Imm && Imm < 8;
25}
26static bool Predicate_LaneIdx4(int64_t Imm) {
27return 0 <= Imm && Imm < 4;
28}
29static bool Predicate_LaneIdx2(int64_t Imm) {
30return 0 <= Imm && Imm < 2;
31}
32
33
34// FastEmit functions for ISD::ABS.
35
36Register fastEmit_ISD_ABS_MVT_v16i8_r(MVT RetVT, Register Op0) {
37 if (RetVT.SimpleTy != MVT::v16i8)
38 return Register();
39 if ((Subtarget->hasSIMD128())) {
40 return fastEmitInst_r(MachineInstOpcode: WebAssembly::ABS_I8x16, RC: &WebAssembly::V128RegClass, Op0);
41 }
42 return Register();
43}
44
45Register fastEmit_ISD_ABS_MVT_v8i16_r(MVT RetVT, Register Op0) {
46 if (RetVT.SimpleTy != MVT::v8i16)
47 return Register();
48 if ((Subtarget->hasSIMD128())) {
49 return fastEmitInst_r(MachineInstOpcode: WebAssembly::ABS_I16x8, RC: &WebAssembly::V128RegClass, Op0);
50 }
51 return Register();
52}
53
54Register fastEmit_ISD_ABS_MVT_v4i32_r(MVT RetVT, Register Op0) {
55 if (RetVT.SimpleTy != MVT::v4i32)
56 return Register();
57 if ((Subtarget->hasSIMD128())) {
58 return fastEmitInst_r(MachineInstOpcode: WebAssembly::ABS_I32x4, RC: &WebAssembly::V128RegClass, Op0);
59 }
60 return Register();
61}
62
63Register fastEmit_ISD_ABS_MVT_v2i64_r(MVT RetVT, Register Op0) {
64 if (RetVT.SimpleTy != MVT::v2i64)
65 return Register();
66 if ((Subtarget->hasSIMD128())) {
67 return fastEmitInst_r(MachineInstOpcode: WebAssembly::ABS_I64x2, RC: &WebAssembly::V128RegClass, Op0);
68 }
69 return Register();
70}
71
72Register fastEmit_ISD_ABS_r(MVT VT, MVT RetVT, Register Op0) {
73 switch (VT.SimpleTy) {
74 case MVT::v16i8: return fastEmit_ISD_ABS_MVT_v16i8_r(RetVT, Op0);
75 case MVT::v8i16: return fastEmit_ISD_ABS_MVT_v8i16_r(RetVT, Op0);
76 case MVT::v4i32: return fastEmit_ISD_ABS_MVT_v4i32_r(RetVT, Op0);
77 case MVT::v2i64: return fastEmit_ISD_ABS_MVT_v2i64_r(RetVT, Op0);
78 default: return Register();
79 }
80}
81
82// FastEmit functions for ISD::ANY_EXTEND.
83
84Register fastEmit_ISD_ANY_EXTEND_MVT_i32_r(MVT RetVT, Register Op0) {
85 if (RetVT.SimpleTy != MVT::i64)
86 return Register();
87 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I64_EXTEND_U_I32, RC: &WebAssembly::I64RegClass, Op0);
88}
89
90Register fastEmit_ISD_ANY_EXTEND_r(MVT VT, MVT RetVT, Register Op0) {
91 switch (VT.SimpleTy) {
92 case MVT::i32: return fastEmit_ISD_ANY_EXTEND_MVT_i32_r(RetVT, Op0);
93 default: return Register();
94 }
95}
96
97// FastEmit functions for ISD::BITCAST.
98
99Register fastEmit_ISD_BITCAST_MVT_i32_r(MVT RetVT, Register Op0) {
100 if (RetVT.SimpleTy != MVT::f32)
101 return Register();
102 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F32_REINTERPRET_I32, RC: &WebAssembly::F32RegClass, Op0);
103}
104
105Register fastEmit_ISD_BITCAST_MVT_i64_r(MVT RetVT, Register Op0) {
106 if (RetVT.SimpleTy != MVT::f64)
107 return Register();
108 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F64_REINTERPRET_I64, RC: &WebAssembly::F64RegClass, Op0);
109}
110
111Register fastEmit_ISD_BITCAST_MVT_f32_r(MVT RetVT, Register Op0) {
112 if (RetVT.SimpleTy != MVT::i32)
113 return Register();
114 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I32_REINTERPRET_F32, RC: &WebAssembly::I32RegClass, Op0);
115}
116
117Register fastEmit_ISD_BITCAST_MVT_f64_r(MVT RetVT, Register Op0) {
118 if (RetVT.SimpleTy != MVT::i64)
119 return Register();
120 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I64_REINTERPRET_F64, RC: &WebAssembly::I64RegClass, Op0);
121}
122
123Register fastEmit_ISD_BITCAST_r(MVT VT, MVT RetVT, Register Op0) {
124 switch (VT.SimpleTy) {
125 case MVT::i32: return fastEmit_ISD_BITCAST_MVT_i32_r(RetVT, Op0);
126 case MVT::i64: return fastEmit_ISD_BITCAST_MVT_i64_r(RetVT, Op0);
127 case MVT::f32: return fastEmit_ISD_BITCAST_MVT_f32_r(RetVT, Op0);
128 case MVT::f64: return fastEmit_ISD_BITCAST_MVT_f64_r(RetVT, Op0);
129 default: return Register();
130 }
131}
132
133// FastEmit functions for ISD::CTLZ.
134
135Register fastEmit_ISD_CTLZ_MVT_i32_r(MVT RetVT, Register Op0) {
136 if (RetVT.SimpleTy != MVT::i32)
137 return Register();
138 return fastEmitInst_r(MachineInstOpcode: WebAssembly::CLZ_I32, RC: &WebAssembly::I32RegClass, Op0);
139}
140
141Register fastEmit_ISD_CTLZ_MVT_i64_r(MVT RetVT, Register Op0) {
142 if (RetVT.SimpleTy != MVT::i64)
143 return Register();
144 return fastEmitInst_r(MachineInstOpcode: WebAssembly::CLZ_I64, RC: &WebAssembly::I64RegClass, Op0);
145}
146
147Register fastEmit_ISD_CTLZ_r(MVT VT, MVT RetVT, Register Op0) {
148 switch (VT.SimpleTy) {
149 case MVT::i32: return fastEmit_ISD_CTLZ_MVT_i32_r(RetVT, Op0);
150 case MVT::i64: return fastEmit_ISD_CTLZ_MVT_i64_r(RetVT, Op0);
151 default: return Register();
152 }
153}
154
155// FastEmit functions for ISD::CTPOP.
156
157Register fastEmit_ISD_CTPOP_MVT_i32_r(MVT RetVT, Register Op0) {
158 if (RetVT.SimpleTy != MVT::i32)
159 return Register();
160 return fastEmitInst_r(MachineInstOpcode: WebAssembly::POPCNT_I32, RC: &WebAssembly::I32RegClass, Op0);
161}
162
163Register fastEmit_ISD_CTPOP_MVT_i64_r(MVT RetVT, Register Op0) {
164 if (RetVT.SimpleTy != MVT::i64)
165 return Register();
166 return fastEmitInst_r(MachineInstOpcode: WebAssembly::POPCNT_I64, RC: &WebAssembly::I64RegClass, Op0);
167}
168
169Register fastEmit_ISD_CTPOP_MVT_v16i8_r(MVT RetVT, Register Op0) {
170 if (RetVT.SimpleTy != MVT::v16i8)
171 return Register();
172 if ((Subtarget->hasSIMD128())) {
173 return fastEmitInst_r(MachineInstOpcode: WebAssembly::POPCNT_I8x16, RC: &WebAssembly::V128RegClass, Op0);
174 }
175 return Register();
176}
177
178Register fastEmit_ISD_CTPOP_r(MVT VT, MVT RetVT, Register Op0) {
179 switch (VT.SimpleTy) {
180 case MVT::i32: return fastEmit_ISD_CTPOP_MVT_i32_r(RetVT, Op0);
181 case MVT::i64: return fastEmit_ISD_CTPOP_MVT_i64_r(RetVT, Op0);
182 case MVT::v16i8: return fastEmit_ISD_CTPOP_MVT_v16i8_r(RetVT, Op0);
183 default: return Register();
184 }
185}
186
187// FastEmit functions for ISD::CTTZ.
188
189Register fastEmit_ISD_CTTZ_MVT_i32_r(MVT RetVT, Register Op0) {
190 if (RetVT.SimpleTy != MVT::i32)
191 return Register();
192 return fastEmitInst_r(MachineInstOpcode: WebAssembly::CTZ_I32, RC: &WebAssembly::I32RegClass, Op0);
193}
194
195Register fastEmit_ISD_CTTZ_MVT_i64_r(MVT RetVT, Register Op0) {
196 if (RetVT.SimpleTy != MVT::i64)
197 return Register();
198 return fastEmitInst_r(MachineInstOpcode: WebAssembly::CTZ_I64, RC: &WebAssembly::I64RegClass, Op0);
199}
200
201Register fastEmit_ISD_CTTZ_r(MVT VT, MVT RetVT, Register Op0) {
202 switch (VT.SimpleTy) {
203 case MVT::i32: return fastEmit_ISD_CTTZ_MVT_i32_r(RetVT, Op0);
204 case MVT::i64: return fastEmit_ISD_CTTZ_MVT_i64_r(RetVT, Op0);
205 default: return Register();
206 }
207}
208
209// FastEmit functions for ISD::FABS.
210
211Register fastEmit_ISD_FABS_MVT_f32_r(MVT RetVT, Register Op0) {
212 if (RetVT.SimpleTy != MVT::f32)
213 return Register();
214 return fastEmitInst_r(MachineInstOpcode: WebAssembly::ABS_F32, RC: &WebAssembly::F32RegClass, Op0);
215}
216
217Register fastEmit_ISD_FABS_MVT_f64_r(MVT RetVT, Register Op0) {
218 if (RetVT.SimpleTy != MVT::f64)
219 return Register();
220 return fastEmitInst_r(MachineInstOpcode: WebAssembly::ABS_F64, RC: &WebAssembly::F64RegClass, Op0);
221}
222
223Register fastEmit_ISD_FABS_MVT_v8f16_r(MVT RetVT, Register Op0) {
224 if (RetVT.SimpleTy != MVT::v8f16)
225 return Register();
226 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
227 return fastEmitInst_r(MachineInstOpcode: WebAssembly::ABS_F16x8, RC: &WebAssembly::V128RegClass, Op0);
228 }
229 return Register();
230}
231
232Register fastEmit_ISD_FABS_MVT_v4f32_r(MVT RetVT, Register Op0) {
233 if (RetVT.SimpleTy != MVT::v4f32)
234 return Register();
235 if ((Subtarget->hasSIMD128())) {
236 return fastEmitInst_r(MachineInstOpcode: WebAssembly::ABS_F32x4, RC: &WebAssembly::V128RegClass, Op0);
237 }
238 return Register();
239}
240
241Register fastEmit_ISD_FABS_MVT_v2f64_r(MVT RetVT, Register Op0) {
242 if (RetVT.SimpleTy != MVT::v2f64)
243 return Register();
244 if ((Subtarget->hasSIMD128())) {
245 return fastEmitInst_r(MachineInstOpcode: WebAssembly::ABS_F64x2, RC: &WebAssembly::V128RegClass, Op0);
246 }
247 return Register();
248}
249
250Register fastEmit_ISD_FABS_r(MVT VT, MVT RetVT, Register Op0) {
251 switch (VT.SimpleTy) {
252 case MVT::f32: return fastEmit_ISD_FABS_MVT_f32_r(RetVT, Op0);
253 case MVT::f64: return fastEmit_ISD_FABS_MVT_f64_r(RetVT, Op0);
254 case MVT::v8f16: return fastEmit_ISD_FABS_MVT_v8f16_r(RetVT, Op0);
255 case MVT::v4f32: return fastEmit_ISD_FABS_MVT_v4f32_r(RetVT, Op0);
256 case MVT::v2f64: return fastEmit_ISD_FABS_MVT_v2f64_r(RetVT, Op0);
257 default: return Register();
258 }
259}
260
261// FastEmit functions for ISD::FCEIL.
262
263Register fastEmit_ISD_FCEIL_MVT_f32_r(MVT RetVT, Register Op0) {
264 if (RetVT.SimpleTy != MVT::f32)
265 return Register();
266 return fastEmitInst_r(MachineInstOpcode: WebAssembly::CEIL_F32, RC: &WebAssembly::F32RegClass, Op0);
267}
268
269Register fastEmit_ISD_FCEIL_MVT_f64_r(MVT RetVT, Register Op0) {
270 if (RetVT.SimpleTy != MVT::f64)
271 return Register();
272 return fastEmitInst_r(MachineInstOpcode: WebAssembly::CEIL_F64, RC: &WebAssembly::F64RegClass, Op0);
273}
274
275Register fastEmit_ISD_FCEIL_MVT_v8f16_r(MVT RetVT, Register Op0) {
276 if (RetVT.SimpleTy != MVT::v8f16)
277 return Register();
278 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
279 return fastEmitInst_r(MachineInstOpcode: WebAssembly::CEIL_F16x8, RC: &WebAssembly::V128RegClass, Op0);
280 }
281 return Register();
282}
283
284Register fastEmit_ISD_FCEIL_MVT_v4f32_r(MVT RetVT, Register Op0) {
285 if (RetVT.SimpleTy != MVT::v4f32)
286 return Register();
287 if ((Subtarget->hasSIMD128())) {
288 return fastEmitInst_r(MachineInstOpcode: WebAssembly::CEIL_F32x4, RC: &WebAssembly::V128RegClass, Op0);
289 }
290 return Register();
291}
292
293Register fastEmit_ISD_FCEIL_MVT_v2f64_r(MVT RetVT, Register Op0) {
294 if (RetVT.SimpleTy != MVT::v2f64)
295 return Register();
296 if ((Subtarget->hasSIMD128())) {
297 return fastEmitInst_r(MachineInstOpcode: WebAssembly::CEIL_F64x2, RC: &WebAssembly::V128RegClass, Op0);
298 }
299 return Register();
300}
301
302Register fastEmit_ISD_FCEIL_r(MVT VT, MVT RetVT, Register Op0) {
303 switch (VT.SimpleTy) {
304 case MVT::f32: return fastEmit_ISD_FCEIL_MVT_f32_r(RetVT, Op0);
305 case MVT::f64: return fastEmit_ISD_FCEIL_MVT_f64_r(RetVT, Op0);
306 case MVT::v8f16: return fastEmit_ISD_FCEIL_MVT_v8f16_r(RetVT, Op0);
307 case MVT::v4f32: return fastEmit_ISD_FCEIL_MVT_v4f32_r(RetVT, Op0);
308 case MVT::v2f64: return fastEmit_ISD_FCEIL_MVT_v2f64_r(RetVT, Op0);
309 default: return Register();
310 }
311}
312
313// FastEmit functions for ISD::FFLOOR.
314
315Register fastEmit_ISD_FFLOOR_MVT_f32_r(MVT RetVT, Register Op0) {
316 if (RetVT.SimpleTy != MVT::f32)
317 return Register();
318 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FLOOR_F32, RC: &WebAssembly::F32RegClass, Op0);
319}
320
321Register fastEmit_ISD_FFLOOR_MVT_f64_r(MVT RetVT, Register Op0) {
322 if (RetVT.SimpleTy != MVT::f64)
323 return Register();
324 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FLOOR_F64, RC: &WebAssembly::F64RegClass, Op0);
325}
326
327Register fastEmit_ISD_FFLOOR_MVT_v8f16_r(MVT RetVT, Register Op0) {
328 if (RetVT.SimpleTy != MVT::v8f16)
329 return Register();
330 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
331 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FLOOR_F16x8, RC: &WebAssembly::V128RegClass, Op0);
332 }
333 return Register();
334}
335
336Register fastEmit_ISD_FFLOOR_MVT_v4f32_r(MVT RetVT, Register Op0) {
337 if (RetVT.SimpleTy != MVT::v4f32)
338 return Register();
339 if ((Subtarget->hasSIMD128())) {
340 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FLOOR_F32x4, RC: &WebAssembly::V128RegClass, Op0);
341 }
342 return Register();
343}
344
345Register fastEmit_ISD_FFLOOR_MVT_v2f64_r(MVT RetVT, Register Op0) {
346 if (RetVT.SimpleTy != MVT::v2f64)
347 return Register();
348 if ((Subtarget->hasSIMD128())) {
349 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FLOOR_F64x2, RC: &WebAssembly::V128RegClass, Op0);
350 }
351 return Register();
352}
353
354Register fastEmit_ISD_FFLOOR_r(MVT VT, MVT RetVT, Register Op0) {
355 switch (VT.SimpleTy) {
356 case MVT::f32: return fastEmit_ISD_FFLOOR_MVT_f32_r(RetVT, Op0);
357 case MVT::f64: return fastEmit_ISD_FFLOOR_MVT_f64_r(RetVT, Op0);
358 case MVT::v8f16: return fastEmit_ISD_FFLOOR_MVT_v8f16_r(RetVT, Op0);
359 case MVT::v4f32: return fastEmit_ISD_FFLOOR_MVT_v4f32_r(RetVT, Op0);
360 case MVT::v2f64: return fastEmit_ISD_FFLOOR_MVT_v2f64_r(RetVT, Op0);
361 default: return Register();
362 }
363}
364
365// FastEmit functions for ISD::FNEARBYINT.
366
367Register fastEmit_ISD_FNEARBYINT_MVT_f32_r(MVT RetVT, Register Op0) {
368 if (RetVT.SimpleTy != MVT::f32)
369 return Register();
370 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F32, RC: &WebAssembly::F32RegClass, Op0);
371}
372
373Register fastEmit_ISD_FNEARBYINT_MVT_f64_r(MVT RetVT, Register Op0) {
374 if (RetVT.SimpleTy != MVT::f64)
375 return Register();
376 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F64, RC: &WebAssembly::F64RegClass, Op0);
377}
378
379Register fastEmit_ISD_FNEARBYINT_MVT_v8f16_r(MVT RetVT, Register Op0) {
380 if (RetVT.SimpleTy != MVT::v8f16)
381 return Register();
382 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
383 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F16x8, RC: &WebAssembly::V128RegClass, Op0);
384 }
385 return Register();
386}
387
388Register fastEmit_ISD_FNEARBYINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
389 if (RetVT.SimpleTy != MVT::v4f32)
390 return Register();
391 if ((Subtarget->hasSIMD128())) {
392 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F32x4, RC: &WebAssembly::V128RegClass, Op0);
393 }
394 return Register();
395}
396
397Register fastEmit_ISD_FNEARBYINT_MVT_v2f64_r(MVT RetVT, Register Op0) {
398 if (RetVT.SimpleTy != MVT::v2f64)
399 return Register();
400 if ((Subtarget->hasSIMD128())) {
401 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F64x2, RC: &WebAssembly::V128RegClass, Op0);
402 }
403 return Register();
404}
405
406Register fastEmit_ISD_FNEARBYINT_r(MVT VT, MVT RetVT, Register Op0) {
407 switch (VT.SimpleTy) {
408 case MVT::f32: return fastEmit_ISD_FNEARBYINT_MVT_f32_r(RetVT, Op0);
409 case MVT::f64: return fastEmit_ISD_FNEARBYINT_MVT_f64_r(RetVT, Op0);
410 case MVT::v8f16: return fastEmit_ISD_FNEARBYINT_MVT_v8f16_r(RetVT, Op0);
411 case MVT::v4f32: return fastEmit_ISD_FNEARBYINT_MVT_v4f32_r(RetVT, Op0);
412 case MVT::v2f64: return fastEmit_ISD_FNEARBYINT_MVT_v2f64_r(RetVT, Op0);
413 default: return Register();
414 }
415}
416
417// FastEmit functions for ISD::FNEG.
418
419Register fastEmit_ISD_FNEG_MVT_f32_r(MVT RetVT, Register Op0) {
420 if (RetVT.SimpleTy != MVT::f32)
421 return Register();
422 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEG_F32, RC: &WebAssembly::F32RegClass, Op0);
423}
424
425Register fastEmit_ISD_FNEG_MVT_f64_r(MVT RetVT, Register Op0) {
426 if (RetVT.SimpleTy != MVT::f64)
427 return Register();
428 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEG_F64, RC: &WebAssembly::F64RegClass, Op0);
429}
430
431Register fastEmit_ISD_FNEG_MVT_v8f16_r(MVT RetVT, Register Op0) {
432 if (RetVT.SimpleTy != MVT::v8f16)
433 return Register();
434 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
435 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEG_F16x8, RC: &WebAssembly::V128RegClass, Op0);
436 }
437 return Register();
438}
439
440Register fastEmit_ISD_FNEG_MVT_v4f32_r(MVT RetVT, Register Op0) {
441 if (RetVT.SimpleTy != MVT::v4f32)
442 return Register();
443 if ((Subtarget->hasSIMD128())) {
444 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEG_F32x4, RC: &WebAssembly::V128RegClass, Op0);
445 }
446 return Register();
447}
448
449Register fastEmit_ISD_FNEG_MVT_v2f64_r(MVT RetVT, Register Op0) {
450 if (RetVT.SimpleTy != MVT::v2f64)
451 return Register();
452 if ((Subtarget->hasSIMD128())) {
453 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEG_F64x2, RC: &WebAssembly::V128RegClass, Op0);
454 }
455 return Register();
456}
457
458Register fastEmit_ISD_FNEG_r(MVT VT, MVT RetVT, Register Op0) {
459 switch (VT.SimpleTy) {
460 case MVT::f32: return fastEmit_ISD_FNEG_MVT_f32_r(RetVT, Op0);
461 case MVT::f64: return fastEmit_ISD_FNEG_MVT_f64_r(RetVT, Op0);
462 case MVT::v8f16: return fastEmit_ISD_FNEG_MVT_v8f16_r(RetVT, Op0);
463 case MVT::v4f32: return fastEmit_ISD_FNEG_MVT_v4f32_r(RetVT, Op0);
464 case MVT::v2f64: return fastEmit_ISD_FNEG_MVT_v2f64_r(RetVT, Op0);
465 default: return Register();
466 }
467}
468
469// FastEmit functions for ISD::FP_EXTEND.
470
471Register fastEmit_ISD_FP_EXTEND_MVT_f32_r(MVT RetVT, Register Op0) {
472 if (RetVT.SimpleTy != MVT::f64)
473 return Register();
474 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F64_PROMOTE_F32, RC: &WebAssembly::F64RegClass, Op0);
475}
476
477Register fastEmit_ISD_FP_EXTEND_r(MVT VT, MVT RetVT, Register Op0) {
478 switch (VT.SimpleTy) {
479 case MVT::f32: return fastEmit_ISD_FP_EXTEND_MVT_f32_r(RetVT, Op0);
480 default: return Register();
481 }
482}
483
484// FastEmit functions for ISD::FP_ROUND.
485
486Register fastEmit_ISD_FP_ROUND_MVT_f64_r(MVT RetVT, Register Op0) {
487 if (RetVT.SimpleTy != MVT::f32)
488 return Register();
489 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F32_DEMOTE_F64, RC: &WebAssembly::F32RegClass, Op0);
490}
491
492Register fastEmit_ISD_FP_ROUND_r(MVT VT, MVT RetVT, Register Op0) {
493 switch (VT.SimpleTy) {
494 case MVT::f64: return fastEmit_ISD_FP_ROUND_MVT_f64_r(RetVT, Op0);
495 default: return Register();
496 }
497}
498
499// FastEmit functions for ISD::FP_TO_SINT.
500
501Register fastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i32_r(Register Op0) {
502 if ((!Subtarget->hasNontrappingFPToInt())) {
503 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FP_TO_SINT_I32_F32, RC: &WebAssembly::I32RegClass, Op0);
504 }
505 if ((Subtarget->hasNontrappingFPToInt())) {
506 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I32_TRUNC_S_SAT_F32, RC: &WebAssembly::I32RegClass, Op0);
507 }
508 return Register();
509}
510
511Register fastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i64_r(Register Op0) {
512 if ((!Subtarget->hasNontrappingFPToInt())) {
513 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FP_TO_SINT_I64_F32, RC: &WebAssembly::I64RegClass, Op0);
514 }
515 if ((Subtarget->hasNontrappingFPToInt())) {
516 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I64_TRUNC_S_SAT_F32, RC: &WebAssembly::I64RegClass, Op0);
517 }
518 return Register();
519}
520
521Register fastEmit_ISD_FP_TO_SINT_MVT_f32_r(MVT RetVT, Register Op0) {
522switch (RetVT.SimpleTy) {
523 case MVT::i32: return fastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i32_r(Op0);
524 case MVT::i64: return fastEmit_ISD_FP_TO_SINT_MVT_f32_MVT_i64_r(Op0);
525 default: return Register();
526}
527}
528
529Register fastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i32_r(Register Op0) {
530 if ((!Subtarget->hasNontrappingFPToInt())) {
531 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FP_TO_SINT_I32_F64, RC: &WebAssembly::I32RegClass, Op0);
532 }
533 if ((Subtarget->hasNontrappingFPToInt())) {
534 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I32_TRUNC_S_SAT_F64, RC: &WebAssembly::I32RegClass, Op0);
535 }
536 return Register();
537}
538
539Register fastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i64_r(Register Op0) {
540 if ((!Subtarget->hasNontrappingFPToInt())) {
541 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FP_TO_SINT_I64_F64, RC: &WebAssembly::I64RegClass, Op0);
542 }
543 if ((Subtarget->hasNontrappingFPToInt())) {
544 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I64_TRUNC_S_SAT_F64, RC: &WebAssembly::I64RegClass, Op0);
545 }
546 return Register();
547}
548
549Register fastEmit_ISD_FP_TO_SINT_MVT_f64_r(MVT RetVT, Register Op0) {
550switch (RetVT.SimpleTy) {
551 case MVT::i32: return fastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i32_r(Op0);
552 case MVT::i64: return fastEmit_ISD_FP_TO_SINT_MVT_f64_MVT_i64_r(Op0);
553 default: return Register();
554}
555}
556
557Register fastEmit_ISD_FP_TO_SINT_MVT_v8f16_r(MVT RetVT, Register Op0) {
558 if (RetVT.SimpleTy != MVT::v8i16)
559 return Register();
560 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
561 return fastEmitInst_r(MachineInstOpcode: WebAssembly::fp_to_sint_I16x8, RC: &WebAssembly::V128RegClass, Op0);
562 }
563 return Register();
564}
565
566Register fastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
567 if (RetVT.SimpleTy != MVT::v4i32)
568 return Register();
569 if ((Subtarget->hasSIMD128())) {
570 return fastEmitInst_r(MachineInstOpcode: WebAssembly::fp_to_sint_I32x4, RC: &WebAssembly::V128RegClass, Op0);
571 }
572 return Register();
573}
574
575Register fastEmit_ISD_FP_TO_SINT_r(MVT VT, MVT RetVT, Register Op0) {
576 switch (VT.SimpleTy) {
577 case MVT::f32: return fastEmit_ISD_FP_TO_SINT_MVT_f32_r(RetVT, Op0);
578 case MVT::f64: return fastEmit_ISD_FP_TO_SINT_MVT_f64_r(RetVT, Op0);
579 case MVT::v8f16: return fastEmit_ISD_FP_TO_SINT_MVT_v8f16_r(RetVT, Op0);
580 case MVT::v4f32: return fastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(RetVT, Op0);
581 default: return Register();
582 }
583}
584
585// FastEmit functions for ISD::FP_TO_UINT.
586
587Register fastEmit_ISD_FP_TO_UINT_MVT_f32_MVT_i32_r(Register Op0) {
588 if ((!Subtarget->hasNontrappingFPToInt())) {
589 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FP_TO_UINT_I32_F32, RC: &WebAssembly::I32RegClass, Op0);
590 }
591 if ((Subtarget->hasNontrappingFPToInt())) {
592 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I32_TRUNC_U_SAT_F32, RC: &WebAssembly::I32RegClass, Op0);
593 }
594 return Register();
595}
596
597Register fastEmit_ISD_FP_TO_UINT_MVT_f32_MVT_i64_r(Register Op0) {
598 if ((!Subtarget->hasNontrappingFPToInt())) {
599 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FP_TO_UINT_I64_F32, RC: &WebAssembly::I64RegClass, Op0);
600 }
601 if ((Subtarget->hasNontrappingFPToInt())) {
602 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I64_TRUNC_U_SAT_F32, RC: &WebAssembly::I64RegClass, Op0);
603 }
604 return Register();
605}
606
607Register fastEmit_ISD_FP_TO_UINT_MVT_f32_r(MVT RetVT, Register Op0) {
608switch (RetVT.SimpleTy) {
609 case MVT::i32: return fastEmit_ISD_FP_TO_UINT_MVT_f32_MVT_i32_r(Op0);
610 case MVT::i64: return fastEmit_ISD_FP_TO_UINT_MVT_f32_MVT_i64_r(Op0);
611 default: return Register();
612}
613}
614
615Register fastEmit_ISD_FP_TO_UINT_MVT_f64_MVT_i32_r(Register Op0) {
616 if ((!Subtarget->hasNontrappingFPToInt())) {
617 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FP_TO_UINT_I32_F64, RC: &WebAssembly::I32RegClass, Op0);
618 }
619 if ((Subtarget->hasNontrappingFPToInt())) {
620 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I32_TRUNC_U_SAT_F64, RC: &WebAssembly::I32RegClass, Op0);
621 }
622 return Register();
623}
624
625Register fastEmit_ISD_FP_TO_UINT_MVT_f64_MVT_i64_r(Register Op0) {
626 if ((!Subtarget->hasNontrappingFPToInt())) {
627 return fastEmitInst_r(MachineInstOpcode: WebAssembly::FP_TO_UINT_I64_F64, RC: &WebAssembly::I64RegClass, Op0);
628 }
629 if ((Subtarget->hasNontrappingFPToInt())) {
630 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I64_TRUNC_U_SAT_F64, RC: &WebAssembly::I64RegClass, Op0);
631 }
632 return Register();
633}
634
635Register fastEmit_ISD_FP_TO_UINT_MVT_f64_r(MVT RetVT, Register Op0) {
636switch (RetVT.SimpleTy) {
637 case MVT::i32: return fastEmit_ISD_FP_TO_UINT_MVT_f64_MVT_i32_r(Op0);
638 case MVT::i64: return fastEmit_ISD_FP_TO_UINT_MVT_f64_MVT_i64_r(Op0);
639 default: return Register();
640}
641}
642
643Register fastEmit_ISD_FP_TO_UINT_MVT_v8f16_r(MVT RetVT, Register Op0) {
644 if (RetVT.SimpleTy != MVT::v8i16)
645 return Register();
646 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
647 return fastEmitInst_r(MachineInstOpcode: WebAssembly::fp_to_uint_I16x8, RC: &WebAssembly::V128RegClass, Op0);
648 }
649 return Register();
650}
651
652Register fastEmit_ISD_FP_TO_UINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
653 if (RetVT.SimpleTy != MVT::v4i32)
654 return Register();
655 if ((Subtarget->hasSIMD128())) {
656 return fastEmitInst_r(MachineInstOpcode: WebAssembly::fp_to_uint_I32x4, RC: &WebAssembly::V128RegClass, Op0);
657 }
658 return Register();
659}
660
661Register fastEmit_ISD_FP_TO_UINT_r(MVT VT, MVT RetVT, Register Op0) {
662 switch (VT.SimpleTy) {
663 case MVT::f32: return fastEmit_ISD_FP_TO_UINT_MVT_f32_r(RetVT, Op0);
664 case MVT::f64: return fastEmit_ISD_FP_TO_UINT_MVT_f64_r(RetVT, Op0);
665 case MVT::v8f16: return fastEmit_ISD_FP_TO_UINT_MVT_v8f16_r(RetVT, Op0);
666 case MVT::v4f32: return fastEmit_ISD_FP_TO_UINT_MVT_v4f32_r(RetVT, Op0);
667 default: return Register();
668 }
669}
670
671// FastEmit functions for ISD::FRINT.
672
673Register fastEmit_ISD_FRINT_MVT_f32_r(MVT RetVT, Register Op0) {
674 if (RetVT.SimpleTy != MVT::f32)
675 return Register();
676 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F32, RC: &WebAssembly::F32RegClass, Op0);
677}
678
679Register fastEmit_ISD_FRINT_MVT_f64_r(MVT RetVT, Register Op0) {
680 if (RetVT.SimpleTy != MVT::f64)
681 return Register();
682 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F64, RC: &WebAssembly::F64RegClass, Op0);
683}
684
685Register fastEmit_ISD_FRINT_MVT_v8f16_r(MVT RetVT, Register Op0) {
686 if (RetVT.SimpleTy != MVT::v8f16)
687 return Register();
688 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F16x8, RC: &WebAssembly::V128RegClass, Op0);
689}
690
691Register fastEmit_ISD_FRINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
692 if (RetVT.SimpleTy != MVT::v4f32)
693 return Register();
694 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F32x4, RC: &WebAssembly::V128RegClass, Op0);
695}
696
697Register fastEmit_ISD_FRINT_MVT_v2f64_r(MVT RetVT, Register Op0) {
698 if (RetVT.SimpleTy != MVT::v2f64)
699 return Register();
700 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F64x2, RC: &WebAssembly::V128RegClass, Op0);
701}
702
703Register fastEmit_ISD_FRINT_r(MVT VT, MVT RetVT, Register Op0) {
704 switch (VT.SimpleTy) {
705 case MVT::f32: return fastEmit_ISD_FRINT_MVT_f32_r(RetVT, Op0);
706 case MVT::f64: return fastEmit_ISD_FRINT_MVT_f64_r(RetVT, Op0);
707 case MVT::v8f16: return fastEmit_ISD_FRINT_MVT_v8f16_r(RetVT, Op0);
708 case MVT::v4f32: return fastEmit_ISD_FRINT_MVT_v4f32_r(RetVT, Op0);
709 case MVT::v2f64: return fastEmit_ISD_FRINT_MVT_v2f64_r(RetVT, Op0);
710 default: return Register();
711 }
712}
713
714// FastEmit functions for ISD::FROUNDEVEN.
715
716Register fastEmit_ISD_FROUNDEVEN_MVT_f32_r(MVT RetVT, Register Op0) {
717 if (RetVT.SimpleTy != MVT::f32)
718 return Register();
719 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F32, RC: &WebAssembly::F32RegClass, Op0);
720}
721
722Register fastEmit_ISD_FROUNDEVEN_MVT_f64_r(MVT RetVT, Register Op0) {
723 if (RetVT.SimpleTy != MVT::f64)
724 return Register();
725 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F64, RC: &WebAssembly::F64RegClass, Op0);
726}
727
728Register fastEmit_ISD_FROUNDEVEN_MVT_v8f16_r(MVT RetVT, Register Op0) {
729 if (RetVT.SimpleTy != MVT::v8f16)
730 return Register();
731 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F16x8, RC: &WebAssembly::V128RegClass, Op0);
732}
733
734Register fastEmit_ISD_FROUNDEVEN_MVT_v4f32_r(MVT RetVT, Register Op0) {
735 if (RetVT.SimpleTy != MVT::v4f32)
736 return Register();
737 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F32x4, RC: &WebAssembly::V128RegClass, Op0);
738}
739
740Register fastEmit_ISD_FROUNDEVEN_MVT_v2f64_r(MVT RetVT, Register Op0) {
741 if (RetVT.SimpleTy != MVT::v2f64)
742 return Register();
743 return fastEmitInst_r(MachineInstOpcode: WebAssembly::NEAREST_F64x2, RC: &WebAssembly::V128RegClass, Op0);
744}
745
746Register fastEmit_ISD_FROUNDEVEN_r(MVT VT, MVT RetVT, Register Op0) {
747 switch (VT.SimpleTy) {
748 case MVT::f32: return fastEmit_ISD_FROUNDEVEN_MVT_f32_r(RetVT, Op0);
749 case MVT::f64: return fastEmit_ISD_FROUNDEVEN_MVT_f64_r(RetVT, Op0);
750 case MVT::v8f16: return fastEmit_ISD_FROUNDEVEN_MVT_v8f16_r(RetVT, Op0);
751 case MVT::v4f32: return fastEmit_ISD_FROUNDEVEN_MVT_v4f32_r(RetVT, Op0);
752 case MVT::v2f64: return fastEmit_ISD_FROUNDEVEN_MVT_v2f64_r(RetVT, Op0);
753 default: return Register();
754 }
755}
756
757// FastEmit functions for ISD::FSQRT.
758
759Register fastEmit_ISD_FSQRT_MVT_f32_r(MVT RetVT, Register Op0) {
760 if (RetVT.SimpleTy != MVT::f32)
761 return Register();
762 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SQRT_F32, RC: &WebAssembly::F32RegClass, Op0);
763}
764
765Register fastEmit_ISD_FSQRT_MVT_f64_r(MVT RetVT, Register Op0) {
766 if (RetVT.SimpleTy != MVT::f64)
767 return Register();
768 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SQRT_F64, RC: &WebAssembly::F64RegClass, Op0);
769}
770
771Register fastEmit_ISD_FSQRT_MVT_v8f16_r(MVT RetVT, Register Op0) {
772 if (RetVT.SimpleTy != MVT::v8f16)
773 return Register();
774 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
775 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SQRT_F16x8, RC: &WebAssembly::V128RegClass, Op0);
776 }
777 return Register();
778}
779
780Register fastEmit_ISD_FSQRT_MVT_v4f32_r(MVT RetVT, Register Op0) {
781 if (RetVT.SimpleTy != MVT::v4f32)
782 return Register();
783 if ((Subtarget->hasSIMD128())) {
784 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SQRT_F32x4, RC: &WebAssembly::V128RegClass, Op0);
785 }
786 return Register();
787}
788
789Register fastEmit_ISD_FSQRT_MVT_v2f64_r(MVT RetVT, Register Op0) {
790 if (RetVT.SimpleTy != MVT::v2f64)
791 return Register();
792 if ((Subtarget->hasSIMD128())) {
793 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SQRT_F64x2, RC: &WebAssembly::V128RegClass, Op0);
794 }
795 return Register();
796}
797
798Register fastEmit_ISD_FSQRT_r(MVT VT, MVT RetVT, Register Op0) {
799 switch (VT.SimpleTy) {
800 case MVT::f32: return fastEmit_ISD_FSQRT_MVT_f32_r(RetVT, Op0);
801 case MVT::f64: return fastEmit_ISD_FSQRT_MVT_f64_r(RetVT, Op0);
802 case MVT::v8f16: return fastEmit_ISD_FSQRT_MVT_v8f16_r(RetVT, Op0);
803 case MVT::v4f32: return fastEmit_ISD_FSQRT_MVT_v4f32_r(RetVT, Op0);
804 case MVT::v2f64: return fastEmit_ISD_FSQRT_MVT_v2f64_r(RetVT, Op0);
805 default: return Register();
806 }
807}
808
809// FastEmit functions for ISD::FTRUNC.
810
811Register fastEmit_ISD_FTRUNC_MVT_f32_r(MVT RetVT, Register Op0) {
812 if (RetVT.SimpleTy != MVT::f32)
813 return Register();
814 return fastEmitInst_r(MachineInstOpcode: WebAssembly::TRUNC_F32, RC: &WebAssembly::F32RegClass, Op0);
815}
816
817Register fastEmit_ISD_FTRUNC_MVT_f64_r(MVT RetVT, Register Op0) {
818 if (RetVT.SimpleTy != MVT::f64)
819 return Register();
820 return fastEmitInst_r(MachineInstOpcode: WebAssembly::TRUNC_F64, RC: &WebAssembly::F64RegClass, Op0);
821}
822
823Register fastEmit_ISD_FTRUNC_MVT_v8f16_r(MVT RetVT, Register Op0) {
824 if (RetVT.SimpleTy != MVT::v8f16)
825 return Register();
826 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
827 return fastEmitInst_r(MachineInstOpcode: WebAssembly::TRUNC_F16x8, RC: &WebAssembly::V128RegClass, Op0);
828 }
829 return Register();
830}
831
832Register fastEmit_ISD_FTRUNC_MVT_v4f32_r(MVT RetVT, Register Op0) {
833 if (RetVT.SimpleTy != MVT::v4f32)
834 return Register();
835 if ((Subtarget->hasSIMD128())) {
836 return fastEmitInst_r(MachineInstOpcode: WebAssembly::TRUNC_F32x4, RC: &WebAssembly::V128RegClass, Op0);
837 }
838 return Register();
839}
840
841Register fastEmit_ISD_FTRUNC_MVT_v2f64_r(MVT RetVT, Register Op0) {
842 if (RetVT.SimpleTy != MVT::v2f64)
843 return Register();
844 if ((Subtarget->hasSIMD128())) {
845 return fastEmitInst_r(MachineInstOpcode: WebAssembly::TRUNC_F64x2, RC: &WebAssembly::V128RegClass, Op0);
846 }
847 return Register();
848}
849
850Register fastEmit_ISD_FTRUNC_r(MVT VT, MVT RetVT, Register Op0) {
851 switch (VT.SimpleTy) {
852 case MVT::f32: return fastEmit_ISD_FTRUNC_MVT_f32_r(RetVT, Op0);
853 case MVT::f64: return fastEmit_ISD_FTRUNC_MVT_f64_r(RetVT, Op0);
854 case MVT::v8f16: return fastEmit_ISD_FTRUNC_MVT_v8f16_r(RetVT, Op0);
855 case MVT::v4f32: return fastEmit_ISD_FTRUNC_MVT_v4f32_r(RetVT, Op0);
856 case MVT::v2f64: return fastEmit_ISD_FTRUNC_MVT_v2f64_r(RetVT, Op0);
857 default: return Register();
858 }
859}
860
861// FastEmit functions for ISD::SCALAR_TO_VECTOR.
862
863Register fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v16i8_r(Register Op0) {
864 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_I8x16, RC: &WebAssembly::V128RegClass, Op0);
865}
866
867Register fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v8i16_r(Register Op0) {
868 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_I16x8, RC: &WebAssembly::V128RegClass, Op0);
869}
870
871Register fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v4i32_r(Register Op0) {
872 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_I32x4, RC: &WebAssembly::V128RegClass, Op0);
873}
874
875Register fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(MVT RetVT, Register Op0) {
876switch (RetVT.SimpleTy) {
877 case MVT::v16i8: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v16i8_r(Op0);
878 case MVT::v8i16: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v8i16_r(Op0);
879 case MVT::v4i32: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_MVT_v4i32_r(Op0);
880 default: return Register();
881}
882}
883
884Register fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_r(MVT RetVT, Register Op0) {
885 if (RetVT.SimpleTy != MVT::v2i64)
886 return Register();
887 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_I64x2, RC: &WebAssembly::V128RegClass, Op0);
888}
889
890Register fastEmit_ISD_SCALAR_TO_VECTOR_MVT_f32_r(MVT RetVT, Register Op0) {
891 if (RetVT.SimpleTy != MVT::v4f32)
892 return Register();
893 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_F32x4, RC: &WebAssembly::V128RegClass, Op0);
894}
895
896Register fastEmit_ISD_SCALAR_TO_VECTOR_MVT_f64_r(MVT RetVT, Register Op0) {
897 if (RetVT.SimpleTy != MVT::v2f64)
898 return Register();
899 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_F64x2, RC: &WebAssembly::V128RegClass, Op0);
900}
901
902Register fastEmit_ISD_SCALAR_TO_VECTOR_r(MVT VT, MVT RetVT, Register Op0) {
903 switch (VT.SimpleTy) {
904 case MVT::i32: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(RetVT, Op0);
905 case MVT::i64: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i64_r(RetVT, Op0);
906 case MVT::f32: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_f32_r(RetVT, Op0);
907 case MVT::f64: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_f64_r(RetVT, Op0);
908 default: return Register();
909 }
910}
911
912// FastEmit functions for ISD::SIGN_EXTEND.
913
914Register fastEmit_ISD_SIGN_EXTEND_MVT_i32_r(MVT RetVT, Register Op0) {
915 if (RetVT.SimpleTy != MVT::i64)
916 return Register();
917 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I64_EXTEND_S_I32, RC: &WebAssembly::I64RegClass, Op0);
918}
919
920Register fastEmit_ISD_SIGN_EXTEND_r(MVT VT, MVT RetVT, Register Op0) {
921 switch (VT.SimpleTy) {
922 case MVT::i32: return fastEmit_ISD_SIGN_EXTEND_MVT_i32_r(RetVT, Op0);
923 default: return Register();
924 }
925}
926
927// FastEmit functions for ISD::SINT_TO_FP.
928
929Register fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(Register Op0) {
930 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F32_CONVERT_S_I32, RC: &WebAssembly::F32RegClass, Op0);
931}
932
933Register fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(Register Op0) {
934 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F64_CONVERT_S_I32, RC: &WebAssembly::F64RegClass, Op0);
935}
936
937Register fastEmit_ISD_SINT_TO_FP_MVT_i32_r(MVT RetVT, Register Op0) {
938switch (RetVT.SimpleTy) {
939 case MVT::f32: return fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(Op0);
940 case MVT::f64: return fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(Op0);
941 default: return Register();
942}
943}
944
945Register fastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f32_r(Register Op0) {
946 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F32_CONVERT_S_I64, RC: &WebAssembly::F32RegClass, Op0);
947}
948
949Register fastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f64_r(Register Op0) {
950 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F64_CONVERT_S_I64, RC: &WebAssembly::F64RegClass, Op0);
951}
952
953Register fastEmit_ISD_SINT_TO_FP_MVT_i64_r(MVT RetVT, Register Op0) {
954switch (RetVT.SimpleTy) {
955 case MVT::f32: return fastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f32_r(Op0);
956 case MVT::f64: return fastEmit_ISD_SINT_TO_FP_MVT_i64_MVT_f64_r(Op0);
957 default: return Register();
958}
959}
960
961Register fastEmit_ISD_SINT_TO_FP_MVT_v8i16_r(MVT RetVT, Register Op0) {
962 if (RetVT.SimpleTy != MVT::v8f16)
963 return Register();
964 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
965 return fastEmitInst_r(MachineInstOpcode: WebAssembly::sint_to_fp_F16x8, RC: &WebAssembly::V128RegClass, Op0);
966 }
967 return Register();
968}
969
970Register fastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(MVT RetVT, Register Op0) {
971 if (RetVT.SimpleTy != MVT::v4f32)
972 return Register();
973 if ((Subtarget->hasSIMD128())) {
974 return fastEmitInst_r(MachineInstOpcode: WebAssembly::sint_to_fp_F32x4, RC: &WebAssembly::V128RegClass, Op0);
975 }
976 return Register();
977}
978
979Register fastEmit_ISD_SINT_TO_FP_r(MVT VT, MVT RetVT, Register Op0) {
980 switch (VT.SimpleTy) {
981 case MVT::i32: return fastEmit_ISD_SINT_TO_FP_MVT_i32_r(RetVT, Op0);
982 case MVT::i64: return fastEmit_ISD_SINT_TO_FP_MVT_i64_r(RetVT, Op0);
983 case MVT::v8i16: return fastEmit_ISD_SINT_TO_FP_MVT_v8i16_r(RetVT, Op0);
984 case MVT::v4i32: return fastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(RetVT, Op0);
985 default: return Register();
986 }
987}
988
989// FastEmit functions for ISD::SPLAT_VECTOR.
990
991Register fastEmit_ISD_SPLAT_VECTOR_MVT_i32_MVT_v16i8_r(Register Op0) {
992 if ((Subtarget->hasSIMD128())) {
993 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_I8x16, RC: &WebAssembly::V128RegClass, Op0);
994 }
995 return Register();
996}
997
998Register fastEmit_ISD_SPLAT_VECTOR_MVT_i32_MVT_v8i16_r(Register Op0) {
999 if ((Subtarget->hasSIMD128())) {
1000 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_I16x8, RC: &WebAssembly::V128RegClass, Op0);
1001 }
1002 return Register();
1003}
1004
1005Register fastEmit_ISD_SPLAT_VECTOR_MVT_i32_MVT_v4i32_r(Register Op0) {
1006 if ((Subtarget->hasSIMD128())) {
1007 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_I32x4, RC: &WebAssembly::V128RegClass, Op0);
1008 }
1009 return Register();
1010}
1011
1012Register fastEmit_ISD_SPLAT_VECTOR_MVT_i32_r(MVT RetVT, Register Op0) {
1013switch (RetVT.SimpleTy) {
1014 case MVT::v16i8: return fastEmit_ISD_SPLAT_VECTOR_MVT_i32_MVT_v16i8_r(Op0);
1015 case MVT::v8i16: return fastEmit_ISD_SPLAT_VECTOR_MVT_i32_MVT_v8i16_r(Op0);
1016 case MVT::v4i32: return fastEmit_ISD_SPLAT_VECTOR_MVT_i32_MVT_v4i32_r(Op0);
1017 default: return Register();
1018}
1019}
1020
1021Register fastEmit_ISD_SPLAT_VECTOR_MVT_i64_r(MVT RetVT, Register Op0) {
1022 if (RetVT.SimpleTy != MVT::v2i64)
1023 return Register();
1024 if ((Subtarget->hasSIMD128())) {
1025 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_I64x2, RC: &WebAssembly::V128RegClass, Op0);
1026 }
1027 return Register();
1028}
1029
1030Register fastEmit_ISD_SPLAT_VECTOR_MVT_f32_r(MVT RetVT, Register Op0) {
1031 if (RetVT.SimpleTy != MVT::v4f32)
1032 return Register();
1033 if ((Subtarget->hasSIMD128())) {
1034 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_F32x4, RC: &WebAssembly::V128RegClass, Op0);
1035 }
1036 return Register();
1037}
1038
1039Register fastEmit_ISD_SPLAT_VECTOR_MVT_f64_r(MVT RetVT, Register Op0) {
1040 if (RetVT.SimpleTy != MVT::v2f64)
1041 return Register();
1042 if ((Subtarget->hasSIMD128())) {
1043 return fastEmitInst_r(MachineInstOpcode: WebAssembly::SPLAT_F64x2, RC: &WebAssembly::V128RegClass, Op0);
1044 }
1045 return Register();
1046}
1047
1048Register fastEmit_ISD_SPLAT_VECTOR_r(MVT VT, MVT RetVT, Register Op0) {
1049 switch (VT.SimpleTy) {
1050 case MVT::i32: return fastEmit_ISD_SPLAT_VECTOR_MVT_i32_r(RetVT, Op0);
1051 case MVT::i64: return fastEmit_ISD_SPLAT_VECTOR_MVT_i64_r(RetVT, Op0);
1052 case MVT::f32: return fastEmit_ISD_SPLAT_VECTOR_MVT_f32_r(RetVT, Op0);
1053 case MVT::f64: return fastEmit_ISD_SPLAT_VECTOR_MVT_f64_r(RetVT, Op0);
1054 default: return Register();
1055 }
1056}
1057
1058// FastEmit functions for ISD::TRUNCATE.
1059
1060Register fastEmit_ISD_TRUNCATE_MVT_i64_r(MVT RetVT, Register Op0) {
1061 if (RetVT.SimpleTy != MVT::i32)
1062 return Register();
1063 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I32_WRAP_I64, RC: &WebAssembly::I32RegClass, Op0);
1064}
1065
1066Register fastEmit_ISD_TRUNCATE_r(MVT VT, MVT RetVT, Register Op0) {
1067 switch (VT.SimpleTy) {
1068 case MVT::i64: return fastEmit_ISD_TRUNCATE_MVT_i64_r(RetVT, Op0);
1069 default: return Register();
1070 }
1071}
1072
1073// FastEmit functions for ISD::UINT_TO_FP.
1074
1075Register fastEmit_ISD_UINT_TO_FP_MVT_i32_MVT_f32_r(Register Op0) {
1076 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F32_CONVERT_U_I32, RC: &WebAssembly::F32RegClass, Op0);
1077}
1078
1079Register fastEmit_ISD_UINT_TO_FP_MVT_i32_MVT_f64_r(Register Op0) {
1080 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F64_CONVERT_U_I32, RC: &WebAssembly::F64RegClass, Op0);
1081}
1082
1083Register fastEmit_ISD_UINT_TO_FP_MVT_i32_r(MVT RetVT, Register Op0) {
1084switch (RetVT.SimpleTy) {
1085 case MVT::f32: return fastEmit_ISD_UINT_TO_FP_MVT_i32_MVT_f32_r(Op0);
1086 case MVT::f64: return fastEmit_ISD_UINT_TO_FP_MVT_i32_MVT_f64_r(Op0);
1087 default: return Register();
1088}
1089}
1090
1091Register fastEmit_ISD_UINT_TO_FP_MVT_i64_MVT_f32_r(Register Op0) {
1092 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F32_CONVERT_U_I64, RC: &WebAssembly::F32RegClass, Op0);
1093}
1094
1095Register fastEmit_ISD_UINT_TO_FP_MVT_i64_MVT_f64_r(Register Op0) {
1096 return fastEmitInst_r(MachineInstOpcode: WebAssembly::F64_CONVERT_U_I64, RC: &WebAssembly::F64RegClass, Op0);
1097}
1098
1099Register fastEmit_ISD_UINT_TO_FP_MVT_i64_r(MVT RetVT, Register Op0) {
1100switch (RetVT.SimpleTy) {
1101 case MVT::f32: return fastEmit_ISD_UINT_TO_FP_MVT_i64_MVT_f32_r(Op0);
1102 case MVT::f64: return fastEmit_ISD_UINT_TO_FP_MVT_i64_MVT_f64_r(Op0);
1103 default: return Register();
1104}
1105}
1106
1107Register fastEmit_ISD_UINT_TO_FP_MVT_v8i16_r(MVT RetVT, Register Op0) {
1108 if (RetVT.SimpleTy != MVT::v8f16)
1109 return Register();
1110 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
1111 return fastEmitInst_r(MachineInstOpcode: WebAssembly::uint_to_fp_F16x8, RC: &WebAssembly::V128RegClass, Op0);
1112 }
1113 return Register();
1114}
1115
1116Register fastEmit_ISD_UINT_TO_FP_MVT_v4i32_r(MVT RetVT, Register Op0) {
1117 if (RetVT.SimpleTy != MVT::v4f32)
1118 return Register();
1119 if ((Subtarget->hasSIMD128())) {
1120 return fastEmitInst_r(MachineInstOpcode: WebAssembly::uint_to_fp_F32x4, RC: &WebAssembly::V128RegClass, Op0);
1121 }
1122 return Register();
1123}
1124
1125Register fastEmit_ISD_UINT_TO_FP_r(MVT VT, MVT RetVT, Register Op0) {
1126 switch (VT.SimpleTy) {
1127 case MVT::i32: return fastEmit_ISD_UINT_TO_FP_MVT_i32_r(RetVT, Op0);
1128 case MVT::i64: return fastEmit_ISD_UINT_TO_FP_MVT_i64_r(RetVT, Op0);
1129 case MVT::v8i16: return fastEmit_ISD_UINT_TO_FP_MVT_v8i16_r(RetVT, Op0);
1130 case MVT::v4i32: return fastEmit_ISD_UINT_TO_FP_MVT_v4i32_r(RetVT, Op0);
1131 default: return Register();
1132 }
1133}
1134
1135// FastEmit functions for ISD::ZERO_EXTEND.
1136
1137Register fastEmit_ISD_ZERO_EXTEND_MVT_i32_r(MVT RetVT, Register Op0) {
1138 if (RetVT.SimpleTy != MVT::i64)
1139 return Register();
1140 return fastEmitInst_r(MachineInstOpcode: WebAssembly::I64_EXTEND_U_I32, RC: &WebAssembly::I64RegClass, Op0);
1141}
1142
1143Register fastEmit_ISD_ZERO_EXTEND_r(MVT VT, MVT RetVT, Register Op0) {
1144 switch (VT.SimpleTy) {
1145 case MVT::i32: return fastEmit_ISD_ZERO_EXTEND_MVT_i32_r(RetVT, Op0);
1146 default: return Register();
1147 }
1148}
1149
1150// FastEmit functions for WebAssemblyISD::BR_TABLE.
1151
1152Register fastEmit_WebAssemblyISD_BR_TABLE_MVT_i32_r(MVT RetVT, Register Op0) {
1153 if (RetVT.SimpleTy != MVT::isVoid)
1154 return Register();
1155 return fastEmitInst_r(MachineInstOpcode: WebAssembly::BR_TABLE_I32, RC: &WebAssembly::I32RegClass, Op0);
1156}
1157
1158Register fastEmit_WebAssemblyISD_BR_TABLE_MVT_i64_r(MVT RetVT, Register Op0) {
1159 if (RetVT.SimpleTy != MVT::isVoid)
1160 return Register();
1161 return fastEmitInst_r(MachineInstOpcode: WebAssembly::BR_TABLE_I64, RC: &WebAssembly::I64RegClass, Op0);
1162}
1163
1164Register fastEmit_WebAssemblyISD_BR_TABLE_r(MVT VT, MVT RetVT, Register Op0) {
1165 switch (VT.SimpleTy) {
1166 case MVT::i32: return fastEmit_WebAssemblyISD_BR_TABLE_MVT_i32_r(RetVT, Op0);
1167 case MVT::i64: return fastEmit_WebAssemblyISD_BR_TABLE_MVT_i64_r(RetVT, Op0);
1168 default: return Register();
1169 }
1170}
1171
1172// FastEmit functions for WebAssemblyISD::CONVERT_LOW_S.
1173
1174Register fastEmit_WebAssemblyISD_CONVERT_LOW_S_MVT_v4i32_r(MVT RetVT, Register Op0) {
1175 if (RetVT.SimpleTy != MVT::v2f64)
1176 return Register();
1177 if ((Subtarget->hasSIMD128())) {
1178 return fastEmitInst_r(MachineInstOpcode: WebAssembly::convert_low_s_F64x2, RC: &WebAssembly::V128RegClass, Op0);
1179 }
1180 return Register();
1181}
1182
1183Register fastEmit_WebAssemblyISD_CONVERT_LOW_S_r(MVT VT, MVT RetVT, Register Op0) {
1184 switch (VT.SimpleTy) {
1185 case MVT::v4i32: return fastEmit_WebAssemblyISD_CONVERT_LOW_S_MVT_v4i32_r(RetVT, Op0);
1186 default: return Register();
1187 }
1188}
1189
1190// FastEmit functions for WebAssemblyISD::CONVERT_LOW_U.
1191
1192Register fastEmit_WebAssemblyISD_CONVERT_LOW_U_MVT_v4i32_r(MVT RetVT, Register Op0) {
1193 if (RetVT.SimpleTy != MVT::v2f64)
1194 return Register();
1195 if ((Subtarget->hasSIMD128())) {
1196 return fastEmitInst_r(MachineInstOpcode: WebAssembly::convert_low_u_F64x2, RC: &WebAssembly::V128RegClass, Op0);
1197 }
1198 return Register();
1199}
1200
1201Register fastEmit_WebAssemblyISD_CONVERT_LOW_U_r(MVT VT, MVT RetVT, Register Op0) {
1202 switch (VT.SimpleTy) {
1203 case MVT::v4i32: return fastEmit_WebAssemblyISD_CONVERT_LOW_U_MVT_v4i32_r(RetVT, Op0);
1204 default: return Register();
1205 }
1206}
1207
1208// FastEmit functions for WebAssemblyISD::DEMOTE_ZERO.
1209
1210Register fastEmit_WebAssemblyISD_DEMOTE_ZERO_MVT_v2f64_r(MVT RetVT, Register Op0) {
1211 if (RetVT.SimpleTy != MVT::v4f32)
1212 return Register();
1213 if ((Subtarget->hasSIMD128())) {
1214 return fastEmitInst_r(MachineInstOpcode: WebAssembly::demote_zero_F32x4, RC: &WebAssembly::V128RegClass, Op0);
1215 }
1216 return Register();
1217}
1218
1219Register fastEmit_WebAssemblyISD_DEMOTE_ZERO_r(MVT VT, MVT RetVT, Register Op0) {
1220 switch (VT.SimpleTy) {
1221 case MVT::v2f64: return fastEmit_WebAssemblyISD_DEMOTE_ZERO_MVT_v2f64_r(RetVT, Op0);
1222 default: return Register();
1223 }
1224}
1225
1226// FastEmit functions for WebAssemblyISD::EXTEND_HIGH_S.
1227
1228Register fastEmit_WebAssemblyISD_EXTEND_HIGH_S_MVT_v16i8_r(MVT RetVT, Register Op0) {
1229 if (RetVT.SimpleTy != MVT::v8i16)
1230 return Register();
1231 if ((Subtarget->hasSIMD128())) {
1232 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_high_s_I16x8, RC: &WebAssembly::V128RegClass, Op0);
1233 }
1234 return Register();
1235}
1236
1237Register fastEmit_WebAssemblyISD_EXTEND_HIGH_S_MVT_v8i16_r(MVT RetVT, Register Op0) {
1238 if (RetVT.SimpleTy != MVT::v4i32)
1239 return Register();
1240 if ((Subtarget->hasSIMD128())) {
1241 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_high_s_I32x4, RC: &WebAssembly::V128RegClass, Op0);
1242 }
1243 return Register();
1244}
1245
1246Register fastEmit_WebAssemblyISD_EXTEND_HIGH_S_MVT_v4i32_r(MVT RetVT, Register Op0) {
1247 if (RetVT.SimpleTy != MVT::v2i64)
1248 return Register();
1249 if ((Subtarget->hasSIMD128())) {
1250 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_high_s_I64x2, RC: &WebAssembly::V128RegClass, Op0);
1251 }
1252 return Register();
1253}
1254
1255Register fastEmit_WebAssemblyISD_EXTEND_HIGH_S_r(MVT VT, MVT RetVT, Register Op0) {
1256 switch (VT.SimpleTy) {
1257 case MVT::v16i8: return fastEmit_WebAssemblyISD_EXTEND_HIGH_S_MVT_v16i8_r(RetVT, Op0);
1258 case MVT::v8i16: return fastEmit_WebAssemblyISD_EXTEND_HIGH_S_MVT_v8i16_r(RetVT, Op0);
1259 case MVT::v4i32: return fastEmit_WebAssemblyISD_EXTEND_HIGH_S_MVT_v4i32_r(RetVT, Op0);
1260 default: return Register();
1261 }
1262}
1263
1264// FastEmit functions for WebAssemblyISD::EXTEND_HIGH_U.
1265
1266Register fastEmit_WebAssemblyISD_EXTEND_HIGH_U_MVT_v16i8_r(MVT RetVT, Register Op0) {
1267 if (RetVT.SimpleTy != MVT::v8i16)
1268 return Register();
1269 if ((Subtarget->hasSIMD128())) {
1270 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_high_u_I16x8, RC: &WebAssembly::V128RegClass, Op0);
1271 }
1272 return Register();
1273}
1274
1275Register fastEmit_WebAssemblyISD_EXTEND_HIGH_U_MVT_v8i16_r(MVT RetVT, Register Op0) {
1276 if (RetVT.SimpleTy != MVT::v4i32)
1277 return Register();
1278 if ((Subtarget->hasSIMD128())) {
1279 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_high_u_I32x4, RC: &WebAssembly::V128RegClass, Op0);
1280 }
1281 return Register();
1282}
1283
1284Register fastEmit_WebAssemblyISD_EXTEND_HIGH_U_MVT_v4i32_r(MVT RetVT, Register Op0) {
1285 if (RetVT.SimpleTy != MVT::v2i64)
1286 return Register();
1287 if ((Subtarget->hasSIMD128())) {
1288 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_high_u_I64x2, RC: &WebAssembly::V128RegClass, Op0);
1289 }
1290 return Register();
1291}
1292
1293Register fastEmit_WebAssemblyISD_EXTEND_HIGH_U_r(MVT VT, MVT RetVT, Register Op0) {
1294 switch (VT.SimpleTy) {
1295 case MVT::v16i8: return fastEmit_WebAssemblyISD_EXTEND_HIGH_U_MVT_v16i8_r(RetVT, Op0);
1296 case MVT::v8i16: return fastEmit_WebAssemblyISD_EXTEND_HIGH_U_MVT_v8i16_r(RetVT, Op0);
1297 case MVT::v4i32: return fastEmit_WebAssemblyISD_EXTEND_HIGH_U_MVT_v4i32_r(RetVT, Op0);
1298 default: return Register();
1299 }
1300}
1301
1302// FastEmit functions for WebAssemblyISD::EXTEND_LOW_S.
1303
1304Register fastEmit_WebAssemblyISD_EXTEND_LOW_S_MVT_v16i8_r(MVT RetVT, Register Op0) {
1305 if (RetVT.SimpleTy != MVT::v8i16)
1306 return Register();
1307 if ((Subtarget->hasSIMD128())) {
1308 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_low_s_I16x8, RC: &WebAssembly::V128RegClass, Op0);
1309 }
1310 return Register();
1311}
1312
1313Register fastEmit_WebAssemblyISD_EXTEND_LOW_S_MVT_v8i16_r(MVT RetVT, Register Op0) {
1314 if (RetVT.SimpleTy != MVT::v4i32)
1315 return Register();
1316 if ((Subtarget->hasSIMD128())) {
1317 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_low_s_I32x4, RC: &WebAssembly::V128RegClass, Op0);
1318 }
1319 return Register();
1320}
1321
1322Register fastEmit_WebAssemblyISD_EXTEND_LOW_S_MVT_v4i32_r(MVT RetVT, Register Op0) {
1323 if (RetVT.SimpleTy != MVT::v2i64)
1324 return Register();
1325 if ((Subtarget->hasSIMD128())) {
1326 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_low_s_I64x2, RC: &WebAssembly::V128RegClass, Op0);
1327 }
1328 return Register();
1329}
1330
1331Register fastEmit_WebAssemblyISD_EXTEND_LOW_S_r(MVT VT, MVT RetVT, Register Op0) {
1332 switch (VT.SimpleTy) {
1333 case MVT::v16i8: return fastEmit_WebAssemblyISD_EXTEND_LOW_S_MVT_v16i8_r(RetVT, Op0);
1334 case MVT::v8i16: return fastEmit_WebAssemblyISD_EXTEND_LOW_S_MVT_v8i16_r(RetVT, Op0);
1335 case MVT::v4i32: return fastEmit_WebAssemblyISD_EXTEND_LOW_S_MVT_v4i32_r(RetVT, Op0);
1336 default: return Register();
1337 }
1338}
1339
1340// FastEmit functions for WebAssemblyISD::EXTEND_LOW_U.
1341
1342Register fastEmit_WebAssemblyISD_EXTEND_LOW_U_MVT_v16i8_r(MVT RetVT, Register Op0) {
1343 if (RetVT.SimpleTy != MVT::v8i16)
1344 return Register();
1345 if ((Subtarget->hasSIMD128())) {
1346 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_low_u_I16x8, RC: &WebAssembly::V128RegClass, Op0);
1347 }
1348 return Register();
1349}
1350
1351Register fastEmit_WebAssemblyISD_EXTEND_LOW_U_MVT_v8i16_r(MVT RetVT, Register Op0) {
1352 if (RetVT.SimpleTy != MVT::v4i32)
1353 return Register();
1354 if ((Subtarget->hasSIMD128())) {
1355 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_low_u_I32x4, RC: &WebAssembly::V128RegClass, Op0);
1356 }
1357 return Register();
1358}
1359
1360Register fastEmit_WebAssemblyISD_EXTEND_LOW_U_MVT_v4i32_r(MVT RetVT, Register Op0) {
1361 if (RetVT.SimpleTy != MVT::v2i64)
1362 return Register();
1363 if ((Subtarget->hasSIMD128())) {
1364 return fastEmitInst_r(MachineInstOpcode: WebAssembly::extend_low_u_I64x2, RC: &WebAssembly::V128RegClass, Op0);
1365 }
1366 return Register();
1367}
1368
1369Register fastEmit_WebAssemblyISD_EXTEND_LOW_U_r(MVT VT, MVT RetVT, Register Op0) {
1370 switch (VT.SimpleTy) {
1371 case MVT::v16i8: return fastEmit_WebAssemblyISD_EXTEND_LOW_U_MVT_v16i8_r(RetVT, Op0);
1372 case MVT::v8i16: return fastEmit_WebAssemblyISD_EXTEND_LOW_U_MVT_v8i16_r(RetVT, Op0);
1373 case MVT::v4i32: return fastEmit_WebAssemblyISD_EXTEND_LOW_U_MVT_v4i32_r(RetVT, Op0);
1374 default: return Register();
1375 }
1376}
1377
1378// FastEmit functions for WebAssemblyISD::PROMOTE_LOW.
1379
1380Register fastEmit_WebAssemblyISD_PROMOTE_LOW_MVT_v4f32_r(MVT RetVT, Register Op0) {
1381 if (RetVT.SimpleTy != MVT::v2f64)
1382 return Register();
1383 if ((Subtarget->hasSIMD128())) {
1384 return fastEmitInst_r(MachineInstOpcode: WebAssembly::promote_low_F64x2, RC: &WebAssembly::V128RegClass, Op0);
1385 }
1386 return Register();
1387}
1388
1389Register fastEmit_WebAssemblyISD_PROMOTE_LOW_r(MVT VT, MVT RetVT, Register Op0) {
1390 switch (VT.SimpleTy) {
1391 case MVT::v4f32: return fastEmit_WebAssemblyISD_PROMOTE_LOW_MVT_v4f32_r(RetVT, Op0);
1392 default: return Register();
1393 }
1394}
1395
1396// FastEmit functions for WebAssemblyISD::TRUNC_SAT_ZERO_S.
1397
1398Register fastEmit_WebAssemblyISD_TRUNC_SAT_ZERO_S_MVT_v2f64_r(MVT RetVT, Register Op0) {
1399 if (RetVT.SimpleTy != MVT::v4i32)
1400 return Register();
1401 if ((Subtarget->hasSIMD128())) {
1402 return fastEmitInst_r(MachineInstOpcode: WebAssembly::trunc_sat_zero_s_I32x4, RC: &WebAssembly::V128RegClass, Op0);
1403 }
1404 return Register();
1405}
1406
1407Register fastEmit_WebAssemblyISD_TRUNC_SAT_ZERO_S_r(MVT VT, MVT RetVT, Register Op0) {
1408 switch (VT.SimpleTy) {
1409 case MVT::v2f64: return fastEmit_WebAssemblyISD_TRUNC_SAT_ZERO_S_MVT_v2f64_r(RetVT, Op0);
1410 default: return Register();
1411 }
1412}
1413
1414// FastEmit functions for WebAssemblyISD::TRUNC_SAT_ZERO_U.
1415
1416Register fastEmit_WebAssemblyISD_TRUNC_SAT_ZERO_U_MVT_v2f64_r(MVT RetVT, Register Op0) {
1417 if (RetVT.SimpleTy != MVT::v4i32)
1418 return Register();
1419 if ((Subtarget->hasSIMD128())) {
1420 return fastEmitInst_r(MachineInstOpcode: WebAssembly::trunc_sat_zero_u_I32x4, RC: &WebAssembly::V128RegClass, Op0);
1421 }
1422 return Register();
1423}
1424
1425Register fastEmit_WebAssemblyISD_TRUNC_SAT_ZERO_U_r(MVT VT, MVT RetVT, Register Op0) {
1426 switch (VT.SimpleTy) {
1427 case MVT::v2f64: return fastEmit_WebAssemblyISD_TRUNC_SAT_ZERO_U_MVT_v2f64_r(RetVT, Op0);
1428 default: return Register();
1429 }
1430}
1431
1432// Top-level FastEmit function.
1433
1434Register fastEmit_r(MVT VT, MVT RetVT, unsigned Opcode, Register Op0) override {
1435 switch (Opcode) {
1436 case ISD::ABS: return fastEmit_ISD_ABS_r(VT, RetVT, Op0);
1437 case ISD::ANY_EXTEND: return fastEmit_ISD_ANY_EXTEND_r(VT, RetVT, Op0);
1438 case ISD::BITCAST: return fastEmit_ISD_BITCAST_r(VT, RetVT, Op0);
1439 case ISD::CTLZ: return fastEmit_ISD_CTLZ_r(VT, RetVT, Op0);
1440 case ISD::CTPOP: return fastEmit_ISD_CTPOP_r(VT, RetVT, Op0);
1441 case ISD::CTTZ: return fastEmit_ISD_CTTZ_r(VT, RetVT, Op0);
1442 case ISD::FABS: return fastEmit_ISD_FABS_r(VT, RetVT, Op0);
1443 case ISD::FCEIL: return fastEmit_ISD_FCEIL_r(VT, RetVT, Op0);
1444 case ISD::FFLOOR: return fastEmit_ISD_FFLOOR_r(VT, RetVT, Op0);
1445 case ISD::FNEARBYINT: return fastEmit_ISD_FNEARBYINT_r(VT, RetVT, Op0);
1446 case ISD::FNEG: return fastEmit_ISD_FNEG_r(VT, RetVT, Op0);
1447 case ISD::FP_EXTEND: return fastEmit_ISD_FP_EXTEND_r(VT, RetVT, Op0);
1448 case ISD::FP_ROUND: return fastEmit_ISD_FP_ROUND_r(VT, RetVT, Op0);
1449 case ISD::FP_TO_SINT: return fastEmit_ISD_FP_TO_SINT_r(VT, RetVT, Op0);
1450 case ISD::FP_TO_UINT: return fastEmit_ISD_FP_TO_UINT_r(VT, RetVT, Op0);
1451 case ISD::FRINT: return fastEmit_ISD_FRINT_r(VT, RetVT, Op0);
1452 case ISD::FROUNDEVEN: return fastEmit_ISD_FROUNDEVEN_r(VT, RetVT, Op0);
1453 case ISD::FSQRT: return fastEmit_ISD_FSQRT_r(VT, RetVT, Op0);
1454 case ISD::FTRUNC: return fastEmit_ISD_FTRUNC_r(VT, RetVT, Op0);
1455 case ISD::SCALAR_TO_VECTOR: return fastEmit_ISD_SCALAR_TO_VECTOR_r(VT, RetVT, Op0);
1456 case ISD::SIGN_EXTEND: return fastEmit_ISD_SIGN_EXTEND_r(VT, RetVT, Op0);
1457 case ISD::SINT_TO_FP: return fastEmit_ISD_SINT_TO_FP_r(VT, RetVT, Op0);
1458 case ISD::SPLAT_VECTOR: return fastEmit_ISD_SPLAT_VECTOR_r(VT, RetVT, Op0);
1459 case ISD::TRUNCATE: return fastEmit_ISD_TRUNCATE_r(VT, RetVT, Op0);
1460 case ISD::UINT_TO_FP: return fastEmit_ISD_UINT_TO_FP_r(VT, RetVT, Op0);
1461 case ISD::ZERO_EXTEND: return fastEmit_ISD_ZERO_EXTEND_r(VT, RetVT, Op0);
1462 case WebAssemblyISD::BR_TABLE: return fastEmit_WebAssemblyISD_BR_TABLE_r(VT, RetVT, Op0);
1463 case WebAssemblyISD::CONVERT_LOW_S: return fastEmit_WebAssemblyISD_CONVERT_LOW_S_r(VT, RetVT, Op0);
1464 case WebAssemblyISD::CONVERT_LOW_U: return fastEmit_WebAssemblyISD_CONVERT_LOW_U_r(VT, RetVT, Op0);
1465 case WebAssemblyISD::DEMOTE_ZERO: return fastEmit_WebAssemblyISD_DEMOTE_ZERO_r(VT, RetVT, Op0);
1466 case WebAssemblyISD::EXTEND_HIGH_S: return fastEmit_WebAssemblyISD_EXTEND_HIGH_S_r(VT, RetVT, Op0);
1467 case WebAssemblyISD::EXTEND_HIGH_U: return fastEmit_WebAssemblyISD_EXTEND_HIGH_U_r(VT, RetVT, Op0);
1468 case WebAssemblyISD::EXTEND_LOW_S: return fastEmit_WebAssemblyISD_EXTEND_LOW_S_r(VT, RetVT, Op0);
1469 case WebAssemblyISD::EXTEND_LOW_U: return fastEmit_WebAssemblyISD_EXTEND_LOW_U_r(VT, RetVT, Op0);
1470 case WebAssemblyISD::PROMOTE_LOW: return fastEmit_WebAssemblyISD_PROMOTE_LOW_r(VT, RetVT, Op0);
1471 case WebAssemblyISD::TRUNC_SAT_ZERO_S: return fastEmit_WebAssemblyISD_TRUNC_SAT_ZERO_S_r(VT, RetVT, Op0);
1472 case WebAssemblyISD::TRUNC_SAT_ZERO_U: return fastEmit_WebAssemblyISD_TRUNC_SAT_ZERO_U_r(VT, RetVT, Op0);
1473 default: return Register();
1474 }
1475}
1476
1477// FastEmit functions for ISD::ADD.
1478
1479Register fastEmit_ISD_ADD_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
1480 if (RetVT.SimpleTy != MVT::i32)
1481 return Register();
1482 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
1483}
1484
1485Register fastEmit_ISD_ADD_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
1486 if (RetVT.SimpleTy != MVT::i64)
1487 return Register();
1488 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
1489}
1490
1491Register fastEmit_ISD_ADD_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
1492 if (RetVT.SimpleTy != MVT::v16i8)
1493 return Register();
1494 if ((Subtarget->hasSIMD128())) {
1495 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
1496 }
1497 return Register();
1498}
1499
1500Register fastEmit_ISD_ADD_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
1501 if (RetVT.SimpleTy != MVT::v8i16)
1502 return Register();
1503 if ((Subtarget->hasSIMD128())) {
1504 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
1505 }
1506 return Register();
1507}
1508
1509Register fastEmit_ISD_ADD_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
1510 if (RetVT.SimpleTy != MVT::v4i32)
1511 return Register();
1512 if ((Subtarget->hasSIMD128())) {
1513 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_I32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
1514 }
1515 return Register();
1516}
1517
1518Register fastEmit_ISD_ADD_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
1519 if (RetVT.SimpleTy != MVT::v2i64)
1520 return Register();
1521 if ((Subtarget->hasSIMD128())) {
1522 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_I64x2, RC: &WebAssembly::V128RegClass, Op0, Op1);
1523 }
1524 return Register();
1525}
1526
1527Register fastEmit_ISD_ADD_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
1528 switch (VT.SimpleTy) {
1529 case MVT::i32: return fastEmit_ISD_ADD_MVT_i32_rr(RetVT, Op0, Op1);
1530 case MVT::i64: return fastEmit_ISD_ADD_MVT_i64_rr(RetVT, Op0, Op1);
1531 case MVT::v16i8: return fastEmit_ISD_ADD_MVT_v16i8_rr(RetVT, Op0, Op1);
1532 case MVT::v8i16: return fastEmit_ISD_ADD_MVT_v8i16_rr(RetVT, Op0, Op1);
1533 case MVT::v4i32: return fastEmit_ISD_ADD_MVT_v4i32_rr(RetVT, Op0, Op1);
1534 case MVT::v2i64: return fastEmit_ISD_ADD_MVT_v2i64_rr(RetVT, Op0, Op1);
1535 default: return Register();
1536 }
1537}
1538
1539// FastEmit functions for ISD::AND.
1540
1541Register fastEmit_ISD_AND_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
1542 if (RetVT.SimpleTy != MVT::i32)
1543 return Register();
1544 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::AND_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
1545}
1546
1547Register fastEmit_ISD_AND_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
1548 if (RetVT.SimpleTy != MVT::i64)
1549 return Register();
1550 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::AND_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
1551}
1552
1553Register fastEmit_ISD_AND_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
1554 if (RetVT.SimpleTy != MVT::v16i8)
1555 return Register();
1556 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::AND, RC: &WebAssembly::V128RegClass, Op0, Op1);
1557}
1558
1559Register fastEmit_ISD_AND_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
1560 if (RetVT.SimpleTy != MVT::v8i16)
1561 return Register();
1562 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::AND, RC: &WebAssembly::V128RegClass, Op0, Op1);
1563}
1564
1565Register fastEmit_ISD_AND_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
1566 if (RetVT.SimpleTy != MVT::v4i32)
1567 return Register();
1568 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::AND, RC: &WebAssembly::V128RegClass, Op0, Op1);
1569}
1570
1571Register fastEmit_ISD_AND_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
1572 if (RetVT.SimpleTy != MVT::v2i64)
1573 return Register();
1574 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::AND, RC: &WebAssembly::V128RegClass, Op0, Op1);
1575}
1576
1577Register fastEmit_ISD_AND_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
1578 switch (VT.SimpleTy) {
1579 case MVT::i32: return fastEmit_ISD_AND_MVT_i32_rr(RetVT, Op0, Op1);
1580 case MVT::i64: return fastEmit_ISD_AND_MVT_i64_rr(RetVT, Op0, Op1);
1581 case MVT::v16i8: return fastEmit_ISD_AND_MVT_v16i8_rr(RetVT, Op0, Op1);
1582 case MVT::v8i16: return fastEmit_ISD_AND_MVT_v8i16_rr(RetVT, Op0, Op1);
1583 case MVT::v4i32: return fastEmit_ISD_AND_MVT_v4i32_rr(RetVT, Op0, Op1);
1584 case MVT::v2i64: return fastEmit_ISD_AND_MVT_v2i64_rr(RetVT, Op0, Op1);
1585 default: return Register();
1586 }
1587}
1588
1589// FastEmit functions for ISD::FADD.
1590
1591Register fastEmit_ISD_FADD_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
1592 if (RetVT.SimpleTy != MVT::f32)
1593 return Register();
1594 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_F32, RC: &WebAssembly::F32RegClass, Op0, Op1);
1595}
1596
1597Register fastEmit_ISD_FADD_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
1598 if (RetVT.SimpleTy != MVT::f64)
1599 return Register();
1600 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_F64, RC: &WebAssembly::F64RegClass, Op0, Op1);
1601}
1602
1603Register fastEmit_ISD_FADD_MVT_v8f16_rr(MVT RetVT, Register Op0, Register Op1) {
1604 if (RetVT.SimpleTy != MVT::v8f16)
1605 return Register();
1606 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
1607 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_F16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
1608 }
1609 return Register();
1610}
1611
1612Register fastEmit_ISD_FADD_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
1613 if (RetVT.SimpleTy != MVT::v4f32)
1614 return Register();
1615 if ((Subtarget->hasSIMD128())) {
1616 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_F32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
1617 }
1618 return Register();
1619}
1620
1621Register fastEmit_ISD_FADD_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
1622 if (RetVT.SimpleTy != MVT::v2f64)
1623 return Register();
1624 if ((Subtarget->hasSIMD128())) {
1625 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_F64x2, RC: &WebAssembly::V128RegClass, Op0, Op1);
1626 }
1627 return Register();
1628}
1629
1630Register fastEmit_ISD_FADD_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
1631 switch (VT.SimpleTy) {
1632 case MVT::f32: return fastEmit_ISD_FADD_MVT_f32_rr(RetVT, Op0, Op1);
1633 case MVT::f64: return fastEmit_ISD_FADD_MVT_f64_rr(RetVT, Op0, Op1);
1634 case MVT::v8f16: return fastEmit_ISD_FADD_MVT_v8f16_rr(RetVT, Op0, Op1);
1635 case MVT::v4f32: return fastEmit_ISD_FADD_MVT_v4f32_rr(RetVT, Op0, Op1);
1636 case MVT::v2f64: return fastEmit_ISD_FADD_MVT_v2f64_rr(RetVT, Op0, Op1);
1637 default: return Register();
1638 }
1639}
1640
1641// FastEmit functions for ISD::FCOPYSIGN.
1642
1643Register fastEmit_ISD_FCOPYSIGN_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
1644 if (RetVT.SimpleTy != MVT::f32)
1645 return Register();
1646 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::COPYSIGN_F32, RC: &WebAssembly::F32RegClass, Op0, Op1);
1647}
1648
1649Register fastEmit_ISD_FCOPYSIGN_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
1650 if (RetVT.SimpleTy != MVT::f64)
1651 return Register();
1652 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::COPYSIGN_F64, RC: &WebAssembly::F64RegClass, Op0, Op1);
1653}
1654
1655Register fastEmit_ISD_FCOPYSIGN_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
1656 switch (VT.SimpleTy) {
1657 case MVT::f32: return fastEmit_ISD_FCOPYSIGN_MVT_f32_rr(RetVT, Op0, Op1);
1658 case MVT::f64: return fastEmit_ISD_FCOPYSIGN_MVT_f64_rr(RetVT, Op0, Op1);
1659 default: return Register();
1660 }
1661}
1662
1663// FastEmit functions for ISD::FDIV.
1664
1665Register fastEmit_ISD_FDIV_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
1666 if (RetVT.SimpleTy != MVT::f32)
1667 return Register();
1668 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::DIV_F32, RC: &WebAssembly::F32RegClass, Op0, Op1);
1669}
1670
1671Register fastEmit_ISD_FDIV_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
1672 if (RetVT.SimpleTy != MVT::f64)
1673 return Register();
1674 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::DIV_F64, RC: &WebAssembly::F64RegClass, Op0, Op1);
1675}
1676
1677Register fastEmit_ISD_FDIV_MVT_v8f16_rr(MVT RetVT, Register Op0, Register Op1) {
1678 if (RetVT.SimpleTy != MVT::v8f16)
1679 return Register();
1680 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
1681 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::DIV_F16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
1682 }
1683 return Register();
1684}
1685
1686Register fastEmit_ISD_FDIV_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
1687 if (RetVT.SimpleTy != MVT::v4f32)
1688 return Register();
1689 if ((Subtarget->hasSIMD128())) {
1690 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::DIV_F32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
1691 }
1692 return Register();
1693}
1694
1695Register fastEmit_ISD_FDIV_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
1696 if (RetVT.SimpleTy != MVT::v2f64)
1697 return Register();
1698 if ((Subtarget->hasSIMD128())) {
1699 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::DIV_F64x2, RC: &WebAssembly::V128RegClass, Op0, Op1);
1700 }
1701 return Register();
1702}
1703
1704Register fastEmit_ISD_FDIV_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
1705 switch (VT.SimpleTy) {
1706 case MVT::f32: return fastEmit_ISD_FDIV_MVT_f32_rr(RetVT, Op0, Op1);
1707 case MVT::f64: return fastEmit_ISD_FDIV_MVT_f64_rr(RetVT, Op0, Op1);
1708 case MVT::v8f16: return fastEmit_ISD_FDIV_MVT_v8f16_rr(RetVT, Op0, Op1);
1709 case MVT::v4f32: return fastEmit_ISD_FDIV_MVT_v4f32_rr(RetVT, Op0, Op1);
1710 case MVT::v2f64: return fastEmit_ISD_FDIV_MVT_v2f64_rr(RetVT, Op0, Op1);
1711 default: return Register();
1712 }
1713}
1714
1715// FastEmit functions for ISD::FMAXIMUM.
1716
1717Register fastEmit_ISD_FMAXIMUM_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
1718 if (RetVT.SimpleTy != MVT::f32)
1719 return Register();
1720 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_F32, RC: &WebAssembly::F32RegClass, Op0, Op1);
1721}
1722
1723Register fastEmit_ISD_FMAXIMUM_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
1724 if (RetVT.SimpleTy != MVT::f64)
1725 return Register();
1726 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_F64, RC: &WebAssembly::F64RegClass, Op0, Op1);
1727}
1728
1729Register fastEmit_ISD_FMAXIMUM_MVT_v8f16_rr(MVT RetVT, Register Op0, Register Op1) {
1730 if (RetVT.SimpleTy != MVT::v8f16)
1731 return Register();
1732 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
1733 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_F16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
1734 }
1735 return Register();
1736}
1737
1738Register fastEmit_ISD_FMAXIMUM_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
1739 if (RetVT.SimpleTy != MVT::v4f32)
1740 return Register();
1741 if ((Subtarget->hasSIMD128())) {
1742 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_F32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
1743 }
1744 return Register();
1745}
1746
1747Register fastEmit_ISD_FMAXIMUM_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
1748 if (RetVT.SimpleTy != MVT::v2f64)
1749 return Register();
1750 if ((Subtarget->hasSIMD128())) {
1751 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_F64x2, RC: &WebAssembly::V128RegClass, Op0, Op1);
1752 }
1753 return Register();
1754}
1755
1756Register fastEmit_ISD_FMAXIMUM_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
1757 switch (VT.SimpleTy) {
1758 case MVT::f32: return fastEmit_ISD_FMAXIMUM_MVT_f32_rr(RetVT, Op0, Op1);
1759 case MVT::f64: return fastEmit_ISD_FMAXIMUM_MVT_f64_rr(RetVT, Op0, Op1);
1760 case MVT::v8f16: return fastEmit_ISD_FMAXIMUM_MVT_v8f16_rr(RetVT, Op0, Op1);
1761 case MVT::v4f32: return fastEmit_ISD_FMAXIMUM_MVT_v4f32_rr(RetVT, Op0, Op1);
1762 case MVT::v2f64: return fastEmit_ISD_FMAXIMUM_MVT_v2f64_rr(RetVT, Op0, Op1);
1763 default: return Register();
1764 }
1765}
1766
1767// FastEmit functions for ISD::FMINIMUM.
1768
1769Register fastEmit_ISD_FMINIMUM_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
1770 if (RetVT.SimpleTy != MVT::f32)
1771 return Register();
1772 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_F32, RC: &WebAssembly::F32RegClass, Op0, Op1);
1773}
1774
1775Register fastEmit_ISD_FMINIMUM_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
1776 if (RetVT.SimpleTy != MVT::f64)
1777 return Register();
1778 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_F64, RC: &WebAssembly::F64RegClass, Op0, Op1);
1779}
1780
1781Register fastEmit_ISD_FMINIMUM_MVT_v8f16_rr(MVT RetVT, Register Op0, Register Op1) {
1782 if (RetVT.SimpleTy != MVT::v8f16)
1783 return Register();
1784 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
1785 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_F16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
1786 }
1787 return Register();
1788}
1789
1790Register fastEmit_ISD_FMINIMUM_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
1791 if (RetVT.SimpleTy != MVT::v4f32)
1792 return Register();
1793 if ((Subtarget->hasSIMD128())) {
1794 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_F32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
1795 }
1796 return Register();
1797}
1798
1799Register fastEmit_ISD_FMINIMUM_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
1800 if (RetVT.SimpleTy != MVT::v2f64)
1801 return Register();
1802 if ((Subtarget->hasSIMD128())) {
1803 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_F64x2, RC: &WebAssembly::V128RegClass, Op0, Op1);
1804 }
1805 return Register();
1806}
1807
1808Register fastEmit_ISD_FMINIMUM_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
1809 switch (VT.SimpleTy) {
1810 case MVT::f32: return fastEmit_ISD_FMINIMUM_MVT_f32_rr(RetVT, Op0, Op1);
1811 case MVT::f64: return fastEmit_ISD_FMINIMUM_MVT_f64_rr(RetVT, Op0, Op1);
1812 case MVT::v8f16: return fastEmit_ISD_FMINIMUM_MVT_v8f16_rr(RetVT, Op0, Op1);
1813 case MVT::v4f32: return fastEmit_ISD_FMINIMUM_MVT_v4f32_rr(RetVT, Op0, Op1);
1814 case MVT::v2f64: return fastEmit_ISD_FMINIMUM_MVT_v2f64_rr(RetVT, Op0, Op1);
1815 default: return Register();
1816 }
1817}
1818
1819// FastEmit functions for ISD::FMUL.
1820
1821Register fastEmit_ISD_FMUL_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
1822 if (RetVT.SimpleTy != MVT::f32)
1823 return Register();
1824 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MUL_F32, RC: &WebAssembly::F32RegClass, Op0, Op1);
1825}
1826
1827Register fastEmit_ISD_FMUL_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
1828 if (RetVT.SimpleTy != MVT::f64)
1829 return Register();
1830 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MUL_F64, RC: &WebAssembly::F64RegClass, Op0, Op1);
1831}
1832
1833Register fastEmit_ISD_FMUL_MVT_v8f16_rr(MVT RetVT, Register Op0, Register Op1) {
1834 if (RetVT.SimpleTy != MVT::v8f16)
1835 return Register();
1836 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
1837 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MUL_F16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
1838 }
1839 return Register();
1840}
1841
1842Register fastEmit_ISD_FMUL_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
1843 if (RetVT.SimpleTy != MVT::v4f32)
1844 return Register();
1845 if ((Subtarget->hasSIMD128())) {
1846 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MUL_F32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
1847 }
1848 return Register();
1849}
1850
1851Register fastEmit_ISD_FMUL_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
1852 if (RetVT.SimpleTy != MVT::v2f64)
1853 return Register();
1854 if ((Subtarget->hasSIMD128())) {
1855 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MUL_F64x2, RC: &WebAssembly::V128RegClass, Op0, Op1);
1856 }
1857 return Register();
1858}
1859
1860Register fastEmit_ISD_FMUL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
1861 switch (VT.SimpleTy) {
1862 case MVT::f32: return fastEmit_ISD_FMUL_MVT_f32_rr(RetVT, Op0, Op1);
1863 case MVT::f64: return fastEmit_ISD_FMUL_MVT_f64_rr(RetVT, Op0, Op1);
1864 case MVT::v8f16: return fastEmit_ISD_FMUL_MVT_v8f16_rr(RetVT, Op0, Op1);
1865 case MVT::v4f32: return fastEmit_ISD_FMUL_MVT_v4f32_rr(RetVT, Op0, Op1);
1866 case MVT::v2f64: return fastEmit_ISD_FMUL_MVT_v2f64_rr(RetVT, Op0, Op1);
1867 default: return Register();
1868 }
1869}
1870
1871// FastEmit functions for ISD::FSUB.
1872
1873Register fastEmit_ISD_FSUB_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
1874 if (RetVT.SimpleTy != MVT::f32)
1875 return Register();
1876 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_F32, RC: &WebAssembly::F32RegClass, Op0, Op1);
1877}
1878
1879Register fastEmit_ISD_FSUB_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
1880 if (RetVT.SimpleTy != MVT::f64)
1881 return Register();
1882 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_F64, RC: &WebAssembly::F64RegClass, Op0, Op1);
1883}
1884
1885Register fastEmit_ISD_FSUB_MVT_v8f16_rr(MVT RetVT, Register Op0, Register Op1) {
1886 if (RetVT.SimpleTy != MVT::v8f16)
1887 return Register();
1888 if ((Subtarget->hasFP16()) && (Subtarget->hasSIMD128())) {
1889 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_F16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
1890 }
1891 return Register();
1892}
1893
1894Register fastEmit_ISD_FSUB_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
1895 if (RetVT.SimpleTy != MVT::v4f32)
1896 return Register();
1897 if ((Subtarget->hasSIMD128())) {
1898 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_F32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
1899 }
1900 return Register();
1901}
1902
1903Register fastEmit_ISD_FSUB_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
1904 if (RetVT.SimpleTy != MVT::v2f64)
1905 return Register();
1906 if ((Subtarget->hasSIMD128())) {
1907 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_F64x2, RC: &WebAssembly::V128RegClass, Op0, Op1);
1908 }
1909 return Register();
1910}
1911
1912Register fastEmit_ISD_FSUB_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
1913 switch (VT.SimpleTy) {
1914 case MVT::f32: return fastEmit_ISD_FSUB_MVT_f32_rr(RetVT, Op0, Op1);
1915 case MVT::f64: return fastEmit_ISD_FSUB_MVT_f64_rr(RetVT, Op0, Op1);
1916 case MVT::v8f16: return fastEmit_ISD_FSUB_MVT_v8f16_rr(RetVT, Op0, Op1);
1917 case MVT::v4f32: return fastEmit_ISD_FSUB_MVT_v4f32_rr(RetVT, Op0, Op1);
1918 case MVT::v2f64: return fastEmit_ISD_FSUB_MVT_v2f64_rr(RetVT, Op0, Op1);
1919 default: return Register();
1920 }
1921}
1922
1923// FastEmit functions for ISD::MUL.
1924
1925Register fastEmit_ISD_MUL_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
1926 if (RetVT.SimpleTy != MVT::i32)
1927 return Register();
1928 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MUL_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
1929}
1930
1931Register fastEmit_ISD_MUL_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
1932 if (RetVT.SimpleTy != MVT::i64)
1933 return Register();
1934 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MUL_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
1935}
1936
1937Register fastEmit_ISD_MUL_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
1938 if (RetVT.SimpleTy != MVT::v8i16)
1939 return Register();
1940 if ((Subtarget->hasSIMD128())) {
1941 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MUL_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
1942 }
1943 return Register();
1944}
1945
1946Register fastEmit_ISD_MUL_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
1947 if (RetVT.SimpleTy != MVT::v4i32)
1948 return Register();
1949 if ((Subtarget->hasSIMD128())) {
1950 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MUL_I32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
1951 }
1952 return Register();
1953}
1954
1955Register fastEmit_ISD_MUL_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
1956 if (RetVT.SimpleTy != MVT::v2i64)
1957 return Register();
1958 if ((Subtarget->hasSIMD128())) {
1959 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MUL_I64x2, RC: &WebAssembly::V128RegClass, Op0, Op1);
1960 }
1961 return Register();
1962}
1963
1964Register fastEmit_ISD_MUL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
1965 switch (VT.SimpleTy) {
1966 case MVT::i32: return fastEmit_ISD_MUL_MVT_i32_rr(RetVT, Op0, Op1);
1967 case MVT::i64: return fastEmit_ISD_MUL_MVT_i64_rr(RetVT, Op0, Op1);
1968 case MVT::v8i16: return fastEmit_ISD_MUL_MVT_v8i16_rr(RetVT, Op0, Op1);
1969 case MVT::v4i32: return fastEmit_ISD_MUL_MVT_v4i32_rr(RetVT, Op0, Op1);
1970 case MVT::v2i64: return fastEmit_ISD_MUL_MVT_v2i64_rr(RetVT, Op0, Op1);
1971 default: return Register();
1972 }
1973}
1974
1975// FastEmit functions for ISD::OR.
1976
1977Register fastEmit_ISD_OR_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
1978 if (RetVT.SimpleTy != MVT::i32)
1979 return Register();
1980 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::OR_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
1981}
1982
1983Register fastEmit_ISD_OR_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
1984 if (RetVT.SimpleTy != MVT::i64)
1985 return Register();
1986 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::OR_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
1987}
1988
1989Register fastEmit_ISD_OR_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
1990 if (RetVT.SimpleTy != MVT::v16i8)
1991 return Register();
1992 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::OR, RC: &WebAssembly::V128RegClass, Op0, Op1);
1993}
1994
1995Register fastEmit_ISD_OR_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
1996 if (RetVT.SimpleTy != MVT::v8i16)
1997 return Register();
1998 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::OR, RC: &WebAssembly::V128RegClass, Op0, Op1);
1999}
2000
2001Register fastEmit_ISD_OR_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2002 if (RetVT.SimpleTy != MVT::v4i32)
2003 return Register();
2004 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::OR, RC: &WebAssembly::V128RegClass, Op0, Op1);
2005}
2006
2007Register fastEmit_ISD_OR_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
2008 if (RetVT.SimpleTy != MVT::v2i64)
2009 return Register();
2010 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::OR, RC: &WebAssembly::V128RegClass, Op0, Op1);
2011}
2012
2013Register fastEmit_ISD_OR_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2014 switch (VT.SimpleTy) {
2015 case MVT::i32: return fastEmit_ISD_OR_MVT_i32_rr(RetVT, Op0, Op1);
2016 case MVT::i64: return fastEmit_ISD_OR_MVT_i64_rr(RetVT, Op0, Op1);
2017 case MVT::v16i8: return fastEmit_ISD_OR_MVT_v16i8_rr(RetVT, Op0, Op1);
2018 case MVT::v8i16: return fastEmit_ISD_OR_MVT_v8i16_rr(RetVT, Op0, Op1);
2019 case MVT::v4i32: return fastEmit_ISD_OR_MVT_v4i32_rr(RetVT, Op0, Op1);
2020 case MVT::v2i64: return fastEmit_ISD_OR_MVT_v2i64_rr(RetVT, Op0, Op1);
2021 default: return Register();
2022 }
2023}
2024
2025// FastEmit functions for ISD::ROTL.
2026
2027Register fastEmit_ISD_ROTL_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2028 if (RetVT.SimpleTy != MVT::i32)
2029 return Register();
2030 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ROTL_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2031}
2032
2033Register fastEmit_ISD_ROTL_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2034 if (RetVT.SimpleTy != MVT::i64)
2035 return Register();
2036 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ROTL_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2037}
2038
2039Register fastEmit_ISD_ROTL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2040 switch (VT.SimpleTy) {
2041 case MVT::i32: return fastEmit_ISD_ROTL_MVT_i32_rr(RetVT, Op0, Op1);
2042 case MVT::i64: return fastEmit_ISD_ROTL_MVT_i64_rr(RetVT, Op0, Op1);
2043 default: return Register();
2044 }
2045}
2046
2047// FastEmit functions for ISD::ROTR.
2048
2049Register fastEmit_ISD_ROTR_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2050 if (RetVT.SimpleTy != MVT::i32)
2051 return Register();
2052 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ROTR_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2053}
2054
2055Register fastEmit_ISD_ROTR_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2056 if (RetVT.SimpleTy != MVT::i64)
2057 return Register();
2058 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ROTR_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2059}
2060
2061Register fastEmit_ISD_ROTR_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2062 switch (VT.SimpleTy) {
2063 case MVT::i32: return fastEmit_ISD_ROTR_MVT_i32_rr(RetVT, Op0, Op1);
2064 case MVT::i64: return fastEmit_ISD_ROTR_MVT_i64_rr(RetVT, Op0, Op1);
2065 default: return Register();
2066 }
2067}
2068
2069// FastEmit functions for ISD::SADDSAT.
2070
2071Register fastEmit_ISD_SADDSAT_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2072 if (RetVT.SimpleTy != MVT::v16i8)
2073 return Register();
2074 if ((Subtarget->hasSIMD128())) {
2075 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_SAT_S_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
2076 }
2077 return Register();
2078}
2079
2080Register fastEmit_ISD_SADDSAT_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2081 if (RetVT.SimpleTy != MVT::v8i16)
2082 return Register();
2083 if ((Subtarget->hasSIMD128())) {
2084 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_SAT_S_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
2085 }
2086 return Register();
2087}
2088
2089Register fastEmit_ISD_SADDSAT_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2090 switch (VT.SimpleTy) {
2091 case MVT::v16i8: return fastEmit_ISD_SADDSAT_MVT_v16i8_rr(RetVT, Op0, Op1);
2092 case MVT::v8i16: return fastEmit_ISD_SADDSAT_MVT_v8i16_rr(RetVT, Op0, Op1);
2093 default: return Register();
2094 }
2095}
2096
2097// FastEmit functions for ISD::SDIV.
2098
2099Register fastEmit_ISD_SDIV_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2100 if (RetVT.SimpleTy != MVT::i32)
2101 return Register();
2102 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::DIV_S_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2103}
2104
2105Register fastEmit_ISD_SDIV_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2106 if (RetVT.SimpleTy != MVT::i64)
2107 return Register();
2108 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::DIV_S_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2109}
2110
2111Register fastEmit_ISD_SDIV_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2112 switch (VT.SimpleTy) {
2113 case MVT::i32: return fastEmit_ISD_SDIV_MVT_i32_rr(RetVT, Op0, Op1);
2114 case MVT::i64: return fastEmit_ISD_SDIV_MVT_i64_rr(RetVT, Op0, Op1);
2115 default: return Register();
2116 }
2117}
2118
2119// FastEmit functions for ISD::SHL.
2120
2121Register fastEmit_ISD_SHL_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2122 if (RetVT.SimpleTy != MVT::i32)
2123 return Register();
2124 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SHL_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2125}
2126
2127Register fastEmit_ISD_SHL_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2128 if (RetVT.SimpleTy != MVT::i64)
2129 return Register();
2130 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SHL_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2131}
2132
2133Register fastEmit_ISD_SHL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2134 switch (VT.SimpleTy) {
2135 case MVT::i32: return fastEmit_ISD_SHL_MVT_i32_rr(RetVT, Op0, Op1);
2136 case MVT::i64: return fastEmit_ISD_SHL_MVT_i64_rr(RetVT, Op0, Op1);
2137 default: return Register();
2138 }
2139}
2140
2141// FastEmit functions for ISD::SMAX.
2142
2143Register fastEmit_ISD_SMAX_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2144 if (RetVT.SimpleTy != MVT::v16i8)
2145 return Register();
2146 if ((Subtarget->hasSIMD128())) {
2147 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_S_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
2148 }
2149 return Register();
2150}
2151
2152Register fastEmit_ISD_SMAX_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2153 if (RetVT.SimpleTy != MVT::v8i16)
2154 return Register();
2155 if ((Subtarget->hasSIMD128())) {
2156 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_S_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
2157 }
2158 return Register();
2159}
2160
2161Register fastEmit_ISD_SMAX_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2162 if (RetVT.SimpleTy != MVT::v4i32)
2163 return Register();
2164 if ((Subtarget->hasSIMD128())) {
2165 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_S_I32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
2166 }
2167 return Register();
2168}
2169
2170Register fastEmit_ISD_SMAX_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2171 switch (VT.SimpleTy) {
2172 case MVT::v16i8: return fastEmit_ISD_SMAX_MVT_v16i8_rr(RetVT, Op0, Op1);
2173 case MVT::v8i16: return fastEmit_ISD_SMAX_MVT_v8i16_rr(RetVT, Op0, Op1);
2174 case MVT::v4i32: return fastEmit_ISD_SMAX_MVT_v4i32_rr(RetVT, Op0, Op1);
2175 default: return Register();
2176 }
2177}
2178
2179// FastEmit functions for ISD::SMIN.
2180
2181Register fastEmit_ISD_SMIN_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2182 if (RetVT.SimpleTy != MVT::v16i8)
2183 return Register();
2184 if ((Subtarget->hasSIMD128())) {
2185 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_S_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
2186 }
2187 return Register();
2188}
2189
2190Register fastEmit_ISD_SMIN_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2191 if (RetVT.SimpleTy != MVT::v8i16)
2192 return Register();
2193 if ((Subtarget->hasSIMD128())) {
2194 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_S_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
2195 }
2196 return Register();
2197}
2198
2199Register fastEmit_ISD_SMIN_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2200 if (RetVT.SimpleTy != MVT::v4i32)
2201 return Register();
2202 if ((Subtarget->hasSIMD128())) {
2203 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_S_I32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
2204 }
2205 return Register();
2206}
2207
2208Register fastEmit_ISD_SMIN_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2209 switch (VT.SimpleTy) {
2210 case MVT::v16i8: return fastEmit_ISD_SMIN_MVT_v16i8_rr(RetVT, Op0, Op1);
2211 case MVT::v8i16: return fastEmit_ISD_SMIN_MVT_v8i16_rr(RetVT, Op0, Op1);
2212 case MVT::v4i32: return fastEmit_ISD_SMIN_MVT_v4i32_rr(RetVT, Op0, Op1);
2213 default: return Register();
2214 }
2215}
2216
2217// FastEmit functions for ISD::SRA.
2218
2219Register fastEmit_ISD_SRA_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2220 if (RetVT.SimpleTy != MVT::i32)
2221 return Register();
2222 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SHR_S_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2223}
2224
2225Register fastEmit_ISD_SRA_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2226 if (RetVT.SimpleTy != MVT::i64)
2227 return Register();
2228 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SHR_S_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2229}
2230
2231Register fastEmit_ISD_SRA_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2232 switch (VT.SimpleTy) {
2233 case MVT::i32: return fastEmit_ISD_SRA_MVT_i32_rr(RetVT, Op0, Op1);
2234 case MVT::i64: return fastEmit_ISD_SRA_MVT_i64_rr(RetVT, Op0, Op1);
2235 default: return Register();
2236 }
2237}
2238
2239// FastEmit functions for ISD::SREM.
2240
2241Register fastEmit_ISD_SREM_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2242 if (RetVT.SimpleTy != MVT::i32)
2243 return Register();
2244 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::REM_S_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2245}
2246
2247Register fastEmit_ISD_SREM_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2248 if (RetVT.SimpleTy != MVT::i64)
2249 return Register();
2250 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::REM_S_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2251}
2252
2253Register fastEmit_ISD_SREM_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2254 switch (VT.SimpleTy) {
2255 case MVT::i32: return fastEmit_ISD_SREM_MVT_i32_rr(RetVT, Op0, Op1);
2256 case MVT::i64: return fastEmit_ISD_SREM_MVT_i64_rr(RetVT, Op0, Op1);
2257 default: return Register();
2258 }
2259}
2260
2261// FastEmit functions for ISD::SRL.
2262
2263Register fastEmit_ISD_SRL_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2264 if (RetVT.SimpleTy != MVT::i32)
2265 return Register();
2266 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SHR_U_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2267}
2268
2269Register fastEmit_ISD_SRL_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2270 if (RetVT.SimpleTy != MVT::i64)
2271 return Register();
2272 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SHR_U_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2273}
2274
2275Register fastEmit_ISD_SRL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2276 switch (VT.SimpleTy) {
2277 case MVT::i32: return fastEmit_ISD_SRL_MVT_i32_rr(RetVT, Op0, Op1);
2278 case MVT::i64: return fastEmit_ISD_SRL_MVT_i64_rr(RetVT, Op0, Op1);
2279 default: return Register();
2280 }
2281}
2282
2283// FastEmit functions for ISD::SSUBSAT.
2284
2285Register fastEmit_ISD_SSUBSAT_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2286 if (RetVT.SimpleTy != MVT::v16i8)
2287 return Register();
2288 if ((Subtarget->hasSIMD128())) {
2289 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_SAT_S_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
2290 }
2291 return Register();
2292}
2293
2294Register fastEmit_ISD_SSUBSAT_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2295 if (RetVT.SimpleTy != MVT::v8i16)
2296 return Register();
2297 if ((Subtarget->hasSIMD128())) {
2298 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_SAT_S_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
2299 }
2300 return Register();
2301}
2302
2303Register fastEmit_ISD_SSUBSAT_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2304 switch (VT.SimpleTy) {
2305 case MVT::v16i8: return fastEmit_ISD_SSUBSAT_MVT_v16i8_rr(RetVT, Op0, Op1);
2306 case MVT::v8i16: return fastEmit_ISD_SSUBSAT_MVT_v8i16_rr(RetVT, Op0, Op1);
2307 default: return Register();
2308 }
2309}
2310
2311// FastEmit functions for ISD::SUB.
2312
2313Register fastEmit_ISD_SUB_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2314 if (RetVT.SimpleTy != MVT::i32)
2315 return Register();
2316 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2317}
2318
2319Register fastEmit_ISD_SUB_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2320 if (RetVT.SimpleTy != MVT::i64)
2321 return Register();
2322 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2323}
2324
2325Register fastEmit_ISD_SUB_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2326 if (RetVT.SimpleTy != MVT::v16i8)
2327 return Register();
2328 if ((Subtarget->hasSIMD128())) {
2329 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
2330 }
2331 return Register();
2332}
2333
2334Register fastEmit_ISD_SUB_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2335 if (RetVT.SimpleTy != MVT::v8i16)
2336 return Register();
2337 if ((Subtarget->hasSIMD128())) {
2338 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
2339 }
2340 return Register();
2341}
2342
2343Register fastEmit_ISD_SUB_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2344 if (RetVT.SimpleTy != MVT::v4i32)
2345 return Register();
2346 if ((Subtarget->hasSIMD128())) {
2347 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_I32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
2348 }
2349 return Register();
2350}
2351
2352Register fastEmit_ISD_SUB_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
2353 if (RetVT.SimpleTy != MVT::v2i64)
2354 return Register();
2355 if ((Subtarget->hasSIMD128())) {
2356 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_I64x2, RC: &WebAssembly::V128RegClass, Op0, Op1);
2357 }
2358 return Register();
2359}
2360
2361Register fastEmit_ISD_SUB_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2362 switch (VT.SimpleTy) {
2363 case MVT::i32: return fastEmit_ISD_SUB_MVT_i32_rr(RetVT, Op0, Op1);
2364 case MVT::i64: return fastEmit_ISD_SUB_MVT_i64_rr(RetVT, Op0, Op1);
2365 case MVT::v16i8: return fastEmit_ISD_SUB_MVT_v16i8_rr(RetVT, Op0, Op1);
2366 case MVT::v8i16: return fastEmit_ISD_SUB_MVT_v8i16_rr(RetVT, Op0, Op1);
2367 case MVT::v4i32: return fastEmit_ISD_SUB_MVT_v4i32_rr(RetVT, Op0, Op1);
2368 case MVT::v2i64: return fastEmit_ISD_SUB_MVT_v2i64_rr(RetVT, Op0, Op1);
2369 default: return Register();
2370 }
2371}
2372
2373// FastEmit functions for ISD::UADDSAT.
2374
2375Register fastEmit_ISD_UADDSAT_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2376 if (RetVT.SimpleTy != MVT::v16i8)
2377 return Register();
2378 if ((Subtarget->hasSIMD128())) {
2379 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_SAT_U_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
2380 }
2381 return Register();
2382}
2383
2384Register fastEmit_ISD_UADDSAT_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2385 if (RetVT.SimpleTy != MVT::v8i16)
2386 return Register();
2387 if ((Subtarget->hasSIMD128())) {
2388 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::ADD_SAT_U_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
2389 }
2390 return Register();
2391}
2392
2393Register fastEmit_ISD_UADDSAT_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2394 switch (VT.SimpleTy) {
2395 case MVT::v16i8: return fastEmit_ISD_UADDSAT_MVT_v16i8_rr(RetVT, Op0, Op1);
2396 case MVT::v8i16: return fastEmit_ISD_UADDSAT_MVT_v8i16_rr(RetVT, Op0, Op1);
2397 default: return Register();
2398 }
2399}
2400
2401// FastEmit functions for ISD::UDIV.
2402
2403Register fastEmit_ISD_UDIV_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2404 if (RetVT.SimpleTy != MVT::i32)
2405 return Register();
2406 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::DIV_U_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2407}
2408
2409Register fastEmit_ISD_UDIV_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2410 if (RetVT.SimpleTy != MVT::i64)
2411 return Register();
2412 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::DIV_U_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2413}
2414
2415Register fastEmit_ISD_UDIV_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2416 switch (VT.SimpleTy) {
2417 case MVT::i32: return fastEmit_ISD_UDIV_MVT_i32_rr(RetVT, Op0, Op1);
2418 case MVT::i64: return fastEmit_ISD_UDIV_MVT_i64_rr(RetVT, Op0, Op1);
2419 default: return Register();
2420 }
2421}
2422
2423// FastEmit functions for ISD::UMAX.
2424
2425Register fastEmit_ISD_UMAX_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2426 if (RetVT.SimpleTy != MVT::v16i8)
2427 return Register();
2428 if ((Subtarget->hasSIMD128())) {
2429 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_U_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
2430 }
2431 return Register();
2432}
2433
2434Register fastEmit_ISD_UMAX_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2435 if (RetVT.SimpleTy != MVT::v8i16)
2436 return Register();
2437 if ((Subtarget->hasSIMD128())) {
2438 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_U_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
2439 }
2440 return Register();
2441}
2442
2443Register fastEmit_ISD_UMAX_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2444 if (RetVT.SimpleTy != MVT::v4i32)
2445 return Register();
2446 if ((Subtarget->hasSIMD128())) {
2447 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MAX_U_I32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
2448 }
2449 return Register();
2450}
2451
2452Register fastEmit_ISD_UMAX_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2453 switch (VT.SimpleTy) {
2454 case MVT::v16i8: return fastEmit_ISD_UMAX_MVT_v16i8_rr(RetVT, Op0, Op1);
2455 case MVT::v8i16: return fastEmit_ISD_UMAX_MVT_v8i16_rr(RetVT, Op0, Op1);
2456 case MVT::v4i32: return fastEmit_ISD_UMAX_MVT_v4i32_rr(RetVT, Op0, Op1);
2457 default: return Register();
2458 }
2459}
2460
2461// FastEmit functions for ISD::UMIN.
2462
2463Register fastEmit_ISD_UMIN_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2464 if (RetVT.SimpleTy != MVT::v16i8)
2465 return Register();
2466 if ((Subtarget->hasSIMD128())) {
2467 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_U_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
2468 }
2469 return Register();
2470}
2471
2472Register fastEmit_ISD_UMIN_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2473 if (RetVT.SimpleTy != MVT::v8i16)
2474 return Register();
2475 if ((Subtarget->hasSIMD128())) {
2476 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_U_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
2477 }
2478 return Register();
2479}
2480
2481Register fastEmit_ISD_UMIN_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2482 if (RetVT.SimpleTy != MVT::v4i32)
2483 return Register();
2484 if ((Subtarget->hasSIMD128())) {
2485 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::MIN_U_I32x4, RC: &WebAssembly::V128RegClass, Op0, Op1);
2486 }
2487 return Register();
2488}
2489
2490Register fastEmit_ISD_UMIN_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2491 switch (VT.SimpleTy) {
2492 case MVT::v16i8: return fastEmit_ISD_UMIN_MVT_v16i8_rr(RetVT, Op0, Op1);
2493 case MVT::v8i16: return fastEmit_ISD_UMIN_MVT_v8i16_rr(RetVT, Op0, Op1);
2494 case MVT::v4i32: return fastEmit_ISD_UMIN_MVT_v4i32_rr(RetVT, Op0, Op1);
2495 default: return Register();
2496 }
2497}
2498
2499// FastEmit functions for ISD::UREM.
2500
2501Register fastEmit_ISD_UREM_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2502 if (RetVT.SimpleTy != MVT::i32)
2503 return Register();
2504 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::REM_U_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2505}
2506
2507Register fastEmit_ISD_UREM_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2508 if (RetVT.SimpleTy != MVT::i64)
2509 return Register();
2510 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::REM_U_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2511}
2512
2513Register fastEmit_ISD_UREM_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2514 switch (VT.SimpleTy) {
2515 case MVT::i32: return fastEmit_ISD_UREM_MVT_i32_rr(RetVT, Op0, Op1);
2516 case MVT::i64: return fastEmit_ISD_UREM_MVT_i64_rr(RetVT, Op0, Op1);
2517 default: return Register();
2518 }
2519}
2520
2521// FastEmit functions for ISD::USUBSAT.
2522
2523Register fastEmit_ISD_USUBSAT_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2524 if (RetVT.SimpleTy != MVT::v16i8)
2525 return Register();
2526 if ((Subtarget->hasSIMD128())) {
2527 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_SAT_U_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
2528 }
2529 return Register();
2530}
2531
2532Register fastEmit_ISD_USUBSAT_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2533 if (RetVT.SimpleTy != MVT::v8i16)
2534 return Register();
2535 if ((Subtarget->hasSIMD128())) {
2536 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SUB_SAT_U_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
2537 }
2538 return Register();
2539}
2540
2541Register fastEmit_ISD_USUBSAT_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2542 switch (VT.SimpleTy) {
2543 case MVT::v16i8: return fastEmit_ISD_USUBSAT_MVT_v16i8_rr(RetVT, Op0, Op1);
2544 case MVT::v8i16: return fastEmit_ISD_USUBSAT_MVT_v8i16_rr(RetVT, Op0, Op1);
2545 default: return Register();
2546 }
2547}
2548
2549// FastEmit functions for ISD::XOR.
2550
2551Register fastEmit_ISD_XOR_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2552 if (RetVT.SimpleTy != MVT::i32)
2553 return Register();
2554 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::XOR_I32, RC: &WebAssembly::I32RegClass, Op0, Op1);
2555}
2556
2557Register fastEmit_ISD_XOR_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2558 if (RetVT.SimpleTy != MVT::i64)
2559 return Register();
2560 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::XOR_I64, RC: &WebAssembly::I64RegClass, Op0, Op1);
2561}
2562
2563Register fastEmit_ISD_XOR_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2564 if (RetVT.SimpleTy != MVT::v16i8)
2565 return Register();
2566 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::XOR, RC: &WebAssembly::V128RegClass, Op0, Op1);
2567}
2568
2569Register fastEmit_ISD_XOR_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2570 if (RetVT.SimpleTy != MVT::v8i16)
2571 return Register();
2572 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::XOR, RC: &WebAssembly::V128RegClass, Op0, Op1);
2573}
2574
2575Register fastEmit_ISD_XOR_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2576 if (RetVT.SimpleTy != MVT::v4i32)
2577 return Register();
2578 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::XOR, RC: &WebAssembly::V128RegClass, Op0, Op1);
2579}
2580
2581Register fastEmit_ISD_XOR_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
2582 if (RetVT.SimpleTy != MVT::v2i64)
2583 return Register();
2584 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::XOR, RC: &WebAssembly::V128RegClass, Op0, Op1);
2585}
2586
2587Register fastEmit_ISD_XOR_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2588 switch (VT.SimpleTy) {
2589 case MVT::i32: return fastEmit_ISD_XOR_MVT_i32_rr(RetVT, Op0, Op1);
2590 case MVT::i64: return fastEmit_ISD_XOR_MVT_i64_rr(RetVT, Op0, Op1);
2591 case MVT::v16i8: return fastEmit_ISD_XOR_MVT_v16i8_rr(RetVT, Op0, Op1);
2592 case MVT::v8i16: return fastEmit_ISD_XOR_MVT_v8i16_rr(RetVT, Op0, Op1);
2593 case MVT::v4i32: return fastEmit_ISD_XOR_MVT_v4i32_rr(RetVT, Op0, Op1);
2594 case MVT::v2i64: return fastEmit_ISD_XOR_MVT_v2i64_rr(RetVT, Op0, Op1);
2595 default: return Register();
2596 }
2597}
2598
2599// FastEmit functions for WebAssemblyISD::DOT.
2600
2601Register fastEmit_WebAssemblyISD_DOT_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2602 if (RetVT.SimpleTy != MVT::v4i32)
2603 return Register();
2604 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::DOT, RC: &WebAssembly::V128RegClass, Op0, Op1);
2605}
2606
2607Register fastEmit_WebAssemblyISD_DOT_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2608 switch (VT.SimpleTy) {
2609 case MVT::v8i16: return fastEmit_WebAssemblyISD_DOT_MVT_v8i16_rr(RetVT, Op0, Op1);
2610 default: return Register();
2611 }
2612}
2613
2614// FastEmit functions for WebAssemblyISD::NARROW_U.
2615
2616Register fastEmit_WebAssemblyISD_NARROW_U_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2617 if (RetVT.SimpleTy != MVT::v16i8)
2618 return Register();
2619 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::NARROW_U_I8x16, RC: &WebAssembly::V128RegClass, Op0, Op1);
2620}
2621
2622Register fastEmit_WebAssemblyISD_NARROW_U_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2623 if (RetVT.SimpleTy != MVT::v8i16)
2624 return Register();
2625 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::NARROW_U_I16x8, RC: &WebAssembly::V128RegClass, Op0, Op1);
2626}
2627
2628Register fastEmit_WebAssemblyISD_NARROW_U_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2629 switch (VT.SimpleTy) {
2630 case MVT::v8i16: return fastEmit_WebAssemblyISD_NARROW_U_MVT_v8i16_rr(RetVT, Op0, Op1);
2631 case MVT::v4i32: return fastEmit_WebAssemblyISD_NARROW_U_MVT_v4i32_rr(RetVT, Op0, Op1);
2632 default: return Register();
2633 }
2634}
2635
2636// FastEmit functions for WebAssemblyISD::SWIZZLE.
2637
2638Register fastEmit_WebAssemblyISD_SWIZZLE_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2639 if (RetVT.SimpleTy != MVT::v16i8)
2640 return Register();
2641 if ((Subtarget->hasSIMD128())) {
2642 return fastEmitInst_rr(MachineInstOpcode: WebAssembly::SWIZZLE, RC: &WebAssembly::V128RegClass, Op0, Op1);
2643 }
2644 return Register();
2645}
2646
2647Register fastEmit_WebAssemblyISD_SWIZZLE_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2648 switch (VT.SimpleTy) {
2649 case MVT::v16i8: return fastEmit_WebAssemblyISD_SWIZZLE_MVT_v16i8_rr(RetVT, Op0, Op1);
2650 default: return Register();
2651 }
2652}
2653
2654// Top-level FastEmit function.
2655
2656Register fastEmit_rr(MVT VT, MVT RetVT, unsigned Opcode, Register Op0, Register Op1) override {
2657 switch (Opcode) {
2658 case ISD::ADD: return fastEmit_ISD_ADD_rr(VT, RetVT, Op0, Op1);
2659 case ISD::AND: return fastEmit_ISD_AND_rr(VT, RetVT, Op0, Op1);
2660 case ISD::FADD: return fastEmit_ISD_FADD_rr(VT, RetVT, Op0, Op1);
2661 case ISD::FCOPYSIGN: return fastEmit_ISD_FCOPYSIGN_rr(VT, RetVT, Op0, Op1);
2662 case ISD::FDIV: return fastEmit_ISD_FDIV_rr(VT, RetVT, Op0, Op1);
2663 case ISD::FMAXIMUM: return fastEmit_ISD_FMAXIMUM_rr(VT, RetVT, Op0, Op1);
2664 case ISD::FMINIMUM: return fastEmit_ISD_FMINIMUM_rr(VT, RetVT, Op0, Op1);
2665 case ISD::FMUL: return fastEmit_ISD_FMUL_rr(VT, RetVT, Op0, Op1);
2666 case ISD::FSUB: return fastEmit_ISD_FSUB_rr(VT, RetVT, Op0, Op1);
2667 case ISD::MUL: return fastEmit_ISD_MUL_rr(VT, RetVT, Op0, Op1);
2668 case ISD::OR: return fastEmit_ISD_OR_rr(VT, RetVT, Op0, Op1);
2669 case ISD::ROTL: return fastEmit_ISD_ROTL_rr(VT, RetVT, Op0, Op1);
2670 case ISD::ROTR: return fastEmit_ISD_ROTR_rr(VT, RetVT, Op0, Op1);
2671 case ISD::SADDSAT: return fastEmit_ISD_SADDSAT_rr(VT, RetVT, Op0, Op1);
2672 case ISD::SDIV: return fastEmit_ISD_SDIV_rr(VT, RetVT, Op0, Op1);
2673 case ISD::SHL: return fastEmit_ISD_SHL_rr(VT, RetVT, Op0, Op1);
2674 case ISD::SMAX: return fastEmit_ISD_SMAX_rr(VT, RetVT, Op0, Op1);
2675 case ISD::SMIN: return fastEmit_ISD_SMIN_rr(VT, RetVT, Op0, Op1);
2676 case ISD::SRA: return fastEmit_ISD_SRA_rr(VT, RetVT, Op0, Op1);
2677 case ISD::SREM: return fastEmit_ISD_SREM_rr(VT, RetVT, Op0, Op1);
2678 case ISD::SRL: return fastEmit_ISD_SRL_rr(VT, RetVT, Op0, Op1);
2679 case ISD::SSUBSAT: return fastEmit_ISD_SSUBSAT_rr(VT, RetVT, Op0, Op1);
2680 case ISD::SUB: return fastEmit_ISD_SUB_rr(VT, RetVT, Op0, Op1);
2681 case ISD::UADDSAT: return fastEmit_ISD_UADDSAT_rr(VT, RetVT, Op0, Op1);
2682 case ISD::UDIV: return fastEmit_ISD_UDIV_rr(VT, RetVT, Op0, Op1);
2683 case ISD::UMAX: return fastEmit_ISD_UMAX_rr(VT, RetVT, Op0, Op1);
2684 case ISD::UMIN: return fastEmit_ISD_UMIN_rr(VT, RetVT, Op0, Op1);
2685 case ISD::UREM: return fastEmit_ISD_UREM_rr(VT, RetVT, Op0, Op1);
2686 case ISD::USUBSAT: return fastEmit_ISD_USUBSAT_rr(VT, RetVT, Op0, Op1);
2687 case ISD::XOR: return fastEmit_ISD_XOR_rr(VT, RetVT, Op0, Op1);
2688 case WebAssemblyISD::DOT: return fastEmit_WebAssemblyISD_DOT_rr(VT, RetVT, Op0, Op1);
2689 case WebAssemblyISD::NARROW_U: return fastEmit_WebAssemblyISD_NARROW_U_rr(VT, RetVT, Op0, Op1);
2690 case WebAssemblyISD::SWIZZLE: return fastEmit_WebAssemblyISD_SWIZZLE_rr(VT, RetVT, Op0, Op1);
2691 default: return Register();
2692 }
2693}
2694
2695// FastEmit functions for ISD::EXTRACT_VECTOR_ELT.
2696
2697Register fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v16i8_ri_Predicate_LaneIdx16(MVT RetVT, Register Op0, uint64_t imm1) {
2698 if (RetVT.SimpleTy != MVT::i32)
2699 return Register();
2700 return fastEmitInst_ri(MachineInstOpcode: WebAssembly::EXTRACT_LANE_I8x16_u, RC: &WebAssembly::I32RegClass, Op0, Imm: imm1);
2701}
2702
2703Register fastEmit_ISD_EXTRACT_VECTOR_ELT_ri_Predicate_LaneIdx16(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
2704 switch (VT.SimpleTy) {
2705 case MVT::v16i8: return fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v16i8_ri_Predicate_LaneIdx16(RetVT, Op0, imm1);
2706 default: return Register();
2707 }
2708}
2709
2710// Top-level FastEmit function.
2711
2712Register fastEmit_ri_Predicate_LaneIdx16(MVT VT, MVT RetVT, unsigned Opcode, Register Op0, uint64_t imm1) {
2713 switch (Opcode) {
2714 case ISD::EXTRACT_VECTOR_ELT: return fastEmit_ISD_EXTRACT_VECTOR_ELT_ri_Predicate_LaneIdx16(VT, RetVT, Op0, imm1);
2715 default: return Register();
2716 }
2717}
2718
2719// FastEmit functions for ISD::EXTRACT_VECTOR_ELT.
2720
2721Register fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v8i16_ri_Predicate_LaneIdx8(MVT RetVT, Register Op0, uint64_t imm1) {
2722 if (RetVT.SimpleTy != MVT::i32)
2723 return Register();
2724 return fastEmitInst_ri(MachineInstOpcode: WebAssembly::EXTRACT_LANE_I16x8_u, RC: &WebAssembly::I32RegClass, Op0, Imm: imm1);
2725}
2726
2727Register fastEmit_ISD_EXTRACT_VECTOR_ELT_ri_Predicate_LaneIdx8(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
2728 switch (VT.SimpleTy) {
2729 case MVT::v8i16: return fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v8i16_ri_Predicate_LaneIdx8(RetVT, Op0, imm1);
2730 default: return Register();
2731 }
2732}
2733
2734// Top-level FastEmit function.
2735
2736Register fastEmit_ri_Predicate_LaneIdx8(MVT VT, MVT RetVT, unsigned Opcode, Register Op0, uint64_t imm1) {
2737 switch (Opcode) {
2738 case ISD::EXTRACT_VECTOR_ELT: return fastEmit_ISD_EXTRACT_VECTOR_ELT_ri_Predicate_LaneIdx8(VT, RetVT, Op0, imm1);
2739 default: return Register();
2740 }
2741}
2742
2743// FastEmit functions for ISD::EXTRACT_VECTOR_ELT.
2744
2745Register fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v4i32_ri_Predicate_LaneIdx4(MVT RetVT, Register Op0, uint64_t imm1) {
2746 if (RetVT.SimpleTy != MVT::i32)
2747 return Register();
2748 return fastEmitInst_ri(MachineInstOpcode: WebAssembly::EXTRACT_LANE_I32x4, RC: &WebAssembly::I32RegClass, Op0, Imm: imm1);
2749}
2750
2751Register fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v4f32_ri_Predicate_LaneIdx4(MVT RetVT, Register Op0, uint64_t imm1) {
2752 if (RetVT.SimpleTy != MVT::f32)
2753 return Register();
2754 return fastEmitInst_ri(MachineInstOpcode: WebAssembly::EXTRACT_LANE_F32x4, RC: &WebAssembly::F32RegClass, Op0, Imm: imm1);
2755}
2756
2757Register fastEmit_ISD_EXTRACT_VECTOR_ELT_ri_Predicate_LaneIdx4(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
2758 switch (VT.SimpleTy) {
2759 case MVT::v4i32: return fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v4i32_ri_Predicate_LaneIdx4(RetVT, Op0, imm1);
2760 case MVT::v4f32: return fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v4f32_ri_Predicate_LaneIdx4(RetVT, Op0, imm1);
2761 default: return Register();
2762 }
2763}
2764
2765// Top-level FastEmit function.
2766
2767Register fastEmit_ri_Predicate_LaneIdx4(MVT VT, MVT RetVT, unsigned Opcode, Register Op0, uint64_t imm1) {
2768 switch (Opcode) {
2769 case ISD::EXTRACT_VECTOR_ELT: return fastEmit_ISD_EXTRACT_VECTOR_ELT_ri_Predicate_LaneIdx4(VT, RetVT, Op0, imm1);
2770 default: return Register();
2771 }
2772}
2773
2774// FastEmit functions for ISD::EXTRACT_VECTOR_ELT.
2775
2776Register fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v2i64_ri_Predicate_LaneIdx2(MVT RetVT, Register Op0, uint64_t imm1) {
2777 if (RetVT.SimpleTy != MVT::i64)
2778 return Register();
2779 return fastEmitInst_ri(MachineInstOpcode: WebAssembly::EXTRACT_LANE_I64x2, RC: &WebAssembly::I64RegClass, Op0, Imm: imm1);
2780}
2781
2782Register fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v2f64_ri_Predicate_LaneIdx2(MVT RetVT, Register Op0, uint64_t imm1) {
2783 if (RetVT.SimpleTy != MVT::f64)
2784 return Register();
2785 return fastEmitInst_ri(MachineInstOpcode: WebAssembly::EXTRACT_LANE_F64x2, RC: &WebAssembly::F64RegClass, Op0, Imm: imm1);
2786}
2787
2788Register fastEmit_ISD_EXTRACT_VECTOR_ELT_ri_Predicate_LaneIdx2(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
2789 switch (VT.SimpleTy) {
2790 case MVT::v2i64: return fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v2i64_ri_Predicate_LaneIdx2(RetVT, Op0, imm1);
2791 case MVT::v2f64: return fastEmit_ISD_EXTRACT_VECTOR_ELT_MVT_v2f64_ri_Predicate_LaneIdx2(RetVT, Op0, imm1);
2792 default: return Register();
2793 }
2794}
2795
2796// Top-level FastEmit function.
2797
2798Register fastEmit_ri_Predicate_LaneIdx2(MVT VT, MVT RetVT, unsigned Opcode, Register Op0, uint64_t imm1) {
2799 switch (Opcode) {
2800 case ISD::EXTRACT_VECTOR_ELT: return fastEmit_ISD_EXTRACT_VECTOR_ELT_ri_Predicate_LaneIdx2(VT, RetVT, Op0, imm1);
2801 default: return Register();
2802 }
2803}
2804
2805// FastEmit functions for ISD::ConstantFP.
2806
2807Register fastEmit_ISD_ConstantFP_MVT_f32_f(MVT RetVT, const ConstantFP *f0) {
2808 if (RetVT.SimpleTy != MVT::f32)
2809 return Register();
2810 return fastEmitInst_f(MachineInstOpcode: WebAssembly::CONST_F32, RC: &WebAssembly::F32RegClass, FPImm: f0);
2811}
2812
2813Register fastEmit_ISD_ConstantFP_MVT_f64_f(MVT RetVT, const ConstantFP *f0) {
2814 if (RetVT.SimpleTy != MVT::f64)
2815 return Register();
2816 return fastEmitInst_f(MachineInstOpcode: WebAssembly::CONST_F64, RC: &WebAssembly::F64RegClass, FPImm: f0);
2817}
2818
2819Register fastEmit_ISD_ConstantFP_f(MVT VT, MVT RetVT, const ConstantFP *f0) {
2820 switch (VT.SimpleTy) {
2821 case MVT::f32: return fastEmit_ISD_ConstantFP_MVT_f32_f(RetVT, f0);
2822 case MVT::f64: return fastEmit_ISD_ConstantFP_MVT_f64_f(RetVT, f0);
2823 default: return Register();
2824 }
2825}
2826
2827// Top-level FastEmit function.
2828
2829Register fastEmit_f(MVT VT, MVT RetVT, unsigned Opcode, const ConstantFP *f0) override {
2830 switch (Opcode) {
2831 case ISD::ConstantFP: return fastEmit_ISD_ConstantFP_f(VT, RetVT, f0);
2832 default: return Register();
2833 }
2834}
2835
2836// FastEmit functions for ISD::Constant.
2837
2838Register fastEmit_ISD_Constant_MVT_i32_i(MVT RetVT, uint64_t imm0) {
2839 if (RetVT.SimpleTy != MVT::i32)
2840 return Register();
2841 return fastEmitInst_i(MachineInstOpcode: WebAssembly::CONST_I32, RC: &WebAssembly::I32RegClass, Imm: imm0);
2842}
2843
2844Register fastEmit_ISD_Constant_MVT_i64_i(MVT RetVT, uint64_t imm0) {
2845 if (RetVT.SimpleTy != MVT::i64)
2846 return Register();
2847 return fastEmitInst_i(MachineInstOpcode: WebAssembly::CONST_I64, RC: &WebAssembly::I64RegClass, Imm: imm0);
2848}
2849
2850Register fastEmit_ISD_Constant_i(MVT VT, MVT RetVT, uint64_t imm0) {
2851 switch (VT.SimpleTy) {
2852 case MVT::i32: return fastEmit_ISD_Constant_MVT_i32_i(RetVT, imm0);
2853 case MVT::i64: return fastEmit_ISD_Constant_MVT_i64_i(RetVT, imm0);
2854 default: return Register();
2855 }
2856}
2857
2858// Top-level FastEmit function.
2859
2860Register fastEmit_i(MVT VT, MVT RetVT, unsigned Opcode, uint64_t imm0) override {
2861 switch (Opcode) {
2862 case ISD::Constant: return fastEmit_ISD_Constant_i(VT, RetVT, imm0);
2863 default: return Register();
2864 }
2865}
2866
2867