1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* "Fast" Instruction Selector for the PPC target *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9
10// FastEmit Immediate Predicate functions.
11static bool Predicate_imm32SExt16(int64_t Imm) {
12
13 // imm32SExt16 predicate - True if the i32 immediate fits in a 16-bit
14 // sign extended field. Used by instructions like 'addi'.
15 return (int32_t)Imm == (short)Imm;
16
17}
18static bool Predicate_imm64SExt16(int64_t Imm) {
19
20 // imm64SExt16 predicate - True if the i64 immediate fits in a 16-bit
21 // sign extended field. Used by instructions like 'addi'.
22 return (int64_t)Imm == (short)Imm;
23
24}
25static bool Predicate_immSExt5NonZero(int64_t Imm) {
26 return Imm && isInt<5>(x: Imm);
27}
28static bool Predicate_i32immNonAllOneNonZero(int64_t Imm) {
29 return Imm && (Imm != -1);
30}
31
32
33// FastEmit functions for ISD::READCYCLECOUNTER.
34
35Register fastEmit_ISD_READCYCLECOUNTER_MVT_i64_(MVT RetVT) {
36 if (RetVT.SimpleTy != MVT::i64)
37 return Register();
38 return fastEmitInst_(MachineInstOpcode: PPC::MFTB8, RC: &PPC::G8RCRegClass);
39}
40
41Register fastEmit_ISD_READCYCLECOUNTER_(MVT VT, MVT RetVT) {
42 switch (VT.SimpleTy) {
43 case MVT::i64: return fastEmit_ISD_READCYCLECOUNTER_MVT_i64_(RetVT);
44 default: return Register();
45 }
46}
47
48// FastEmit functions for PPCISD::GET_TPOINTER.
49
50Register fastEmit_PPCISD_GET_TPOINTER_MVT_i32_(MVT RetVT) {
51 if (RetVT.SimpleTy != MVT::i32)
52 return Register();
53 return fastEmitInst_(MachineInstOpcode: PPC::GETtlsTpointer32AIX, RC: &PPC::GPRCRegClass);
54}
55
56Register fastEmit_PPCISD_GET_TPOINTER_(MVT VT, MVT RetVT) {
57 switch (VT.SimpleTy) {
58 case MVT::i32: return fastEmit_PPCISD_GET_TPOINTER_MVT_i32_(RetVT);
59 default: return Register();
60 }
61}
62
63// FastEmit functions for PPCISD::MFFS.
64
65Register fastEmit_PPCISD_MFFS_MVT_f64_(MVT RetVT) {
66 if (RetVT.SimpleTy != MVT::f64)
67 return Register();
68 if ((Subtarget->hasFPU())) {
69 return fastEmitInst_(MachineInstOpcode: PPC::MFFS, RC: &PPC::F8RCRegClass);
70 }
71 return Register();
72}
73
74Register fastEmit_PPCISD_MFFS_(MVT VT, MVT RetVT) {
75 switch (VT.SimpleTy) {
76 case MVT::f64: return fastEmit_PPCISD_MFFS_MVT_f64_(RetVT);
77 default: return Register();
78 }
79}
80
81// FastEmit functions for PPCISD::PPC32_GOT.
82
83Register fastEmit_PPCISD_PPC32_GOT_MVT_i32_(MVT RetVT) {
84 if (RetVT.SimpleTy != MVT::i32)
85 return Register();
86 return fastEmitInst_(MachineInstOpcode: PPC::PPC32GOT, RC: &PPC::GPRCRegClass);
87}
88
89Register fastEmit_PPCISD_PPC32_GOT_(MVT VT, MVT RetVT) {
90 switch (VT.SimpleTy) {
91 case MVT::i32: return fastEmit_PPCISD_PPC32_GOT_MVT_i32_(RetVT);
92 default: return Register();
93 }
94}
95
96// Top-level FastEmit function.
97
98Register fastEmit_(MVT VT, MVT RetVT, unsigned Opcode) override {
99 switch (Opcode) {
100 case ISD::READCYCLECOUNTER: return fastEmit_ISD_READCYCLECOUNTER_(VT, RetVT);
101 case PPCISD::GET_TPOINTER: return fastEmit_PPCISD_GET_TPOINTER_(VT, RetVT);
102 case PPCISD::MFFS: return fastEmit_PPCISD_MFFS_(VT, RetVT);
103 case PPCISD::PPC32_GOT: return fastEmit_PPCISD_PPC32_GOT_(VT, RetVT);
104 default: return Register();
105 }
106}
107
108// FastEmit functions for ISD::ANY_EXTEND.
109
110Register fastEmit_ISD_ANY_EXTEND_MVT_i1_MVT_i32_r(Register Op0) {
111 if ((Subtarget->isISA3_1())) {
112 return fastEmitInst_r(MachineInstOpcode: PPC::SETBC, RC: &PPC::GPRCRegClass, Op0);
113 }
114 return Register();
115}
116
117Register fastEmit_ISD_ANY_EXTEND_MVT_i1_MVT_i64_r(Register Op0) {
118 if ((Subtarget->isISA3_1())) {
119 return fastEmitInst_r(MachineInstOpcode: PPC::SETBC8, RC: &PPC::G8RCRegClass, Op0);
120 }
121 return Register();
122}
123
124Register fastEmit_ISD_ANY_EXTEND_MVT_i1_r(MVT RetVT, Register Op0) {
125switch (RetVT.SimpleTy) {
126 case MVT::i32: return fastEmit_ISD_ANY_EXTEND_MVT_i1_MVT_i32_r(Op0);
127 case MVT::i64: return fastEmit_ISD_ANY_EXTEND_MVT_i1_MVT_i64_r(Op0);
128 default: return Register();
129}
130}
131
132Register fastEmit_ISD_ANY_EXTEND_r(MVT VT, MVT RetVT, Register Op0) {
133 switch (VT.SimpleTy) {
134 case MVT::i1: return fastEmit_ISD_ANY_EXTEND_MVT_i1_r(RetVT, Op0);
135 default: return Register();
136 }
137}
138
139// FastEmit functions for ISD::BITCAST.
140
141Register fastEmit_ISD_BITCAST_MVT_i64_r(MVT RetVT, Register Op0) {
142 if (RetVT.SimpleTy != MVT::f64)
143 return Register();
144 if ((Subtarget->hasDirectMove()) && (Subtarget->hasVSX())) {
145 return fastEmitInst_r(MachineInstOpcode: PPC::MTVSRD, RC: &PPC::VSFRCRegClass, Op0);
146 }
147 return Register();
148}
149
150Register fastEmit_ISD_BITCAST_MVT_f64_r(MVT RetVT, Register Op0) {
151 if (RetVT.SimpleTy != MVT::i64)
152 return Register();
153 if ((Subtarget->hasDirectMove()) && (Subtarget->hasVSX())) {
154 return fastEmitInst_r(MachineInstOpcode: PPC::MFVSRD, RC: &PPC::G8RCRegClass, Op0);
155 }
156 return Register();
157}
158
159Register fastEmit_ISD_BITCAST_r(MVT VT, MVT RetVT, Register Op0) {
160 switch (VT.SimpleTy) {
161 case MVT::i64: return fastEmit_ISD_BITCAST_MVT_i64_r(RetVT, Op0);
162 case MVT::f64: return fastEmit_ISD_BITCAST_MVT_f64_r(RetVT, Op0);
163 default: return Register();
164 }
165}
166
167// FastEmit functions for ISD::BSWAP.
168
169Register fastEmit_ISD_BSWAP_MVT_i32_r(MVT RetVT, Register Op0) {
170 if (RetVT.SimpleTy != MVT::i32)
171 return Register();
172 if ((Subtarget->isISA3_1())) {
173 return fastEmitInst_r(MachineInstOpcode: PPC::BRW, RC: &PPC::GPRCRegClass, Op0);
174 }
175 return Register();
176}
177
178Register fastEmit_ISD_BSWAP_MVT_i64_r(MVT RetVT, Register Op0) {
179 if (RetVT.SimpleTy != MVT::i64)
180 return Register();
181 if ((Subtarget->isISA3_1())) {
182 return fastEmitInst_r(MachineInstOpcode: PPC::BRD, RC: &PPC::G8RCRegClass, Op0);
183 }
184 return Register();
185}
186
187Register fastEmit_ISD_BSWAP_MVT_v4i32_r(MVT RetVT, Register Op0) {
188 if (RetVT.SimpleTy != MVT::v4i32)
189 return Register();
190 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
191 return fastEmitInst_r(MachineInstOpcode: PPC::XXBRW, RC: &PPC::VSRCRegClass, Op0);
192 }
193 return Register();
194}
195
196Register fastEmit_ISD_BSWAP_MVT_v2i64_r(MVT RetVT, Register Op0) {
197 if (RetVT.SimpleTy != MVT::v2i64)
198 return Register();
199 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
200 return fastEmitInst_r(MachineInstOpcode: PPC::XXBRD, RC: &PPC::VSRCRegClass, Op0);
201 }
202 return Register();
203}
204
205Register fastEmit_ISD_BSWAP_r(MVT VT, MVT RetVT, Register Op0) {
206 switch (VT.SimpleTy) {
207 case MVT::i32: return fastEmit_ISD_BSWAP_MVT_i32_r(RetVT, Op0);
208 case MVT::i64: return fastEmit_ISD_BSWAP_MVT_i64_r(RetVT, Op0);
209 case MVT::v4i32: return fastEmit_ISD_BSWAP_MVT_v4i32_r(RetVT, Op0);
210 case MVT::v2i64: return fastEmit_ISD_BSWAP_MVT_v2i64_r(RetVT, Op0);
211 default: return Register();
212 }
213}
214
215// FastEmit functions for ISD::CTLZ.
216
217Register fastEmit_ISD_CTLZ_MVT_i32_r(MVT RetVT, Register Op0) {
218 if (RetVT.SimpleTy != MVT::i32)
219 return Register();
220 return fastEmitInst_r(MachineInstOpcode: PPC::CNTLZW, RC: &PPC::GPRCRegClass, Op0);
221}
222
223Register fastEmit_ISD_CTLZ_MVT_i64_r(MVT RetVT, Register Op0) {
224 if (RetVT.SimpleTy != MVT::i64)
225 return Register();
226 return fastEmitInst_r(MachineInstOpcode: PPC::CNTLZD, RC: &PPC::G8RCRegClass, Op0);
227}
228
229Register fastEmit_ISD_CTLZ_MVT_v16i8_r(MVT RetVT, Register Op0) {
230 if (RetVT.SimpleTy != MVT::v16i8)
231 return Register();
232 if ((Subtarget->hasP8Altivec())) {
233 return fastEmitInst_r(MachineInstOpcode: PPC::VCLZB, RC: &PPC::VRRCRegClass, Op0);
234 }
235 return Register();
236}
237
238Register fastEmit_ISD_CTLZ_MVT_v8i16_r(MVT RetVT, Register Op0) {
239 if (RetVT.SimpleTy != MVT::v8i16)
240 return Register();
241 if ((Subtarget->hasP8Altivec())) {
242 return fastEmitInst_r(MachineInstOpcode: PPC::VCLZH, RC: &PPC::VRRCRegClass, Op0);
243 }
244 return Register();
245}
246
247Register fastEmit_ISD_CTLZ_MVT_v4i32_r(MVT RetVT, Register Op0) {
248 if (RetVT.SimpleTy != MVT::v4i32)
249 return Register();
250 if ((Subtarget->hasP8Altivec())) {
251 return fastEmitInst_r(MachineInstOpcode: PPC::VCLZW, RC: &PPC::VRRCRegClass, Op0);
252 }
253 return Register();
254}
255
256Register fastEmit_ISD_CTLZ_MVT_v2i64_r(MVT RetVT, Register Op0) {
257 if (RetVT.SimpleTy != MVT::v2i64)
258 return Register();
259 if ((Subtarget->hasP8Altivec())) {
260 return fastEmitInst_r(MachineInstOpcode: PPC::VCLZD, RC: &PPC::VRRCRegClass, Op0);
261 }
262 return Register();
263}
264
265Register fastEmit_ISD_CTLZ_r(MVT VT, MVT RetVT, Register Op0) {
266 switch (VT.SimpleTy) {
267 case MVT::i32: return fastEmit_ISD_CTLZ_MVT_i32_r(RetVT, Op0);
268 case MVT::i64: return fastEmit_ISD_CTLZ_MVT_i64_r(RetVT, Op0);
269 case MVT::v16i8: return fastEmit_ISD_CTLZ_MVT_v16i8_r(RetVT, Op0);
270 case MVT::v8i16: return fastEmit_ISD_CTLZ_MVT_v8i16_r(RetVT, Op0);
271 case MVT::v4i32: return fastEmit_ISD_CTLZ_MVT_v4i32_r(RetVT, Op0);
272 case MVT::v2i64: return fastEmit_ISD_CTLZ_MVT_v2i64_r(RetVT, Op0);
273 default: return Register();
274 }
275}
276
277// FastEmit functions for ISD::CTPOP.
278
279Register fastEmit_ISD_CTPOP_MVT_i32_r(MVT RetVT, Register Op0) {
280 if (RetVT.SimpleTy != MVT::i32)
281 return Register();
282 return fastEmitInst_r(MachineInstOpcode: PPC::POPCNTW, RC: &PPC::GPRCRegClass, Op0);
283}
284
285Register fastEmit_ISD_CTPOP_MVT_i64_r(MVT RetVT, Register Op0) {
286 if (RetVT.SimpleTy != MVT::i64)
287 return Register();
288 return fastEmitInst_r(MachineInstOpcode: PPC::POPCNTD, RC: &PPC::G8RCRegClass, Op0);
289}
290
291Register fastEmit_ISD_CTPOP_MVT_v16i8_r(MVT RetVT, Register Op0) {
292 if (RetVT.SimpleTy != MVT::v16i8)
293 return Register();
294 if ((Subtarget->hasP8Altivec())) {
295 return fastEmitInst_r(MachineInstOpcode: PPC::VPOPCNTB, RC: &PPC::VRRCRegClass, Op0);
296 }
297 return Register();
298}
299
300Register fastEmit_ISD_CTPOP_MVT_v8i16_r(MVT RetVT, Register Op0) {
301 if (RetVT.SimpleTy != MVT::v8i16)
302 return Register();
303 if ((Subtarget->hasP8Altivec())) {
304 return fastEmitInst_r(MachineInstOpcode: PPC::VPOPCNTH, RC: &PPC::VRRCRegClass, Op0);
305 }
306 return Register();
307}
308
309Register fastEmit_ISD_CTPOP_MVT_v4i32_r(MVT RetVT, Register Op0) {
310 if (RetVT.SimpleTy != MVT::v4i32)
311 return Register();
312 if ((Subtarget->hasP8Altivec())) {
313 return fastEmitInst_r(MachineInstOpcode: PPC::VPOPCNTW, RC: &PPC::VRRCRegClass, Op0);
314 }
315 return Register();
316}
317
318Register fastEmit_ISD_CTPOP_MVT_v2i64_r(MVT RetVT, Register Op0) {
319 if (RetVT.SimpleTy != MVT::v2i64)
320 return Register();
321 if ((Subtarget->hasP8Altivec())) {
322 return fastEmitInst_r(MachineInstOpcode: PPC::VPOPCNTD, RC: &PPC::VRRCRegClass, Op0);
323 }
324 return Register();
325}
326
327Register fastEmit_ISD_CTPOP_r(MVT VT, MVT RetVT, Register Op0) {
328 switch (VT.SimpleTy) {
329 case MVT::i32: return fastEmit_ISD_CTPOP_MVT_i32_r(RetVT, Op0);
330 case MVT::i64: return fastEmit_ISD_CTPOP_MVT_i64_r(RetVT, Op0);
331 case MVT::v16i8: return fastEmit_ISD_CTPOP_MVT_v16i8_r(RetVT, Op0);
332 case MVT::v8i16: return fastEmit_ISD_CTPOP_MVT_v8i16_r(RetVT, Op0);
333 case MVT::v4i32: return fastEmit_ISD_CTPOP_MVT_v4i32_r(RetVT, Op0);
334 case MVT::v2i64: return fastEmit_ISD_CTPOP_MVT_v2i64_r(RetVT, Op0);
335 default: return Register();
336 }
337}
338
339// FastEmit functions for ISD::CTTZ.
340
341Register fastEmit_ISD_CTTZ_MVT_i32_r(MVT RetVT, Register Op0) {
342 if (RetVT.SimpleTy != MVT::i32)
343 return Register();
344 if ((Subtarget->isISA3_0())) {
345 return fastEmitInst_r(MachineInstOpcode: PPC::CNTTZW, RC: &PPC::GPRCRegClass, Op0);
346 }
347 return Register();
348}
349
350Register fastEmit_ISD_CTTZ_MVT_i64_r(MVT RetVT, Register Op0) {
351 if (RetVT.SimpleTy != MVT::i64)
352 return Register();
353 if ((Subtarget->isISA3_0())) {
354 return fastEmitInst_r(MachineInstOpcode: PPC::CNTTZD, RC: &PPC::G8RCRegClass, Op0);
355 }
356 return Register();
357}
358
359Register fastEmit_ISD_CTTZ_MVT_v16i8_r(MVT RetVT, Register Op0) {
360 if (RetVT.SimpleTy != MVT::v16i8)
361 return Register();
362 if ((Subtarget->hasP9Altivec())) {
363 return fastEmitInst_r(MachineInstOpcode: PPC::VCTZB, RC: &PPC::VRRCRegClass, Op0);
364 }
365 return Register();
366}
367
368Register fastEmit_ISD_CTTZ_MVT_v8i16_r(MVT RetVT, Register Op0) {
369 if (RetVT.SimpleTy != MVT::v8i16)
370 return Register();
371 if ((Subtarget->hasP9Altivec())) {
372 return fastEmitInst_r(MachineInstOpcode: PPC::VCTZH, RC: &PPC::VRRCRegClass, Op0);
373 }
374 return Register();
375}
376
377Register fastEmit_ISD_CTTZ_MVT_v4i32_r(MVT RetVT, Register Op0) {
378 if (RetVT.SimpleTy != MVT::v4i32)
379 return Register();
380 if ((Subtarget->hasP9Altivec())) {
381 return fastEmitInst_r(MachineInstOpcode: PPC::VCTZW, RC: &PPC::VRRCRegClass, Op0);
382 }
383 return Register();
384}
385
386Register fastEmit_ISD_CTTZ_MVT_v2i64_r(MVT RetVT, Register Op0) {
387 if (RetVT.SimpleTy != MVT::v2i64)
388 return Register();
389 if ((Subtarget->hasP9Altivec())) {
390 return fastEmitInst_r(MachineInstOpcode: PPC::VCTZD, RC: &PPC::VRRCRegClass, Op0);
391 }
392 return Register();
393}
394
395Register fastEmit_ISD_CTTZ_r(MVT VT, MVT RetVT, Register Op0) {
396 switch (VT.SimpleTy) {
397 case MVT::i32: return fastEmit_ISD_CTTZ_MVT_i32_r(RetVT, Op0);
398 case MVT::i64: return fastEmit_ISD_CTTZ_MVT_i64_r(RetVT, Op0);
399 case MVT::v16i8: return fastEmit_ISD_CTTZ_MVT_v16i8_r(RetVT, Op0);
400 case MVT::v8i16: return fastEmit_ISD_CTTZ_MVT_v8i16_r(RetVT, Op0);
401 case MVT::v4i32: return fastEmit_ISD_CTTZ_MVT_v4i32_r(RetVT, Op0);
402 case MVT::v2i64: return fastEmit_ISD_CTTZ_MVT_v2i64_r(RetVT, Op0);
403 default: return Register();
404 }
405}
406
407// FastEmit functions for ISD::FABS.
408
409Register fastEmit_ISD_FABS_MVT_f32_r(MVT RetVT, Register Op0) {
410 if (RetVT.SimpleTy != MVT::f32)
411 return Register();
412 if ((Subtarget->hasSPE())) {
413 return fastEmitInst_r(MachineInstOpcode: PPC::EFSABS, RC: &PPC::GPRCRegClass, Op0);
414 }
415 if ((Subtarget->hasFPU())) {
416 return fastEmitInst_r(MachineInstOpcode: PPC::FABSS, RC: &PPC::F4RCRegClass, Op0);
417 }
418 return Register();
419}
420
421Register fastEmit_ISD_FABS_MVT_f64_r(MVT RetVT, Register Op0) {
422 if (RetVT.SimpleTy != MVT::f64)
423 return Register();
424 if ((Subtarget->hasVSX())) {
425 return fastEmitInst_r(MachineInstOpcode: PPC::XSABSDP, RC: &PPC::VSFRCRegClass, Op0);
426 }
427 if ((Subtarget->hasSPE())) {
428 return fastEmitInst_r(MachineInstOpcode: PPC::EFDABS, RC: &PPC::SPERCRegClass, Op0);
429 }
430 if ((Subtarget->hasFPU())) {
431 return fastEmitInst_r(MachineInstOpcode: PPC::FABSD, RC: &PPC::F8RCRegClass, Op0);
432 }
433 return Register();
434}
435
436Register fastEmit_ISD_FABS_MVT_f128_r(MVT RetVT, Register Op0) {
437 if (RetVT.SimpleTy != MVT::f128)
438 return Register();
439 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
440 return fastEmitInst_r(MachineInstOpcode: PPC::XSABSQP, RC: &PPC::VRRCRegClass, Op0);
441 }
442 return Register();
443}
444
445Register fastEmit_ISD_FABS_MVT_v4f32_r(MVT RetVT, Register Op0) {
446 if (RetVT.SimpleTy != MVT::v4f32)
447 return Register();
448 if ((Subtarget->hasVSX())) {
449 return fastEmitInst_r(MachineInstOpcode: PPC::XVABSSP, RC: &PPC::VSRCRegClass, Op0);
450 }
451 return Register();
452}
453
454Register fastEmit_ISD_FABS_MVT_v2f64_r(MVT RetVT, Register Op0) {
455 if (RetVT.SimpleTy != MVT::v2f64)
456 return Register();
457 if ((Subtarget->hasVSX())) {
458 return fastEmitInst_r(MachineInstOpcode: PPC::XVABSDP, RC: &PPC::VSRCRegClass, Op0);
459 }
460 return Register();
461}
462
463Register fastEmit_ISD_FABS_r(MVT VT, MVT RetVT, Register Op0) {
464 switch (VT.SimpleTy) {
465 case MVT::f32: return fastEmit_ISD_FABS_MVT_f32_r(RetVT, Op0);
466 case MVT::f64: return fastEmit_ISD_FABS_MVT_f64_r(RetVT, Op0);
467 case MVT::f128: return fastEmit_ISD_FABS_MVT_f128_r(RetVT, Op0);
468 case MVT::v4f32: return fastEmit_ISD_FABS_MVT_v4f32_r(RetVT, Op0);
469 case MVT::v2f64: return fastEmit_ISD_FABS_MVT_v2f64_r(RetVT, Op0);
470 default: return Register();
471 }
472}
473
474// FastEmit functions for ISD::FCEIL.
475
476Register fastEmit_ISD_FCEIL_MVT_f32_r(MVT RetVT, Register Op0) {
477 if (RetVT.SimpleTy != MVT::f32)
478 return Register();
479 if ((Subtarget->hasFPU())) {
480 return fastEmitInst_r(MachineInstOpcode: PPC::FRIPS, RC: &PPC::F4RCRegClass, Op0);
481 }
482 return Register();
483}
484
485Register fastEmit_ISD_FCEIL_MVT_f64_r(MVT RetVT, Register Op0) {
486 if (RetVT.SimpleTy != MVT::f64)
487 return Register();
488 if ((Subtarget->hasVSX())) {
489 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPIP, RC: &PPC::VSFRCRegClass, Op0);
490 }
491 if ((Subtarget->hasFPU())) {
492 return fastEmitInst_r(MachineInstOpcode: PPC::FRIPD, RC: &PPC::F8RCRegClass, Op0);
493 }
494 return Register();
495}
496
497Register fastEmit_ISD_FCEIL_MVT_v4f32_r(MVT RetVT, Register Op0) {
498 if (RetVT.SimpleTy != MVT::v4f32)
499 return Register();
500 if ((Subtarget->hasVSX())) {
501 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPIP, RC: &PPC::VSRCRegClass, Op0);
502 }
503 if ((Subtarget->hasAltivec())) {
504 return fastEmitInst_r(MachineInstOpcode: PPC::VRFIP, RC: &PPC::VRRCRegClass, Op0);
505 }
506 return Register();
507}
508
509Register fastEmit_ISD_FCEIL_MVT_v2f64_r(MVT RetVT, Register Op0) {
510 if (RetVT.SimpleTy != MVT::v2f64)
511 return Register();
512 if ((Subtarget->hasVSX())) {
513 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPIP, RC: &PPC::VSRCRegClass, Op0);
514 }
515 return Register();
516}
517
518Register fastEmit_ISD_FCEIL_r(MVT VT, MVT RetVT, Register Op0) {
519 switch (VT.SimpleTy) {
520 case MVT::f32: return fastEmit_ISD_FCEIL_MVT_f32_r(RetVT, Op0);
521 case MVT::f64: return fastEmit_ISD_FCEIL_MVT_f64_r(RetVT, Op0);
522 case MVT::v4f32: return fastEmit_ISD_FCEIL_MVT_v4f32_r(RetVT, Op0);
523 case MVT::v2f64: return fastEmit_ISD_FCEIL_MVT_v2f64_r(RetVT, Op0);
524 default: return Register();
525 }
526}
527
528// FastEmit functions for ISD::FFLOOR.
529
530Register fastEmit_ISD_FFLOOR_MVT_f32_r(MVT RetVT, Register Op0) {
531 if (RetVT.SimpleTy != MVT::f32)
532 return Register();
533 if ((Subtarget->hasFPU())) {
534 return fastEmitInst_r(MachineInstOpcode: PPC::FRIMS, RC: &PPC::F4RCRegClass, Op0);
535 }
536 return Register();
537}
538
539Register fastEmit_ISD_FFLOOR_MVT_f64_r(MVT RetVT, Register Op0) {
540 if (RetVT.SimpleTy != MVT::f64)
541 return Register();
542 if ((Subtarget->hasVSX())) {
543 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPIM, RC: &PPC::VSFRCRegClass, Op0);
544 }
545 if ((Subtarget->hasFPU())) {
546 return fastEmitInst_r(MachineInstOpcode: PPC::FRIMD, RC: &PPC::F8RCRegClass, Op0);
547 }
548 return Register();
549}
550
551Register fastEmit_ISD_FFLOOR_MVT_v4f32_r(MVT RetVT, Register Op0) {
552 if (RetVT.SimpleTy != MVT::v4f32)
553 return Register();
554 if ((Subtarget->hasVSX())) {
555 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPIM, RC: &PPC::VSRCRegClass, Op0);
556 }
557 if ((Subtarget->hasAltivec())) {
558 return fastEmitInst_r(MachineInstOpcode: PPC::VRFIM, RC: &PPC::VRRCRegClass, Op0);
559 }
560 return Register();
561}
562
563Register fastEmit_ISD_FFLOOR_MVT_v2f64_r(MVT RetVT, Register Op0) {
564 if (RetVT.SimpleTy != MVT::v2f64)
565 return Register();
566 if ((Subtarget->hasVSX())) {
567 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPIM, RC: &PPC::VSRCRegClass, Op0);
568 }
569 return Register();
570}
571
572Register fastEmit_ISD_FFLOOR_r(MVT VT, MVT RetVT, Register Op0) {
573 switch (VT.SimpleTy) {
574 case MVT::f32: return fastEmit_ISD_FFLOOR_MVT_f32_r(RetVT, Op0);
575 case MVT::f64: return fastEmit_ISD_FFLOOR_MVT_f64_r(RetVT, Op0);
576 case MVT::v4f32: return fastEmit_ISD_FFLOOR_MVT_v4f32_r(RetVT, Op0);
577 case MVT::v2f64: return fastEmit_ISD_FFLOOR_MVT_v2f64_r(RetVT, Op0);
578 default: return Register();
579 }
580}
581
582// FastEmit functions for ISD::FNEARBYINT.
583
584Register fastEmit_ISD_FNEARBYINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
585 if (RetVT.SimpleTy != MVT::v4f32)
586 return Register();
587 if ((Subtarget->hasAltivec())) {
588 return fastEmitInst_r(MachineInstOpcode: PPC::VRFIN, RC: &PPC::VRRCRegClass, Op0);
589 }
590 return Register();
591}
592
593Register fastEmit_ISD_FNEARBYINT_r(MVT VT, MVT RetVT, Register Op0) {
594 switch (VT.SimpleTy) {
595 case MVT::v4f32: return fastEmit_ISD_FNEARBYINT_MVT_v4f32_r(RetVT, Op0);
596 default: return Register();
597 }
598}
599
600// FastEmit functions for ISD::FNEG.
601
602Register fastEmit_ISD_FNEG_MVT_f32_r(MVT RetVT, Register Op0) {
603 if (RetVT.SimpleTy != MVT::f32)
604 return Register();
605 if ((Subtarget->hasSPE())) {
606 return fastEmitInst_r(MachineInstOpcode: PPC::EFSNEG, RC: &PPC::GPRCRegClass, Op0);
607 }
608 if ((Subtarget->hasFPU())) {
609 return fastEmitInst_r(MachineInstOpcode: PPC::FNEGS, RC: &PPC::F4RCRegClass, Op0);
610 }
611 return Register();
612}
613
614Register fastEmit_ISD_FNEG_MVT_f64_r(MVT RetVT, Register Op0) {
615 if (RetVT.SimpleTy != MVT::f64)
616 return Register();
617 if ((Subtarget->hasVSX())) {
618 return fastEmitInst_r(MachineInstOpcode: PPC::XSNEGDP, RC: &PPC::VSFRCRegClass, Op0);
619 }
620 if ((Subtarget->hasSPE())) {
621 return fastEmitInst_r(MachineInstOpcode: PPC::EFDNEG, RC: &PPC::SPERCRegClass, Op0);
622 }
623 if ((Subtarget->hasFPU())) {
624 return fastEmitInst_r(MachineInstOpcode: PPC::FNEGD, RC: &PPC::F8RCRegClass, Op0);
625 }
626 return Register();
627}
628
629Register fastEmit_ISD_FNEG_MVT_f128_r(MVT RetVT, Register Op0) {
630 if (RetVT.SimpleTy != MVT::f128)
631 return Register();
632 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
633 return fastEmitInst_r(MachineInstOpcode: PPC::XSNEGQP, RC: &PPC::VRRCRegClass, Op0);
634 }
635 return Register();
636}
637
638Register fastEmit_ISD_FNEG_MVT_v4f32_r(MVT RetVT, Register Op0) {
639 if (RetVT.SimpleTy != MVT::v4f32)
640 return Register();
641 if ((Subtarget->hasVSX())) {
642 return fastEmitInst_r(MachineInstOpcode: PPC::XVNEGSP, RC: &PPC::VSRCRegClass, Op0);
643 }
644 return Register();
645}
646
647Register fastEmit_ISD_FNEG_MVT_v2f64_r(MVT RetVT, Register Op0) {
648 if (RetVT.SimpleTy != MVT::v2f64)
649 return Register();
650 if ((Subtarget->hasVSX())) {
651 return fastEmitInst_r(MachineInstOpcode: PPC::XVNEGDP, RC: &PPC::VSRCRegClass, Op0);
652 }
653 return Register();
654}
655
656Register fastEmit_ISD_FNEG_r(MVT VT, MVT RetVT, Register Op0) {
657 switch (VT.SimpleTy) {
658 case MVT::f32: return fastEmit_ISD_FNEG_MVT_f32_r(RetVT, Op0);
659 case MVT::f64: return fastEmit_ISD_FNEG_MVT_f64_r(RetVT, Op0);
660 case MVT::f128: return fastEmit_ISD_FNEG_MVT_f128_r(RetVT, Op0);
661 case MVT::v4f32: return fastEmit_ISD_FNEG_MVT_v4f32_r(RetVT, Op0);
662 case MVT::v2f64: return fastEmit_ISD_FNEG_MVT_v2f64_r(RetVT, Op0);
663 default: return Register();
664 }
665}
666
667// FastEmit functions for ISD::FP_EXTEND.
668
669Register fastEmit_ISD_FP_EXTEND_MVT_f32_r(MVT RetVT, Register Op0) {
670 if (RetVT.SimpleTy != MVT::f64)
671 return Register();
672 if ((Subtarget->hasSPE())) {
673 return fastEmitInst_r(MachineInstOpcode: PPC::EFDCFS, RC: &PPC::SPERCRegClass, Op0);
674 }
675 return Register();
676}
677
678Register fastEmit_ISD_FP_EXTEND_MVT_f64_r(MVT RetVT, Register Op0) {
679 if (RetVT.SimpleTy != MVT::f128)
680 return Register();
681 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
682 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPQP, RC: &PPC::VRRCRegClass, Op0);
683 }
684 return Register();
685}
686
687Register fastEmit_ISD_FP_EXTEND_r(MVT VT, MVT RetVT, Register Op0) {
688 switch (VT.SimpleTy) {
689 case MVT::f32: return fastEmit_ISD_FP_EXTEND_MVT_f32_r(RetVT, Op0);
690 case MVT::f64: return fastEmit_ISD_FP_EXTEND_MVT_f64_r(RetVT, Op0);
691 default: return Register();
692 }
693}
694
695// FastEmit functions for ISD::FP_ROUND.
696
697Register fastEmit_ISD_FP_ROUND_MVT_f64_r(MVT RetVT, Register Op0) {
698 if (RetVT.SimpleTy != MVT::f32)
699 return Register();
700 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
701 return fastEmitInst_r(MachineInstOpcode: PPC::XSRSP, RC: &PPC::VSSRCRegClass, Op0);
702 }
703 if ((Subtarget->hasSPE())) {
704 return fastEmitInst_r(MachineInstOpcode: PPC::EFSCFD, RC: &PPC::GPRCRegClass, Op0);
705 }
706 if ((Subtarget->hasFPU())) {
707 return fastEmitInst_r(MachineInstOpcode: PPC::FRSP, RC: &PPC::F4RCRegClass, Op0);
708 }
709 return Register();
710}
711
712Register fastEmit_ISD_FP_ROUND_MVT_f128_r(MVT RetVT, Register Op0) {
713 if (RetVT.SimpleTy != MVT::f64)
714 return Register();
715 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
716 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVQPDP, RC: &PPC::VFRCRegClass, Op0);
717 }
718 return Register();
719}
720
721Register fastEmit_ISD_FP_ROUND_r(MVT VT, MVT RetVT, Register Op0) {
722 switch (VT.SimpleTy) {
723 case MVT::f64: return fastEmit_ISD_FP_ROUND_MVT_f64_r(RetVT, Op0);
724 case MVT::f128: return fastEmit_ISD_FP_ROUND_MVT_f128_r(RetVT, Op0);
725 default: return Register();
726 }
727}
728
729// FastEmit functions for ISD::FP_TO_SINT.
730
731Register fastEmit_ISD_FP_TO_SINT_MVT_f32_r(MVT RetVT, Register Op0) {
732 if (RetVT.SimpleTy != MVT::i32)
733 return Register();
734 if ((Subtarget->hasSPE())) {
735 return fastEmitInst_r(MachineInstOpcode: PPC::EFSCTSIZ, RC: &PPC::GPRCRegClass, Op0);
736 }
737 return Register();
738}
739
740Register fastEmit_ISD_FP_TO_SINT_MVT_f64_r(MVT RetVT, Register Op0) {
741 if (RetVT.SimpleTy != MVT::i32)
742 return Register();
743 if ((Subtarget->hasSPE())) {
744 return fastEmitInst_r(MachineInstOpcode: PPC::EFDCTSIZ, RC: &PPC::GPRCRegClass, Op0);
745 }
746 return Register();
747}
748
749Register fastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
750 if (RetVT.SimpleTy != MVT::v4i32)
751 return Register();
752 if ((Subtarget->hasVSX())) {
753 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVSPSXWS, RC: &PPC::VSRCRegClass, Op0);
754 }
755 if ((Subtarget->hasAltivec())) {
756 return fastEmitInst_r(MachineInstOpcode: PPC::VCTSXS_0, RC: &PPC::VRRCRegClass, Op0);
757 }
758 return Register();
759}
760
761Register fastEmit_ISD_FP_TO_SINT_MVT_v2f64_r(MVT RetVT, Register Op0) {
762 if (RetVT.SimpleTy != MVT::v2i64)
763 return Register();
764 if ((Subtarget->hasVSX())) {
765 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVDPSXDS, RC: &PPC::VSRCRegClass, Op0);
766 }
767 return Register();
768}
769
770Register fastEmit_ISD_FP_TO_SINT_r(MVT VT, MVT RetVT, Register Op0) {
771 switch (VT.SimpleTy) {
772 case MVT::f32: return fastEmit_ISD_FP_TO_SINT_MVT_f32_r(RetVT, Op0);
773 case MVT::f64: return fastEmit_ISD_FP_TO_SINT_MVT_f64_r(RetVT, Op0);
774 case MVT::v4f32: return fastEmit_ISD_FP_TO_SINT_MVT_v4f32_r(RetVT, Op0);
775 case MVT::v2f64: return fastEmit_ISD_FP_TO_SINT_MVT_v2f64_r(RetVT, Op0);
776 default: return Register();
777 }
778}
779
780// FastEmit functions for ISD::FP_TO_UINT.
781
782Register fastEmit_ISD_FP_TO_UINT_MVT_f32_r(MVT RetVT, Register Op0) {
783 if (RetVT.SimpleTy != MVT::i32)
784 return Register();
785 if ((Subtarget->hasSPE())) {
786 return fastEmitInst_r(MachineInstOpcode: PPC::EFSCTUIZ, RC: &PPC::GPRCRegClass, Op0);
787 }
788 return Register();
789}
790
791Register fastEmit_ISD_FP_TO_UINT_MVT_f64_r(MVT RetVT, Register Op0) {
792 if (RetVT.SimpleTy != MVT::i32)
793 return Register();
794 if ((Subtarget->hasSPE())) {
795 return fastEmitInst_r(MachineInstOpcode: PPC::EFDCTUIZ, RC: &PPC::GPRCRegClass, Op0);
796 }
797 return Register();
798}
799
800Register fastEmit_ISD_FP_TO_UINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
801 if (RetVT.SimpleTy != MVT::v4i32)
802 return Register();
803 if ((Subtarget->hasVSX())) {
804 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVSPUXWS, RC: &PPC::VSRCRegClass, Op0);
805 }
806 if ((Subtarget->hasAltivec())) {
807 return fastEmitInst_r(MachineInstOpcode: PPC::VCTUXS_0, RC: &PPC::VRRCRegClass, Op0);
808 }
809 return Register();
810}
811
812Register fastEmit_ISD_FP_TO_UINT_MVT_v2f64_r(MVT RetVT, Register Op0) {
813 if (RetVT.SimpleTy != MVT::v2i64)
814 return Register();
815 if ((Subtarget->hasVSX())) {
816 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVDPUXDS, RC: &PPC::VSRCRegClass, Op0);
817 }
818 return Register();
819}
820
821Register fastEmit_ISD_FP_TO_UINT_r(MVT VT, MVT RetVT, Register Op0) {
822 switch (VT.SimpleTy) {
823 case MVT::f32: return fastEmit_ISD_FP_TO_UINT_MVT_f32_r(RetVT, Op0);
824 case MVT::f64: return fastEmit_ISD_FP_TO_UINT_MVT_f64_r(RetVT, Op0);
825 case MVT::v4f32: return fastEmit_ISD_FP_TO_UINT_MVT_v4f32_r(RetVT, Op0);
826 case MVT::v2f64: return fastEmit_ISD_FP_TO_UINT_MVT_v2f64_r(RetVT, Op0);
827 default: return Register();
828 }
829}
830
831// FastEmit functions for ISD::FRINT.
832
833Register fastEmit_ISD_FRINT_MVT_f64_r(MVT RetVT, Register Op0) {
834 if (RetVT.SimpleTy != MVT::f64)
835 return Register();
836 if ((Subtarget->hasVSX())) {
837 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPIC, RC: &PPC::VSFRCRegClass, Op0);
838 }
839 return Register();
840}
841
842Register fastEmit_ISD_FRINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
843 if (RetVT.SimpleTy != MVT::v4f32)
844 return Register();
845 if ((Subtarget->hasVSX())) {
846 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPIC, RC: &PPC::VSRCRegClass, Op0);
847 }
848 return Register();
849}
850
851Register fastEmit_ISD_FRINT_MVT_v2f64_r(MVT RetVT, Register Op0) {
852 if (RetVT.SimpleTy != MVT::v2f64)
853 return Register();
854 if ((Subtarget->hasVSX())) {
855 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPIC, RC: &PPC::VSRCRegClass, Op0);
856 }
857 return Register();
858}
859
860Register fastEmit_ISD_FRINT_r(MVT VT, MVT RetVT, Register Op0) {
861 switch (VT.SimpleTy) {
862 case MVT::f64: return fastEmit_ISD_FRINT_MVT_f64_r(RetVT, Op0);
863 case MVT::v4f32: return fastEmit_ISD_FRINT_MVT_v4f32_r(RetVT, Op0);
864 case MVT::v2f64: return fastEmit_ISD_FRINT_MVT_v2f64_r(RetVT, Op0);
865 default: return Register();
866 }
867}
868
869// FastEmit functions for ISD::FROUND.
870
871Register fastEmit_ISD_FROUND_MVT_f32_r(MVT RetVT, Register Op0) {
872 if (RetVT.SimpleTy != MVT::f32)
873 return Register();
874 if ((Subtarget->hasFPU())) {
875 return fastEmitInst_r(MachineInstOpcode: PPC::FRINS, RC: &PPC::F4RCRegClass, Op0);
876 }
877 return Register();
878}
879
880Register fastEmit_ISD_FROUND_MVT_f64_r(MVT RetVT, Register Op0) {
881 if (RetVT.SimpleTy != MVT::f64)
882 return Register();
883 if ((Subtarget->hasVSX())) {
884 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPI, RC: &PPC::VSFRCRegClass, Op0);
885 }
886 if ((Subtarget->hasFPU())) {
887 return fastEmitInst_r(MachineInstOpcode: PPC::FRIND, RC: &PPC::F8RCRegClass, Op0);
888 }
889 return Register();
890}
891
892Register fastEmit_ISD_FROUND_MVT_v4f32_r(MVT RetVT, Register Op0) {
893 if (RetVT.SimpleTy != MVT::v4f32)
894 return Register();
895 if ((Subtarget->hasVSX())) {
896 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPI, RC: &PPC::VSRCRegClass, Op0);
897 }
898 return Register();
899}
900
901Register fastEmit_ISD_FROUND_MVT_v2f64_r(MVT RetVT, Register Op0) {
902 if (RetVT.SimpleTy != MVT::v2f64)
903 return Register();
904 if ((Subtarget->hasVSX())) {
905 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPI, RC: &PPC::VSRCRegClass, Op0);
906 }
907 return Register();
908}
909
910Register fastEmit_ISD_FROUND_r(MVT VT, MVT RetVT, Register Op0) {
911 switch (VT.SimpleTy) {
912 case MVT::f32: return fastEmit_ISD_FROUND_MVT_f32_r(RetVT, Op0);
913 case MVT::f64: return fastEmit_ISD_FROUND_MVT_f64_r(RetVT, Op0);
914 case MVT::v4f32: return fastEmit_ISD_FROUND_MVT_v4f32_r(RetVT, Op0);
915 case MVT::v2f64: return fastEmit_ISD_FROUND_MVT_v2f64_r(RetVT, Op0);
916 default: return Register();
917 }
918}
919
920// FastEmit functions for ISD::FSQRT.
921
922Register fastEmit_ISD_FSQRT_MVT_f32_r(MVT RetVT, Register Op0) {
923 if (RetVT.SimpleTy != MVT::f32)
924 return Register();
925 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
926 return fastEmitInst_r(MachineInstOpcode: PPC::XSSQRTSP, RC: &PPC::VSSRCRegClass, Op0);
927 }
928 if ((Subtarget->hasFPU())) {
929 return fastEmitInst_r(MachineInstOpcode: PPC::FSQRTS, RC: &PPC::F4RCRegClass, Op0);
930 }
931 return Register();
932}
933
934Register fastEmit_ISD_FSQRT_MVT_f64_r(MVT RetVT, Register Op0) {
935 if (RetVT.SimpleTy != MVT::f64)
936 return Register();
937 if ((Subtarget->hasVSX())) {
938 return fastEmitInst_r(MachineInstOpcode: PPC::XSSQRTDP, RC: &PPC::VSFRCRegClass, Op0);
939 }
940 if ((Subtarget->hasFPU())) {
941 return fastEmitInst_r(MachineInstOpcode: PPC::FSQRT, RC: &PPC::F8RCRegClass, Op0);
942 }
943 return Register();
944}
945
946Register fastEmit_ISD_FSQRT_MVT_f128_r(MVT RetVT, Register Op0) {
947 if (RetVT.SimpleTy != MVT::f128)
948 return Register();
949 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
950 return fastEmitInst_r(MachineInstOpcode: PPC::XSSQRTQP, RC: &PPC::VRRCRegClass, Op0);
951 }
952 return Register();
953}
954
955Register fastEmit_ISD_FSQRT_MVT_v4f32_r(MVT RetVT, Register Op0) {
956 if (RetVT.SimpleTy != MVT::v4f32)
957 return Register();
958 if ((Subtarget->hasVSX())) {
959 return fastEmitInst_r(MachineInstOpcode: PPC::XVSQRTSP, RC: &PPC::VSRCRegClass, Op0);
960 }
961 return Register();
962}
963
964Register fastEmit_ISD_FSQRT_MVT_v2f64_r(MVT RetVT, Register Op0) {
965 if (RetVT.SimpleTy != MVT::v2f64)
966 return Register();
967 if ((Subtarget->hasVSX())) {
968 return fastEmitInst_r(MachineInstOpcode: PPC::XVSQRTDP, RC: &PPC::VSRCRegClass, Op0);
969 }
970 return Register();
971}
972
973Register fastEmit_ISD_FSQRT_r(MVT VT, MVT RetVT, Register Op0) {
974 switch (VT.SimpleTy) {
975 case MVT::f32: return fastEmit_ISD_FSQRT_MVT_f32_r(RetVT, Op0);
976 case MVT::f64: return fastEmit_ISD_FSQRT_MVT_f64_r(RetVT, Op0);
977 case MVT::f128: return fastEmit_ISD_FSQRT_MVT_f128_r(RetVT, Op0);
978 case MVT::v4f32: return fastEmit_ISD_FSQRT_MVT_v4f32_r(RetVT, Op0);
979 case MVT::v2f64: return fastEmit_ISD_FSQRT_MVT_v2f64_r(RetVT, Op0);
980 default: return Register();
981 }
982}
983
984// FastEmit functions for ISD::FTRUNC.
985
986Register fastEmit_ISD_FTRUNC_MVT_f32_r(MVT RetVT, Register Op0) {
987 if (RetVT.SimpleTy != MVT::f32)
988 return Register();
989 if ((Subtarget->hasFPU())) {
990 return fastEmitInst_r(MachineInstOpcode: PPC::FRIZS, RC: &PPC::F4RCRegClass, Op0);
991 }
992 return Register();
993}
994
995Register fastEmit_ISD_FTRUNC_MVT_f64_r(MVT RetVT, Register Op0) {
996 if (RetVT.SimpleTy != MVT::f64)
997 return Register();
998 if ((Subtarget->hasVSX())) {
999 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPIZ, RC: &PPC::VSFRCRegClass, Op0);
1000 }
1001 if ((Subtarget->hasFPU())) {
1002 return fastEmitInst_r(MachineInstOpcode: PPC::FRIZD, RC: &PPC::F8RCRegClass, Op0);
1003 }
1004 return Register();
1005}
1006
1007Register fastEmit_ISD_FTRUNC_MVT_v4f32_r(MVT RetVT, Register Op0) {
1008 if (RetVT.SimpleTy != MVT::v4f32)
1009 return Register();
1010 if ((Subtarget->hasVSX())) {
1011 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPIZ, RC: &PPC::VSRCRegClass, Op0);
1012 }
1013 if ((Subtarget->hasAltivec())) {
1014 return fastEmitInst_r(MachineInstOpcode: PPC::VRFIZ, RC: &PPC::VRRCRegClass, Op0);
1015 }
1016 return Register();
1017}
1018
1019Register fastEmit_ISD_FTRUNC_MVT_v2f64_r(MVT RetVT, Register Op0) {
1020 if (RetVT.SimpleTy != MVT::v2f64)
1021 return Register();
1022 if ((Subtarget->hasVSX())) {
1023 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPIZ, RC: &PPC::VSRCRegClass, Op0);
1024 }
1025 return Register();
1026}
1027
1028Register fastEmit_ISD_FTRUNC_r(MVT VT, MVT RetVT, Register Op0) {
1029 switch (VT.SimpleTy) {
1030 case MVT::f32: return fastEmit_ISD_FTRUNC_MVT_f32_r(RetVT, Op0);
1031 case MVT::f64: return fastEmit_ISD_FTRUNC_MVT_f64_r(RetVT, Op0);
1032 case MVT::v4f32: return fastEmit_ISD_FTRUNC_MVT_v4f32_r(RetVT, Op0);
1033 case MVT::v2f64: return fastEmit_ISD_FTRUNC_MVT_v2f64_r(RetVT, Op0);
1034 default: return Register();
1035 }
1036}
1037
1038// FastEmit functions for ISD::SCALAR_TO_VECTOR.
1039
1040Register fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(MVT RetVT, Register Op0) {
1041 if (RetVT.SimpleTy != MVT::v4i32)
1042 return Register();
1043 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
1044 return fastEmitInst_r(MachineInstOpcode: PPC::MTVSRWS, RC: &PPC::VSRCRegClass, Op0);
1045 }
1046 return Register();
1047}
1048
1049Register fastEmit_ISD_SCALAR_TO_VECTOR_MVT_f32_r(MVT RetVT, Register Op0) {
1050 if (RetVT.SimpleTy != MVT::v4f32)
1051 return Register();
1052 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX()) && (!Subtarget->isLittleEndian())) {
1053 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSPN, RC: &PPC::VSRCRegClass, Op0);
1054 }
1055 return Register();
1056}
1057
1058Register fastEmit_ISD_SCALAR_TO_VECTOR_r(MVT VT, MVT RetVT, Register Op0) {
1059 switch (VT.SimpleTy) {
1060 case MVT::i32: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_i32_r(RetVT, Op0);
1061 case MVT::f32: return fastEmit_ISD_SCALAR_TO_VECTOR_MVT_f32_r(RetVT, Op0);
1062 default: return Register();
1063 }
1064}
1065
1066// FastEmit functions for ISD::SIGN_EXTEND.
1067
1068Register fastEmit_ISD_SIGN_EXTEND_MVT_i1_MVT_i32_r(Register Op0) {
1069 if ((Subtarget->isISA3_1())) {
1070 return fastEmitInst_r(MachineInstOpcode: PPC::SETNBC, RC: &PPC::GPRCRegClass, Op0);
1071 }
1072 return Register();
1073}
1074
1075Register fastEmit_ISD_SIGN_EXTEND_MVT_i1_MVT_i64_r(Register Op0) {
1076 if ((Subtarget->isISA3_1())) {
1077 return fastEmitInst_r(MachineInstOpcode: PPC::SETNBC8, RC: &PPC::G8RCRegClass, Op0);
1078 }
1079 return Register();
1080}
1081
1082Register fastEmit_ISD_SIGN_EXTEND_MVT_i1_r(MVT RetVT, Register Op0) {
1083switch (RetVT.SimpleTy) {
1084 case MVT::i32: return fastEmit_ISD_SIGN_EXTEND_MVT_i1_MVT_i32_r(Op0);
1085 case MVT::i64: return fastEmit_ISD_SIGN_EXTEND_MVT_i1_MVT_i64_r(Op0);
1086 default: return Register();
1087}
1088}
1089
1090Register fastEmit_ISD_SIGN_EXTEND_MVT_i32_r(MVT RetVT, Register Op0) {
1091 if (RetVT.SimpleTy != MVT::i64)
1092 return Register();
1093 return fastEmitInst_r(MachineInstOpcode: PPC::EXTSW_32_64, RC: &PPC::G8RCRegClass, Op0);
1094}
1095
1096Register fastEmit_ISD_SIGN_EXTEND_r(MVT VT, MVT RetVT, Register Op0) {
1097 switch (VT.SimpleTy) {
1098 case MVT::i1: return fastEmit_ISD_SIGN_EXTEND_MVT_i1_r(RetVT, Op0);
1099 case MVT::i32: return fastEmit_ISD_SIGN_EXTEND_MVT_i32_r(RetVT, Op0);
1100 default: return Register();
1101 }
1102}
1103
1104// FastEmit functions for ISD::SINT_TO_FP.
1105
1106Register fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(Register Op0) {
1107 if ((Subtarget->hasSPE())) {
1108 return fastEmitInst_r(MachineInstOpcode: PPC::EFSCFSI, RC: &PPC::GPRCRegClass, Op0);
1109 }
1110 return Register();
1111}
1112
1113Register fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(Register Op0) {
1114 if ((Subtarget->hasSPE())) {
1115 return fastEmitInst_r(MachineInstOpcode: PPC::EFDCFSI, RC: &PPC::SPERCRegClass, Op0);
1116 }
1117 return Register();
1118}
1119
1120Register fastEmit_ISD_SINT_TO_FP_MVT_i32_r(MVT RetVT, Register Op0) {
1121switch (RetVT.SimpleTy) {
1122 case MVT::f32: return fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f32_r(Op0);
1123 case MVT::f64: return fastEmit_ISD_SINT_TO_FP_MVT_i32_MVT_f64_r(Op0);
1124 default: return Register();
1125}
1126}
1127
1128Register fastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(MVT RetVT, Register Op0) {
1129 if (RetVT.SimpleTy != MVT::v4f32)
1130 return Register();
1131 if ((Subtarget->hasVSX())) {
1132 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVSXWSP, RC: &PPC::VSRCRegClass, Op0);
1133 }
1134 if ((Subtarget->hasAltivec())) {
1135 return fastEmitInst_r(MachineInstOpcode: PPC::VCFSX_0, RC: &PPC::VRRCRegClass, Op0);
1136 }
1137 return Register();
1138}
1139
1140Register fastEmit_ISD_SINT_TO_FP_MVT_v2i64_r(MVT RetVT, Register Op0) {
1141 if (RetVT.SimpleTy != MVT::v2f64)
1142 return Register();
1143 if ((Subtarget->hasVSX())) {
1144 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVSXDDP, RC: &PPC::VSRCRegClass, Op0);
1145 }
1146 return Register();
1147}
1148
1149Register fastEmit_ISD_SINT_TO_FP_r(MVT VT, MVT RetVT, Register Op0) {
1150 switch (VT.SimpleTy) {
1151 case MVT::i32: return fastEmit_ISD_SINT_TO_FP_MVT_i32_r(RetVT, Op0);
1152 case MVT::v4i32: return fastEmit_ISD_SINT_TO_FP_MVT_v4i32_r(RetVT, Op0);
1153 case MVT::v2i64: return fastEmit_ISD_SINT_TO_FP_MVT_v2i64_r(RetVT, Op0);
1154 default: return Register();
1155 }
1156}
1157
1158// FastEmit functions for ISD::STRICT_FCEIL.
1159
1160Register fastEmit_ISD_STRICT_FCEIL_MVT_f32_r(MVT RetVT, Register Op0) {
1161 if (RetVT.SimpleTy != MVT::f32)
1162 return Register();
1163 if ((Subtarget->hasFPU())) {
1164 return fastEmitInst_r(MachineInstOpcode: PPC::FRIPS, RC: &PPC::F4RCRegClass, Op0);
1165 }
1166 return Register();
1167}
1168
1169Register fastEmit_ISD_STRICT_FCEIL_MVT_f64_r(MVT RetVT, Register Op0) {
1170 if (RetVT.SimpleTy != MVT::f64)
1171 return Register();
1172 if ((Subtarget->hasVSX())) {
1173 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPIP, RC: &PPC::VSFRCRegClass, Op0);
1174 }
1175 if ((Subtarget->hasFPU())) {
1176 return fastEmitInst_r(MachineInstOpcode: PPC::FRIPD, RC: &PPC::F8RCRegClass, Op0);
1177 }
1178 return Register();
1179}
1180
1181Register fastEmit_ISD_STRICT_FCEIL_MVT_v4f32_r(MVT RetVT, Register Op0) {
1182 if (RetVT.SimpleTy != MVT::v4f32)
1183 return Register();
1184 if ((Subtarget->hasVSX())) {
1185 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPIP, RC: &PPC::VSRCRegClass, Op0);
1186 }
1187 return Register();
1188}
1189
1190Register fastEmit_ISD_STRICT_FCEIL_MVT_v2f64_r(MVT RetVT, Register Op0) {
1191 if (RetVT.SimpleTy != MVT::v2f64)
1192 return Register();
1193 if ((Subtarget->hasVSX())) {
1194 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPIP, RC: &PPC::VSRCRegClass, Op0);
1195 }
1196 return Register();
1197}
1198
1199Register fastEmit_ISD_STRICT_FCEIL_r(MVT VT, MVT RetVT, Register Op0) {
1200 switch (VT.SimpleTy) {
1201 case MVT::f32: return fastEmit_ISD_STRICT_FCEIL_MVT_f32_r(RetVT, Op0);
1202 case MVT::f64: return fastEmit_ISD_STRICT_FCEIL_MVT_f64_r(RetVT, Op0);
1203 case MVT::v4f32: return fastEmit_ISD_STRICT_FCEIL_MVT_v4f32_r(RetVT, Op0);
1204 case MVT::v2f64: return fastEmit_ISD_STRICT_FCEIL_MVT_v2f64_r(RetVT, Op0);
1205 default: return Register();
1206 }
1207}
1208
1209// FastEmit functions for ISD::STRICT_FFLOOR.
1210
1211Register fastEmit_ISD_STRICT_FFLOOR_MVT_f32_r(MVT RetVT, Register Op0) {
1212 if (RetVT.SimpleTy != MVT::f32)
1213 return Register();
1214 if ((Subtarget->hasFPU())) {
1215 return fastEmitInst_r(MachineInstOpcode: PPC::FRIMS, RC: &PPC::F4RCRegClass, Op0);
1216 }
1217 return Register();
1218}
1219
1220Register fastEmit_ISD_STRICT_FFLOOR_MVT_f64_r(MVT RetVT, Register Op0) {
1221 if (RetVT.SimpleTy != MVT::f64)
1222 return Register();
1223 if ((Subtarget->hasVSX())) {
1224 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPIM, RC: &PPC::VSFRCRegClass, Op0);
1225 }
1226 if ((Subtarget->hasFPU())) {
1227 return fastEmitInst_r(MachineInstOpcode: PPC::FRIMD, RC: &PPC::F8RCRegClass, Op0);
1228 }
1229 return Register();
1230}
1231
1232Register fastEmit_ISD_STRICT_FFLOOR_MVT_v4f32_r(MVT RetVT, Register Op0) {
1233 if (RetVT.SimpleTy != MVT::v4f32)
1234 return Register();
1235 if ((Subtarget->hasVSX())) {
1236 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPIM, RC: &PPC::VSRCRegClass, Op0);
1237 }
1238 return Register();
1239}
1240
1241Register fastEmit_ISD_STRICT_FFLOOR_MVT_v2f64_r(MVT RetVT, Register Op0) {
1242 if (RetVT.SimpleTy != MVT::v2f64)
1243 return Register();
1244 if ((Subtarget->hasVSX())) {
1245 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPIM, RC: &PPC::VSRCRegClass, Op0);
1246 }
1247 return Register();
1248}
1249
1250Register fastEmit_ISD_STRICT_FFLOOR_r(MVT VT, MVT RetVT, Register Op0) {
1251 switch (VT.SimpleTy) {
1252 case MVT::f32: return fastEmit_ISD_STRICT_FFLOOR_MVT_f32_r(RetVT, Op0);
1253 case MVT::f64: return fastEmit_ISD_STRICT_FFLOOR_MVT_f64_r(RetVT, Op0);
1254 case MVT::v4f32: return fastEmit_ISD_STRICT_FFLOOR_MVT_v4f32_r(RetVT, Op0);
1255 case MVT::v2f64: return fastEmit_ISD_STRICT_FFLOOR_MVT_v2f64_r(RetVT, Op0);
1256 default: return Register();
1257 }
1258}
1259
1260// FastEmit functions for ISD::STRICT_FNEARBYINT.
1261
1262Register fastEmit_ISD_STRICT_FNEARBYINT_MVT_f64_r(MVT RetVT, Register Op0) {
1263 if (RetVT.SimpleTy != MVT::f64)
1264 return Register();
1265 if ((Subtarget->hasVSX())) {
1266 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPIC, RC: &PPC::VSFRCRegClass, Op0);
1267 }
1268 return Register();
1269}
1270
1271Register fastEmit_ISD_STRICT_FNEARBYINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
1272 if (RetVT.SimpleTy != MVT::v4f32)
1273 return Register();
1274 if ((Subtarget->hasVSX())) {
1275 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPIC, RC: &PPC::VSRCRegClass, Op0);
1276 }
1277 return Register();
1278}
1279
1280Register fastEmit_ISD_STRICT_FNEARBYINT_MVT_v2f64_r(MVT RetVT, Register Op0) {
1281 if (RetVT.SimpleTy != MVT::v2f64)
1282 return Register();
1283 if ((Subtarget->hasVSX())) {
1284 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPIC, RC: &PPC::VSRCRegClass, Op0);
1285 }
1286 return Register();
1287}
1288
1289Register fastEmit_ISD_STRICT_FNEARBYINT_r(MVT VT, MVT RetVT, Register Op0) {
1290 switch (VT.SimpleTy) {
1291 case MVT::f64: return fastEmit_ISD_STRICT_FNEARBYINT_MVT_f64_r(RetVT, Op0);
1292 case MVT::v4f32: return fastEmit_ISD_STRICT_FNEARBYINT_MVT_v4f32_r(RetVT, Op0);
1293 case MVT::v2f64: return fastEmit_ISD_STRICT_FNEARBYINT_MVT_v2f64_r(RetVT, Op0);
1294 default: return Register();
1295 }
1296}
1297
1298// FastEmit functions for ISD::STRICT_FP_EXTEND.
1299
1300Register fastEmit_ISD_STRICT_FP_EXTEND_MVT_f32_r(MVT RetVT, Register Op0) {
1301 if (RetVT.SimpleTy != MVT::f64)
1302 return Register();
1303 if ((Subtarget->hasSPE())) {
1304 return fastEmitInst_r(MachineInstOpcode: PPC::EFDCFS, RC: &PPC::SPERCRegClass, Op0);
1305 }
1306 return Register();
1307}
1308
1309Register fastEmit_ISD_STRICT_FP_EXTEND_MVT_f64_r(MVT RetVT, Register Op0) {
1310 if (RetVT.SimpleTy != MVT::f128)
1311 return Register();
1312 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
1313 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPQP, RC: &PPC::VRRCRegClass, Op0);
1314 }
1315 return Register();
1316}
1317
1318Register fastEmit_ISD_STRICT_FP_EXTEND_r(MVT VT, MVT RetVT, Register Op0) {
1319 switch (VT.SimpleTy) {
1320 case MVT::f32: return fastEmit_ISD_STRICT_FP_EXTEND_MVT_f32_r(RetVT, Op0);
1321 case MVT::f64: return fastEmit_ISD_STRICT_FP_EXTEND_MVT_f64_r(RetVT, Op0);
1322 default: return Register();
1323 }
1324}
1325
1326// FastEmit functions for ISD::STRICT_FP_ROUND.
1327
1328Register fastEmit_ISD_STRICT_FP_ROUND_MVT_f64_r(MVT RetVT, Register Op0) {
1329 if (RetVT.SimpleTy != MVT::f32)
1330 return Register();
1331 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
1332 return fastEmitInst_r(MachineInstOpcode: PPC::XSRSP, RC: &PPC::VSSRCRegClass, Op0);
1333 }
1334 if ((Subtarget->hasSPE())) {
1335 return fastEmitInst_r(MachineInstOpcode: PPC::EFSCFD, RC: &PPC::GPRCRegClass, Op0);
1336 }
1337 if ((Subtarget->hasFPU())) {
1338 return fastEmitInst_r(MachineInstOpcode: PPC::FRSP, RC: &PPC::F4RCRegClass, Op0);
1339 }
1340 return Register();
1341}
1342
1343Register fastEmit_ISD_STRICT_FP_ROUND_MVT_f128_r(MVT RetVT, Register Op0) {
1344 if (RetVT.SimpleTy != MVT::f64)
1345 return Register();
1346 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
1347 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVQPDP, RC: &PPC::VFRCRegClass, Op0);
1348 }
1349 return Register();
1350}
1351
1352Register fastEmit_ISD_STRICT_FP_ROUND_r(MVT VT, MVT RetVT, Register Op0) {
1353 switch (VT.SimpleTy) {
1354 case MVT::f64: return fastEmit_ISD_STRICT_FP_ROUND_MVT_f64_r(RetVT, Op0);
1355 case MVT::f128: return fastEmit_ISD_STRICT_FP_ROUND_MVT_f128_r(RetVT, Op0);
1356 default: return Register();
1357 }
1358}
1359
1360// FastEmit functions for ISD::STRICT_FP_TO_SINT.
1361
1362Register fastEmit_ISD_STRICT_FP_TO_SINT_MVT_f32_r(MVT RetVT, Register Op0) {
1363 if (RetVT.SimpleTy != MVT::i32)
1364 return Register();
1365 if ((Subtarget->hasSPE())) {
1366 return fastEmitInst_r(MachineInstOpcode: PPC::EFSCTSIZ, RC: &PPC::GPRCRegClass, Op0);
1367 }
1368 return Register();
1369}
1370
1371Register fastEmit_ISD_STRICT_FP_TO_SINT_MVT_f64_r(MVT RetVT, Register Op0) {
1372 if (RetVT.SimpleTy != MVT::i32)
1373 return Register();
1374 if ((Subtarget->hasSPE())) {
1375 return fastEmitInst_r(MachineInstOpcode: PPC::EFDCTSIZ, RC: &PPC::GPRCRegClass, Op0);
1376 }
1377 return Register();
1378}
1379
1380Register fastEmit_ISD_STRICT_FP_TO_SINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
1381 if (RetVT.SimpleTy != MVT::v4i32)
1382 return Register();
1383 if ((Subtarget->hasVSX())) {
1384 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVSPSXWS, RC: &PPC::VSRCRegClass, Op0);
1385 }
1386 return Register();
1387}
1388
1389Register fastEmit_ISD_STRICT_FP_TO_SINT_MVT_v2f64_r(MVT RetVT, Register Op0) {
1390 if (RetVT.SimpleTy != MVT::v2i64)
1391 return Register();
1392 if ((Subtarget->hasVSX())) {
1393 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVDPSXDS, RC: &PPC::VSRCRegClass, Op0);
1394 }
1395 return Register();
1396}
1397
1398Register fastEmit_ISD_STRICT_FP_TO_SINT_r(MVT VT, MVT RetVT, Register Op0) {
1399 switch (VT.SimpleTy) {
1400 case MVT::f32: return fastEmit_ISD_STRICT_FP_TO_SINT_MVT_f32_r(RetVT, Op0);
1401 case MVT::f64: return fastEmit_ISD_STRICT_FP_TO_SINT_MVT_f64_r(RetVT, Op0);
1402 case MVT::v4f32: return fastEmit_ISD_STRICT_FP_TO_SINT_MVT_v4f32_r(RetVT, Op0);
1403 case MVT::v2f64: return fastEmit_ISD_STRICT_FP_TO_SINT_MVT_v2f64_r(RetVT, Op0);
1404 default: return Register();
1405 }
1406}
1407
1408// FastEmit functions for ISD::STRICT_FP_TO_UINT.
1409
1410Register fastEmit_ISD_STRICT_FP_TO_UINT_MVT_f32_r(MVT RetVT, Register Op0) {
1411 if (RetVT.SimpleTy != MVT::i32)
1412 return Register();
1413 if ((Subtarget->hasSPE())) {
1414 return fastEmitInst_r(MachineInstOpcode: PPC::EFSCTUIZ, RC: &PPC::GPRCRegClass, Op0);
1415 }
1416 return Register();
1417}
1418
1419Register fastEmit_ISD_STRICT_FP_TO_UINT_MVT_f64_r(MVT RetVT, Register Op0) {
1420 if (RetVT.SimpleTy != MVT::i32)
1421 return Register();
1422 if ((Subtarget->hasSPE())) {
1423 return fastEmitInst_r(MachineInstOpcode: PPC::EFDCTUIZ, RC: &PPC::GPRCRegClass, Op0);
1424 }
1425 return Register();
1426}
1427
1428Register fastEmit_ISD_STRICT_FP_TO_UINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
1429 if (RetVT.SimpleTy != MVT::v4i32)
1430 return Register();
1431 if ((Subtarget->hasVSX())) {
1432 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVSPUXWS, RC: &PPC::VSRCRegClass, Op0);
1433 }
1434 return Register();
1435}
1436
1437Register fastEmit_ISD_STRICT_FP_TO_UINT_MVT_v2f64_r(MVT RetVT, Register Op0) {
1438 if (RetVT.SimpleTy != MVT::v2i64)
1439 return Register();
1440 if ((Subtarget->hasVSX())) {
1441 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVDPUXDS, RC: &PPC::VSRCRegClass, Op0);
1442 }
1443 return Register();
1444}
1445
1446Register fastEmit_ISD_STRICT_FP_TO_UINT_r(MVT VT, MVT RetVT, Register Op0) {
1447 switch (VT.SimpleTy) {
1448 case MVT::f32: return fastEmit_ISD_STRICT_FP_TO_UINT_MVT_f32_r(RetVT, Op0);
1449 case MVT::f64: return fastEmit_ISD_STRICT_FP_TO_UINT_MVT_f64_r(RetVT, Op0);
1450 case MVT::v4f32: return fastEmit_ISD_STRICT_FP_TO_UINT_MVT_v4f32_r(RetVT, Op0);
1451 case MVT::v2f64: return fastEmit_ISD_STRICT_FP_TO_UINT_MVT_v2f64_r(RetVT, Op0);
1452 default: return Register();
1453 }
1454}
1455
1456// FastEmit functions for ISD::STRICT_FRINT.
1457
1458Register fastEmit_ISD_STRICT_FRINT_MVT_f64_r(MVT RetVT, Register Op0) {
1459 if (RetVT.SimpleTy != MVT::f64)
1460 return Register();
1461 if ((Subtarget->hasVSX())) {
1462 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPIC, RC: &PPC::VSFRCRegClass, Op0);
1463 }
1464 return Register();
1465}
1466
1467Register fastEmit_ISD_STRICT_FRINT_MVT_v4f32_r(MVT RetVT, Register Op0) {
1468 if (RetVT.SimpleTy != MVT::v4f32)
1469 return Register();
1470 if ((Subtarget->hasVSX())) {
1471 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPIC, RC: &PPC::VSRCRegClass, Op0);
1472 }
1473 return Register();
1474}
1475
1476Register fastEmit_ISD_STRICT_FRINT_MVT_v2f64_r(MVT RetVT, Register Op0) {
1477 if (RetVT.SimpleTy != MVT::v2f64)
1478 return Register();
1479 if ((Subtarget->hasVSX())) {
1480 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPIC, RC: &PPC::VSRCRegClass, Op0);
1481 }
1482 return Register();
1483}
1484
1485Register fastEmit_ISD_STRICT_FRINT_r(MVT VT, MVT RetVT, Register Op0) {
1486 switch (VT.SimpleTy) {
1487 case MVT::f64: return fastEmit_ISD_STRICT_FRINT_MVT_f64_r(RetVT, Op0);
1488 case MVT::v4f32: return fastEmit_ISD_STRICT_FRINT_MVT_v4f32_r(RetVT, Op0);
1489 case MVT::v2f64: return fastEmit_ISD_STRICT_FRINT_MVT_v2f64_r(RetVT, Op0);
1490 default: return Register();
1491 }
1492}
1493
1494// FastEmit functions for ISD::STRICT_FROUND.
1495
1496Register fastEmit_ISD_STRICT_FROUND_MVT_f32_r(MVT RetVT, Register Op0) {
1497 if (RetVT.SimpleTy != MVT::f32)
1498 return Register();
1499 if ((Subtarget->hasFPU())) {
1500 return fastEmitInst_r(MachineInstOpcode: PPC::FRINS, RC: &PPC::F4RCRegClass, Op0);
1501 }
1502 return Register();
1503}
1504
1505Register fastEmit_ISD_STRICT_FROUND_MVT_f64_r(MVT RetVT, Register Op0) {
1506 if (RetVT.SimpleTy != MVT::f64)
1507 return Register();
1508 if ((Subtarget->hasVSX())) {
1509 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPI, RC: &PPC::VSFRCRegClass, Op0);
1510 }
1511 if ((Subtarget->hasFPU())) {
1512 return fastEmitInst_r(MachineInstOpcode: PPC::FRIND, RC: &PPC::F8RCRegClass, Op0);
1513 }
1514 return Register();
1515}
1516
1517Register fastEmit_ISD_STRICT_FROUND_MVT_v4f32_r(MVT RetVT, Register Op0) {
1518 if (RetVT.SimpleTy != MVT::v4f32)
1519 return Register();
1520 if ((Subtarget->hasVSX())) {
1521 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPI, RC: &PPC::VSRCRegClass, Op0);
1522 }
1523 return Register();
1524}
1525
1526Register fastEmit_ISD_STRICT_FROUND_MVT_v2f64_r(MVT RetVT, Register Op0) {
1527 if (RetVT.SimpleTy != MVT::v2f64)
1528 return Register();
1529 if ((Subtarget->hasVSX())) {
1530 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPI, RC: &PPC::VSRCRegClass, Op0);
1531 }
1532 return Register();
1533}
1534
1535Register fastEmit_ISD_STRICT_FROUND_r(MVT VT, MVT RetVT, Register Op0) {
1536 switch (VT.SimpleTy) {
1537 case MVT::f32: return fastEmit_ISD_STRICT_FROUND_MVT_f32_r(RetVT, Op0);
1538 case MVT::f64: return fastEmit_ISD_STRICT_FROUND_MVT_f64_r(RetVT, Op0);
1539 case MVT::v4f32: return fastEmit_ISD_STRICT_FROUND_MVT_v4f32_r(RetVT, Op0);
1540 case MVT::v2f64: return fastEmit_ISD_STRICT_FROUND_MVT_v2f64_r(RetVT, Op0);
1541 default: return Register();
1542 }
1543}
1544
1545// FastEmit functions for ISD::STRICT_FSQRT.
1546
1547Register fastEmit_ISD_STRICT_FSQRT_MVT_f32_r(MVT RetVT, Register Op0) {
1548 if (RetVT.SimpleTy != MVT::f32)
1549 return Register();
1550 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
1551 return fastEmitInst_r(MachineInstOpcode: PPC::XSSQRTSP, RC: &PPC::VSSRCRegClass, Op0);
1552 }
1553 if ((Subtarget->hasFPU())) {
1554 return fastEmitInst_r(MachineInstOpcode: PPC::FSQRTS, RC: &PPC::F4RCRegClass, Op0);
1555 }
1556 return Register();
1557}
1558
1559Register fastEmit_ISD_STRICT_FSQRT_MVT_f64_r(MVT RetVT, Register Op0) {
1560 if (RetVT.SimpleTy != MVT::f64)
1561 return Register();
1562 if ((Subtarget->hasVSX())) {
1563 return fastEmitInst_r(MachineInstOpcode: PPC::XSSQRTDP, RC: &PPC::VSFRCRegClass, Op0);
1564 }
1565 if ((Subtarget->hasFPU())) {
1566 return fastEmitInst_r(MachineInstOpcode: PPC::FSQRT, RC: &PPC::F8RCRegClass, Op0);
1567 }
1568 return Register();
1569}
1570
1571Register fastEmit_ISD_STRICT_FSQRT_MVT_f128_r(MVT RetVT, Register Op0) {
1572 if (RetVT.SimpleTy != MVT::f128)
1573 return Register();
1574 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
1575 return fastEmitInst_r(MachineInstOpcode: PPC::XSSQRTQP, RC: &PPC::VRRCRegClass, Op0);
1576 }
1577 return Register();
1578}
1579
1580Register fastEmit_ISD_STRICT_FSQRT_MVT_v4f32_r(MVT RetVT, Register Op0) {
1581 if (RetVT.SimpleTy != MVT::v4f32)
1582 return Register();
1583 if ((Subtarget->hasVSX())) {
1584 return fastEmitInst_r(MachineInstOpcode: PPC::XVSQRTSP, RC: &PPC::VSRCRegClass, Op0);
1585 }
1586 return Register();
1587}
1588
1589Register fastEmit_ISD_STRICT_FSQRT_MVT_v2f64_r(MVT RetVT, Register Op0) {
1590 if (RetVT.SimpleTy != MVT::v2f64)
1591 return Register();
1592 if ((Subtarget->hasVSX())) {
1593 return fastEmitInst_r(MachineInstOpcode: PPC::XVSQRTDP, RC: &PPC::VSRCRegClass, Op0);
1594 }
1595 return Register();
1596}
1597
1598Register fastEmit_ISD_STRICT_FSQRT_r(MVT VT, MVT RetVT, Register Op0) {
1599 switch (VT.SimpleTy) {
1600 case MVT::f32: return fastEmit_ISD_STRICT_FSQRT_MVT_f32_r(RetVT, Op0);
1601 case MVT::f64: return fastEmit_ISD_STRICT_FSQRT_MVT_f64_r(RetVT, Op0);
1602 case MVT::f128: return fastEmit_ISD_STRICT_FSQRT_MVT_f128_r(RetVT, Op0);
1603 case MVT::v4f32: return fastEmit_ISD_STRICT_FSQRT_MVT_v4f32_r(RetVT, Op0);
1604 case MVT::v2f64: return fastEmit_ISD_STRICT_FSQRT_MVT_v2f64_r(RetVT, Op0);
1605 default: return Register();
1606 }
1607}
1608
1609// FastEmit functions for ISD::STRICT_FTRUNC.
1610
1611Register fastEmit_ISD_STRICT_FTRUNC_MVT_f32_r(MVT RetVT, Register Op0) {
1612 if (RetVT.SimpleTy != MVT::f32)
1613 return Register();
1614 if ((Subtarget->hasFPU())) {
1615 return fastEmitInst_r(MachineInstOpcode: PPC::FRIZS, RC: &PPC::F4RCRegClass, Op0);
1616 }
1617 return Register();
1618}
1619
1620Register fastEmit_ISD_STRICT_FTRUNC_MVT_f64_r(MVT RetVT, Register Op0) {
1621 if (RetVT.SimpleTy != MVT::f64)
1622 return Register();
1623 if ((Subtarget->hasVSX())) {
1624 return fastEmitInst_r(MachineInstOpcode: PPC::XSRDPIZ, RC: &PPC::VSFRCRegClass, Op0);
1625 }
1626 if ((Subtarget->hasFPU())) {
1627 return fastEmitInst_r(MachineInstOpcode: PPC::FRIZD, RC: &PPC::F8RCRegClass, Op0);
1628 }
1629 return Register();
1630}
1631
1632Register fastEmit_ISD_STRICT_FTRUNC_MVT_v4f32_r(MVT RetVT, Register Op0) {
1633 if (RetVT.SimpleTy != MVT::v4f32)
1634 return Register();
1635 if ((Subtarget->hasVSX())) {
1636 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSPIZ, RC: &PPC::VSRCRegClass, Op0);
1637 }
1638 return Register();
1639}
1640
1641Register fastEmit_ISD_STRICT_FTRUNC_MVT_v2f64_r(MVT RetVT, Register Op0) {
1642 if (RetVT.SimpleTy != MVT::v2f64)
1643 return Register();
1644 if ((Subtarget->hasVSX())) {
1645 return fastEmitInst_r(MachineInstOpcode: PPC::XVRDPIZ, RC: &PPC::VSRCRegClass, Op0);
1646 }
1647 return Register();
1648}
1649
1650Register fastEmit_ISD_STRICT_FTRUNC_r(MVT VT, MVT RetVT, Register Op0) {
1651 switch (VT.SimpleTy) {
1652 case MVT::f32: return fastEmit_ISD_STRICT_FTRUNC_MVT_f32_r(RetVT, Op0);
1653 case MVT::f64: return fastEmit_ISD_STRICT_FTRUNC_MVT_f64_r(RetVT, Op0);
1654 case MVT::v4f32: return fastEmit_ISD_STRICT_FTRUNC_MVT_v4f32_r(RetVT, Op0);
1655 case MVT::v2f64: return fastEmit_ISD_STRICT_FTRUNC_MVT_v2f64_r(RetVT, Op0);
1656 default: return Register();
1657 }
1658}
1659
1660// FastEmit functions for ISD::STRICT_SINT_TO_FP.
1661
1662Register fastEmit_ISD_STRICT_SINT_TO_FP_MVT_i32_MVT_f32_r(Register Op0) {
1663 if ((Subtarget->hasSPE())) {
1664 return fastEmitInst_r(MachineInstOpcode: PPC::EFSCFSI, RC: &PPC::GPRCRegClass, Op0);
1665 }
1666 return Register();
1667}
1668
1669Register fastEmit_ISD_STRICT_SINT_TO_FP_MVT_i32_MVT_f64_r(Register Op0) {
1670 if ((Subtarget->hasSPE())) {
1671 return fastEmitInst_r(MachineInstOpcode: PPC::EFDCFSI, RC: &PPC::SPERCRegClass, Op0);
1672 }
1673 return Register();
1674}
1675
1676Register fastEmit_ISD_STRICT_SINT_TO_FP_MVT_i32_r(MVT RetVT, Register Op0) {
1677switch (RetVT.SimpleTy) {
1678 case MVT::f32: return fastEmit_ISD_STRICT_SINT_TO_FP_MVT_i32_MVT_f32_r(Op0);
1679 case MVT::f64: return fastEmit_ISD_STRICT_SINT_TO_FP_MVT_i32_MVT_f64_r(Op0);
1680 default: return Register();
1681}
1682}
1683
1684Register fastEmit_ISD_STRICT_SINT_TO_FP_MVT_v4i32_r(MVT RetVT, Register Op0) {
1685 if (RetVT.SimpleTy != MVT::v4f32)
1686 return Register();
1687 if ((Subtarget->hasVSX())) {
1688 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVSXWSP, RC: &PPC::VSRCRegClass, Op0);
1689 }
1690 return Register();
1691}
1692
1693Register fastEmit_ISD_STRICT_SINT_TO_FP_MVT_v2i64_r(MVT RetVT, Register Op0) {
1694 if (RetVT.SimpleTy != MVT::v2f64)
1695 return Register();
1696 if ((Subtarget->hasVSX())) {
1697 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVSXDDP, RC: &PPC::VSRCRegClass, Op0);
1698 }
1699 return Register();
1700}
1701
1702Register fastEmit_ISD_STRICT_SINT_TO_FP_r(MVT VT, MVT RetVT, Register Op0) {
1703 switch (VT.SimpleTy) {
1704 case MVT::i32: return fastEmit_ISD_STRICT_SINT_TO_FP_MVT_i32_r(RetVT, Op0);
1705 case MVT::v4i32: return fastEmit_ISD_STRICT_SINT_TO_FP_MVT_v4i32_r(RetVT, Op0);
1706 case MVT::v2i64: return fastEmit_ISD_STRICT_SINT_TO_FP_MVT_v2i64_r(RetVT, Op0);
1707 default: return Register();
1708 }
1709}
1710
1711// FastEmit functions for ISD::STRICT_UINT_TO_FP.
1712
1713Register fastEmit_ISD_STRICT_UINT_TO_FP_MVT_i32_MVT_f32_r(Register Op0) {
1714 if ((Subtarget->hasSPE())) {
1715 return fastEmitInst_r(MachineInstOpcode: PPC::EFSCFUI, RC: &PPC::GPRCRegClass, Op0);
1716 }
1717 return Register();
1718}
1719
1720Register fastEmit_ISD_STRICT_UINT_TO_FP_MVT_i32_MVT_f64_r(Register Op0) {
1721 if ((Subtarget->hasSPE())) {
1722 return fastEmitInst_r(MachineInstOpcode: PPC::EFDCFUI, RC: &PPC::SPERCRegClass, Op0);
1723 }
1724 return Register();
1725}
1726
1727Register fastEmit_ISD_STRICT_UINT_TO_FP_MVT_i32_r(MVT RetVT, Register Op0) {
1728switch (RetVT.SimpleTy) {
1729 case MVT::f32: return fastEmit_ISD_STRICT_UINT_TO_FP_MVT_i32_MVT_f32_r(Op0);
1730 case MVT::f64: return fastEmit_ISD_STRICT_UINT_TO_FP_MVT_i32_MVT_f64_r(Op0);
1731 default: return Register();
1732}
1733}
1734
1735Register fastEmit_ISD_STRICT_UINT_TO_FP_MVT_v4i32_r(MVT RetVT, Register Op0) {
1736 if (RetVT.SimpleTy != MVT::v4f32)
1737 return Register();
1738 if ((Subtarget->hasVSX())) {
1739 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVUXWSP, RC: &PPC::VSRCRegClass, Op0);
1740 }
1741 return Register();
1742}
1743
1744Register fastEmit_ISD_STRICT_UINT_TO_FP_MVT_v2i64_r(MVT RetVT, Register Op0) {
1745 if (RetVT.SimpleTy != MVT::v2f64)
1746 return Register();
1747 if ((Subtarget->hasVSX())) {
1748 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVUXDDP, RC: &PPC::VSRCRegClass, Op0);
1749 }
1750 return Register();
1751}
1752
1753Register fastEmit_ISD_STRICT_UINT_TO_FP_r(MVT VT, MVT RetVT, Register Op0) {
1754 switch (VT.SimpleTy) {
1755 case MVT::i32: return fastEmit_ISD_STRICT_UINT_TO_FP_MVT_i32_r(RetVT, Op0);
1756 case MVT::v4i32: return fastEmit_ISD_STRICT_UINT_TO_FP_MVT_v4i32_r(RetVT, Op0);
1757 case MVT::v2i64: return fastEmit_ISD_STRICT_UINT_TO_FP_MVT_v2i64_r(RetVT, Op0);
1758 default: return Register();
1759 }
1760}
1761
1762// FastEmit functions for ISD::TRUNCATE.
1763
1764Register fastEmit_ISD_TRUNCATE_MVT_i32_r(MVT RetVT, Register Op0) {
1765 if (RetVT.SimpleTy != MVT::i1)
1766 return Register();
1767 return fastEmitInst_r(MachineInstOpcode: PPC::ANDI_rec_1_GT_BIT, RC: &PPC::CRBITRCRegClass, Op0);
1768}
1769
1770Register fastEmit_ISD_TRUNCATE_MVT_i64_r(MVT RetVT, Register Op0) {
1771 if (RetVT.SimpleTy != MVT::i1)
1772 return Register();
1773 return fastEmitInst_r(MachineInstOpcode: PPC::ANDI_rec_1_GT_BIT8, RC: &PPC::CRBITRCRegClass, Op0);
1774}
1775
1776Register fastEmit_ISD_TRUNCATE_r(MVT VT, MVT RetVT, Register Op0) {
1777 switch (VT.SimpleTy) {
1778 case MVT::i32: return fastEmit_ISD_TRUNCATE_MVT_i32_r(RetVT, Op0);
1779 case MVT::i64: return fastEmit_ISD_TRUNCATE_MVT_i64_r(RetVT, Op0);
1780 default: return Register();
1781 }
1782}
1783
1784// FastEmit functions for ISD::UINT_TO_FP.
1785
1786Register fastEmit_ISD_UINT_TO_FP_MVT_i32_MVT_f32_r(Register Op0) {
1787 if ((Subtarget->hasSPE())) {
1788 return fastEmitInst_r(MachineInstOpcode: PPC::EFSCFUI, RC: &PPC::GPRCRegClass, Op0);
1789 }
1790 return Register();
1791}
1792
1793Register fastEmit_ISD_UINT_TO_FP_MVT_i32_MVT_f64_r(Register Op0) {
1794 if ((Subtarget->hasSPE())) {
1795 return fastEmitInst_r(MachineInstOpcode: PPC::EFDCFUI, RC: &PPC::SPERCRegClass, Op0);
1796 }
1797 return Register();
1798}
1799
1800Register fastEmit_ISD_UINT_TO_FP_MVT_i32_r(MVT RetVT, Register Op0) {
1801switch (RetVT.SimpleTy) {
1802 case MVT::f32: return fastEmit_ISD_UINT_TO_FP_MVT_i32_MVT_f32_r(Op0);
1803 case MVT::f64: return fastEmit_ISD_UINT_TO_FP_MVT_i32_MVT_f64_r(Op0);
1804 default: return Register();
1805}
1806}
1807
1808Register fastEmit_ISD_UINT_TO_FP_MVT_v4i32_r(MVT RetVT, Register Op0) {
1809 if (RetVT.SimpleTy != MVT::v4f32)
1810 return Register();
1811 if ((Subtarget->hasVSX())) {
1812 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVUXWSP, RC: &PPC::VSRCRegClass, Op0);
1813 }
1814 if ((Subtarget->hasAltivec())) {
1815 return fastEmitInst_r(MachineInstOpcode: PPC::VCFUX_0, RC: &PPC::VRRCRegClass, Op0);
1816 }
1817 return Register();
1818}
1819
1820Register fastEmit_ISD_UINT_TO_FP_MVT_v2i64_r(MVT RetVT, Register Op0) {
1821 if (RetVT.SimpleTy != MVT::v2f64)
1822 return Register();
1823 if ((Subtarget->hasVSX())) {
1824 return fastEmitInst_r(MachineInstOpcode: PPC::XVCVUXDDP, RC: &PPC::VSRCRegClass, Op0);
1825 }
1826 return Register();
1827}
1828
1829Register fastEmit_ISD_UINT_TO_FP_r(MVT VT, MVT RetVT, Register Op0) {
1830 switch (VT.SimpleTy) {
1831 case MVT::i32: return fastEmit_ISD_UINT_TO_FP_MVT_i32_r(RetVT, Op0);
1832 case MVT::v4i32: return fastEmit_ISD_UINT_TO_FP_MVT_v4i32_r(RetVT, Op0);
1833 case MVT::v2i64: return fastEmit_ISD_UINT_TO_FP_MVT_v2i64_r(RetVT, Op0);
1834 default: return Register();
1835 }
1836}
1837
1838// FastEmit functions for ISD::ZERO_EXTEND.
1839
1840Register fastEmit_ISD_ZERO_EXTEND_MVT_i1_MVT_i32_r(Register Op0) {
1841 if ((Subtarget->isISA3_1())) {
1842 return fastEmitInst_r(MachineInstOpcode: PPC::SETBC, RC: &PPC::GPRCRegClass, Op0);
1843 }
1844 return Register();
1845}
1846
1847Register fastEmit_ISD_ZERO_EXTEND_MVT_i1_MVT_i64_r(Register Op0) {
1848 if ((Subtarget->isISA3_1())) {
1849 return fastEmitInst_r(MachineInstOpcode: PPC::SETBC8, RC: &PPC::G8RCRegClass, Op0);
1850 }
1851 return Register();
1852}
1853
1854Register fastEmit_ISD_ZERO_EXTEND_MVT_i1_r(MVT RetVT, Register Op0) {
1855switch (RetVT.SimpleTy) {
1856 case MVT::i32: return fastEmit_ISD_ZERO_EXTEND_MVT_i1_MVT_i32_r(Op0);
1857 case MVT::i64: return fastEmit_ISD_ZERO_EXTEND_MVT_i1_MVT_i64_r(Op0);
1858 default: return Register();
1859}
1860}
1861
1862Register fastEmit_ISD_ZERO_EXTEND_r(MVT VT, MVT RetVT, Register Op0) {
1863 switch (VT.SimpleTy) {
1864 case MVT::i1: return fastEmit_ISD_ZERO_EXTEND_MVT_i1_r(RetVT, Op0);
1865 default: return Register();
1866 }
1867}
1868
1869// FastEmit functions for PPCISD::FCFID.
1870
1871Register fastEmit_PPCISD_FCFID_MVT_f64_r(MVT RetVT, Register Op0) {
1872 if (RetVT.SimpleTy != MVT::f64)
1873 return Register();
1874 if ((Subtarget->hasVSX())) {
1875 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVSXDDP, RC: &PPC::VSFRCRegClass, Op0);
1876 }
1877 return fastEmitInst_r(MachineInstOpcode: PPC::FCFID, RC: &PPC::F8RCRegClass, Op0);
1878}
1879
1880Register fastEmit_PPCISD_FCFID_r(MVT VT, MVT RetVT, Register Op0) {
1881 switch (VT.SimpleTy) {
1882 case MVT::f64: return fastEmit_PPCISD_FCFID_MVT_f64_r(RetVT, Op0);
1883 default: return Register();
1884 }
1885}
1886
1887// FastEmit functions for PPCISD::FCFIDS.
1888
1889Register fastEmit_PPCISD_FCFIDS_MVT_f64_r(MVT RetVT, Register Op0) {
1890 if (RetVT.SimpleTy != MVT::f32)
1891 return Register();
1892 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
1893 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVSXDSP, RC: &PPC::VSSRCRegClass, Op0);
1894 }
1895 return fastEmitInst_r(MachineInstOpcode: PPC::FCFIDS, RC: &PPC::F4RCRegClass, Op0);
1896}
1897
1898Register fastEmit_PPCISD_FCFIDS_r(MVT VT, MVT RetVT, Register Op0) {
1899 switch (VT.SimpleTy) {
1900 case MVT::f64: return fastEmit_PPCISD_FCFIDS_MVT_f64_r(RetVT, Op0);
1901 default: return Register();
1902 }
1903}
1904
1905// FastEmit functions for PPCISD::FCFIDU.
1906
1907Register fastEmit_PPCISD_FCFIDU_MVT_f64_r(MVT RetVT, Register Op0) {
1908 if (RetVT.SimpleTy != MVT::f64)
1909 return Register();
1910 if ((Subtarget->hasVSX())) {
1911 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVUXDDP, RC: &PPC::VSFRCRegClass, Op0);
1912 }
1913 return fastEmitInst_r(MachineInstOpcode: PPC::FCFIDU, RC: &PPC::F8RCRegClass, Op0);
1914}
1915
1916Register fastEmit_PPCISD_FCFIDU_r(MVT VT, MVT RetVT, Register Op0) {
1917 switch (VT.SimpleTy) {
1918 case MVT::f64: return fastEmit_PPCISD_FCFIDU_MVT_f64_r(RetVT, Op0);
1919 default: return Register();
1920 }
1921}
1922
1923// FastEmit functions for PPCISD::FCFIDUS.
1924
1925Register fastEmit_PPCISD_FCFIDUS_MVT_f64_r(MVT RetVT, Register Op0) {
1926 if (RetVT.SimpleTy != MVT::f32)
1927 return Register();
1928 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
1929 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVUXDSP, RC: &PPC::VSSRCRegClass, Op0);
1930 }
1931 return fastEmitInst_r(MachineInstOpcode: PPC::FCFIDUS, RC: &PPC::F4RCRegClass, Op0);
1932}
1933
1934Register fastEmit_PPCISD_FCFIDUS_r(MVT VT, MVT RetVT, Register Op0) {
1935 switch (VT.SimpleTy) {
1936 case MVT::f64: return fastEmit_PPCISD_FCFIDUS_MVT_f64_r(RetVT, Op0);
1937 default: return Register();
1938 }
1939}
1940
1941// FastEmit functions for PPCISD::FCTIDUZ.
1942
1943Register fastEmit_PPCISD_FCTIDUZ_MVT_f32_r(MVT RetVT, Register Op0) {
1944 if (RetVT.SimpleTy != MVT::f32)
1945 return Register();
1946 if ((Subtarget->hasVSX())) {
1947 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPUXDSs, RC: &PPC::VSSRCRegClass, Op0);
1948 }
1949 return Register();
1950}
1951
1952Register fastEmit_PPCISD_FCTIDUZ_MVT_f64_r(MVT RetVT, Register Op0) {
1953 if (RetVT.SimpleTy != MVT::f64)
1954 return Register();
1955 if ((Subtarget->hasVSX())) {
1956 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPUXDS, RC: &PPC::VSFRCRegClass, Op0);
1957 }
1958 return fastEmitInst_r(MachineInstOpcode: PPC::FCTIDUZ, RC: &PPC::F8RCRegClass, Op0);
1959}
1960
1961Register fastEmit_PPCISD_FCTIDUZ_MVT_f128_r(MVT RetVT, Register Op0) {
1962 if (RetVT.SimpleTy != MVT::f128)
1963 return Register();
1964 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
1965 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVQPUDZ, RC: &PPC::VRRCRegClass, Op0);
1966 }
1967 return Register();
1968}
1969
1970Register fastEmit_PPCISD_FCTIDUZ_r(MVT VT, MVT RetVT, Register Op0) {
1971 switch (VT.SimpleTy) {
1972 case MVT::f32: return fastEmit_PPCISD_FCTIDUZ_MVT_f32_r(RetVT, Op0);
1973 case MVT::f64: return fastEmit_PPCISD_FCTIDUZ_MVT_f64_r(RetVT, Op0);
1974 case MVT::f128: return fastEmit_PPCISD_FCTIDUZ_MVT_f128_r(RetVT, Op0);
1975 default: return Register();
1976 }
1977}
1978
1979// FastEmit functions for PPCISD::FCTIDZ.
1980
1981Register fastEmit_PPCISD_FCTIDZ_MVT_f32_r(MVT RetVT, Register Op0) {
1982 if (RetVT.SimpleTy != MVT::f32)
1983 return Register();
1984 if ((Subtarget->hasVSX())) {
1985 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSXDSs, RC: &PPC::VSSRCRegClass, Op0);
1986 }
1987 return Register();
1988}
1989
1990Register fastEmit_PPCISD_FCTIDZ_MVT_f64_r(MVT RetVT, Register Op0) {
1991 if (RetVT.SimpleTy != MVT::f64)
1992 return Register();
1993 if ((Subtarget->hasVSX())) {
1994 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSXDS, RC: &PPC::VSFRCRegClass, Op0);
1995 }
1996 return fastEmitInst_r(MachineInstOpcode: PPC::FCTIDZ, RC: &PPC::F8RCRegClass, Op0);
1997}
1998
1999Register fastEmit_PPCISD_FCTIDZ_MVT_f128_r(MVT RetVT, Register Op0) {
2000 if (RetVT.SimpleTy != MVT::f128)
2001 return Register();
2002 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
2003 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVQPSDZ, RC: &PPC::VRRCRegClass, Op0);
2004 }
2005 return Register();
2006}
2007
2008Register fastEmit_PPCISD_FCTIDZ_r(MVT VT, MVT RetVT, Register Op0) {
2009 switch (VT.SimpleTy) {
2010 case MVT::f32: return fastEmit_PPCISD_FCTIDZ_MVT_f32_r(RetVT, Op0);
2011 case MVT::f64: return fastEmit_PPCISD_FCTIDZ_MVT_f64_r(RetVT, Op0);
2012 case MVT::f128: return fastEmit_PPCISD_FCTIDZ_MVT_f128_r(RetVT, Op0);
2013 default: return Register();
2014 }
2015}
2016
2017// FastEmit functions for PPCISD::FCTIWUZ.
2018
2019Register fastEmit_PPCISD_FCTIWUZ_MVT_f32_r(MVT RetVT, Register Op0) {
2020 if (RetVT.SimpleTy != MVT::f32)
2021 return Register();
2022 if ((Subtarget->hasVSX())) {
2023 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPUXWSs, RC: &PPC::VSSRCRegClass, Op0);
2024 }
2025 return Register();
2026}
2027
2028Register fastEmit_PPCISD_FCTIWUZ_MVT_f64_r(MVT RetVT, Register Op0) {
2029 if (RetVT.SimpleTy != MVT::f64)
2030 return Register();
2031 if ((Subtarget->hasVSX())) {
2032 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPUXWS, RC: &PPC::VSFRCRegClass, Op0);
2033 }
2034 return fastEmitInst_r(MachineInstOpcode: PPC::FCTIWUZ, RC: &PPC::F8RCRegClass, Op0);
2035}
2036
2037Register fastEmit_PPCISD_FCTIWUZ_MVT_f128_r(MVT RetVT, Register Op0) {
2038 if (RetVT.SimpleTy != MVT::f128)
2039 return Register();
2040 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
2041 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVQPUWZ, RC: &PPC::VRRCRegClass, Op0);
2042 }
2043 return Register();
2044}
2045
2046Register fastEmit_PPCISD_FCTIWUZ_r(MVT VT, MVT RetVT, Register Op0) {
2047 switch (VT.SimpleTy) {
2048 case MVT::f32: return fastEmit_PPCISD_FCTIWUZ_MVT_f32_r(RetVT, Op0);
2049 case MVT::f64: return fastEmit_PPCISD_FCTIWUZ_MVT_f64_r(RetVT, Op0);
2050 case MVT::f128: return fastEmit_PPCISD_FCTIWUZ_MVT_f128_r(RetVT, Op0);
2051 default: return Register();
2052 }
2053}
2054
2055// FastEmit functions for PPCISD::FCTIWZ.
2056
2057Register fastEmit_PPCISD_FCTIWZ_MVT_f32_r(MVT RetVT, Register Op0) {
2058 if (RetVT.SimpleTy != MVT::f32)
2059 return Register();
2060 if ((Subtarget->hasVSX())) {
2061 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSXWSs, RC: &PPC::VSSRCRegClass, Op0);
2062 }
2063 return Register();
2064}
2065
2066Register fastEmit_PPCISD_FCTIWZ_MVT_f64_r(MVT RetVT, Register Op0) {
2067 if (RetVT.SimpleTy != MVT::f64)
2068 return Register();
2069 if ((Subtarget->hasVSX())) {
2070 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSXWS, RC: &PPC::VSFRCRegClass, Op0);
2071 }
2072 if ((Subtarget->hasFPU())) {
2073 return fastEmitInst_r(MachineInstOpcode: PPC::FCTIWZ, RC: &PPC::F8RCRegClass, Op0);
2074 }
2075 return Register();
2076}
2077
2078Register fastEmit_PPCISD_FCTIWZ_MVT_f128_r(MVT RetVT, Register Op0) {
2079 if (RetVT.SimpleTy != MVT::f128)
2080 return Register();
2081 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
2082 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVQPSWZ, RC: &PPC::VRRCRegClass, Op0);
2083 }
2084 return Register();
2085}
2086
2087Register fastEmit_PPCISD_FCTIWZ_r(MVT VT, MVT RetVT, Register Op0) {
2088 switch (VT.SimpleTy) {
2089 case MVT::f32: return fastEmit_PPCISD_FCTIWZ_MVT_f32_r(RetVT, Op0);
2090 case MVT::f64: return fastEmit_PPCISD_FCTIWZ_MVT_f64_r(RetVT, Op0);
2091 case MVT::f128: return fastEmit_PPCISD_FCTIWZ_MVT_f128_r(RetVT, Op0);
2092 default: return Register();
2093 }
2094}
2095
2096// FastEmit functions for PPCISD::FRE.
2097
2098Register fastEmit_PPCISD_FRE_MVT_f32_r(MVT RetVT, Register Op0) {
2099 if (RetVT.SimpleTy != MVT::f32)
2100 return Register();
2101 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
2102 return fastEmitInst_r(MachineInstOpcode: PPC::XSRESP, RC: &PPC::VSSRCRegClass, Op0);
2103 }
2104 if ((Subtarget->hasFPU())) {
2105 return fastEmitInst_r(MachineInstOpcode: PPC::FRES, RC: &PPC::F4RCRegClass, Op0);
2106 }
2107 return Register();
2108}
2109
2110Register fastEmit_PPCISD_FRE_MVT_f64_r(MVT RetVT, Register Op0) {
2111 if (RetVT.SimpleTy != MVT::f64)
2112 return Register();
2113 if ((Subtarget->hasVSX())) {
2114 return fastEmitInst_r(MachineInstOpcode: PPC::XSREDP, RC: &PPC::VSFRCRegClass, Op0);
2115 }
2116 if ((Subtarget->hasFPU())) {
2117 return fastEmitInst_r(MachineInstOpcode: PPC::FRE, RC: &PPC::F8RCRegClass, Op0);
2118 }
2119 return Register();
2120}
2121
2122Register fastEmit_PPCISD_FRE_MVT_v4f32_r(MVT RetVT, Register Op0) {
2123 if (RetVT.SimpleTy != MVT::v4f32)
2124 return Register();
2125 if ((Subtarget->hasVSX())) {
2126 return fastEmitInst_r(MachineInstOpcode: PPC::XVRESP, RC: &PPC::VSRCRegClass, Op0);
2127 }
2128 if ((Subtarget->hasAltivec())) {
2129 return fastEmitInst_r(MachineInstOpcode: PPC::VREFP, RC: &PPC::VRRCRegClass, Op0);
2130 }
2131 return Register();
2132}
2133
2134Register fastEmit_PPCISD_FRE_MVT_v2f64_r(MVT RetVT, Register Op0) {
2135 if (RetVT.SimpleTy != MVT::v2f64)
2136 return Register();
2137 if ((Subtarget->hasVSX())) {
2138 return fastEmitInst_r(MachineInstOpcode: PPC::XVREDP, RC: &PPC::VSRCRegClass, Op0);
2139 }
2140 return Register();
2141}
2142
2143Register fastEmit_PPCISD_FRE_r(MVT VT, MVT RetVT, Register Op0) {
2144 switch (VT.SimpleTy) {
2145 case MVT::f32: return fastEmit_PPCISD_FRE_MVT_f32_r(RetVT, Op0);
2146 case MVT::f64: return fastEmit_PPCISD_FRE_MVT_f64_r(RetVT, Op0);
2147 case MVT::v4f32: return fastEmit_PPCISD_FRE_MVT_v4f32_r(RetVT, Op0);
2148 case MVT::v2f64: return fastEmit_PPCISD_FRE_MVT_v2f64_r(RetVT, Op0);
2149 default: return Register();
2150 }
2151}
2152
2153// FastEmit functions for PPCISD::FRSQRTE.
2154
2155Register fastEmit_PPCISD_FRSQRTE_MVT_f32_r(MVT RetVT, Register Op0) {
2156 if (RetVT.SimpleTy != MVT::f32)
2157 return Register();
2158 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
2159 return fastEmitInst_r(MachineInstOpcode: PPC::XSRSQRTESP, RC: &PPC::VSSRCRegClass, Op0);
2160 }
2161 if ((Subtarget->hasFPU())) {
2162 return fastEmitInst_r(MachineInstOpcode: PPC::FRSQRTES, RC: &PPC::F4RCRegClass, Op0);
2163 }
2164 return Register();
2165}
2166
2167Register fastEmit_PPCISD_FRSQRTE_MVT_f64_r(MVT RetVT, Register Op0) {
2168 if (RetVT.SimpleTy != MVT::f64)
2169 return Register();
2170 if ((Subtarget->hasVSX())) {
2171 return fastEmitInst_r(MachineInstOpcode: PPC::XSRSQRTEDP, RC: &PPC::VSFRCRegClass, Op0);
2172 }
2173 if ((Subtarget->hasFPU())) {
2174 return fastEmitInst_r(MachineInstOpcode: PPC::FRSQRTE, RC: &PPC::F8RCRegClass, Op0);
2175 }
2176 return Register();
2177}
2178
2179Register fastEmit_PPCISD_FRSQRTE_MVT_v4f32_r(MVT RetVT, Register Op0) {
2180 if (RetVT.SimpleTy != MVT::v4f32)
2181 return Register();
2182 if ((Subtarget->hasVSX())) {
2183 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSQRTESP, RC: &PPC::VSRCRegClass, Op0);
2184 }
2185 if ((Subtarget->hasAltivec())) {
2186 return fastEmitInst_r(MachineInstOpcode: PPC::VRSQRTEFP, RC: &PPC::VRRCRegClass, Op0);
2187 }
2188 return Register();
2189}
2190
2191Register fastEmit_PPCISD_FRSQRTE_MVT_v2f64_r(MVT RetVT, Register Op0) {
2192 if (RetVT.SimpleTy != MVT::v2f64)
2193 return Register();
2194 if ((Subtarget->hasVSX())) {
2195 return fastEmitInst_r(MachineInstOpcode: PPC::XVRSQRTEDP, RC: &PPC::VSRCRegClass, Op0);
2196 }
2197 return Register();
2198}
2199
2200Register fastEmit_PPCISD_FRSQRTE_r(MVT VT, MVT RetVT, Register Op0) {
2201 switch (VT.SimpleTy) {
2202 case MVT::f32: return fastEmit_PPCISD_FRSQRTE_MVT_f32_r(RetVT, Op0);
2203 case MVT::f64: return fastEmit_PPCISD_FRSQRTE_MVT_f64_r(RetVT, Op0);
2204 case MVT::v4f32: return fastEmit_PPCISD_FRSQRTE_MVT_v4f32_r(RetVT, Op0);
2205 case MVT::v2f64: return fastEmit_PPCISD_FRSQRTE_MVT_v2f64_r(RetVT, Op0);
2206 default: return Register();
2207 }
2208}
2209
2210// FastEmit functions for PPCISD::FSQRT.
2211
2212Register fastEmit_PPCISD_FSQRT_MVT_f64_r(MVT RetVT, Register Op0) {
2213 if (RetVT.SimpleTy != MVT::f64)
2214 return Register();
2215 if ((Subtarget->hasVSX())) {
2216 return fastEmitInst_r(MachineInstOpcode: PPC::XSSQRTDP, RC: &PPC::VSFRCRegClass, Op0);
2217 }
2218 return fastEmitInst_r(MachineInstOpcode: PPC::FSQRT, RC: &PPC::F8RCRegClass, Op0);
2219}
2220
2221Register fastEmit_PPCISD_FSQRT_MVT_v4f32_r(MVT RetVT, Register Op0) {
2222 if (RetVT.SimpleTy != MVT::v4f32)
2223 return Register();
2224 if ((Subtarget->hasVSX())) {
2225 return fastEmitInst_r(MachineInstOpcode: PPC::XVSQRTSP, RC: &PPC::VSRCRegClass, Op0);
2226 }
2227 return Register();
2228}
2229
2230Register fastEmit_PPCISD_FSQRT_MVT_v2f64_r(MVT RetVT, Register Op0) {
2231 if (RetVT.SimpleTy != MVT::v2f64)
2232 return Register();
2233 if ((Subtarget->hasVSX())) {
2234 return fastEmitInst_r(MachineInstOpcode: PPC::XVSQRTDP, RC: &PPC::VSRCRegClass, Op0);
2235 }
2236 return Register();
2237}
2238
2239Register fastEmit_PPCISD_FSQRT_r(MVT VT, MVT RetVT, Register Op0) {
2240 switch (VT.SimpleTy) {
2241 case MVT::f64: return fastEmit_PPCISD_FSQRT_MVT_f64_r(RetVT, Op0);
2242 case MVT::v4f32: return fastEmit_PPCISD_FSQRT_MVT_v4f32_r(RetVT, Op0);
2243 case MVT::v2f64: return fastEmit_PPCISD_FSQRT_MVT_v2f64_r(RetVT, Op0);
2244 default: return Register();
2245 }
2246}
2247
2248// FastEmit functions for PPCISD::FTSQRT.
2249
2250Register fastEmit_PPCISD_FTSQRT_MVT_f64_r(MVT RetVT, Register Op0) {
2251 if (RetVT.SimpleTy != MVT::i32)
2252 return Register();
2253 if ((Subtarget->hasVSX())) {
2254 return fastEmitInst_r(MachineInstOpcode: PPC::XSTSQRTDP, RC: &PPC::CRRCRegClass, Op0);
2255 }
2256 if ((Subtarget->hasFPU())) {
2257 return fastEmitInst_r(MachineInstOpcode: PPC::FTSQRT, RC: &PPC::CRRCRegClass, Op0);
2258 }
2259 return Register();
2260}
2261
2262Register fastEmit_PPCISD_FTSQRT_MVT_v4f32_r(MVT RetVT, Register Op0) {
2263 if (RetVT.SimpleTy != MVT::i32)
2264 return Register();
2265 if ((Subtarget->hasVSX())) {
2266 return fastEmitInst_r(MachineInstOpcode: PPC::XVTSQRTSP, RC: &PPC::CRRCRegClass, Op0);
2267 }
2268 return Register();
2269}
2270
2271Register fastEmit_PPCISD_FTSQRT_MVT_v2f64_r(MVT RetVT, Register Op0) {
2272 if (RetVT.SimpleTy != MVT::i32)
2273 return Register();
2274 if ((Subtarget->hasVSX())) {
2275 return fastEmitInst_r(MachineInstOpcode: PPC::XVTSQRTDP, RC: &PPC::CRRCRegClass, Op0);
2276 }
2277 return Register();
2278}
2279
2280Register fastEmit_PPCISD_FTSQRT_r(MVT VT, MVT RetVT, Register Op0) {
2281 switch (VT.SimpleTy) {
2282 case MVT::f64: return fastEmit_PPCISD_FTSQRT_MVT_f64_r(RetVT, Op0);
2283 case MVT::v4f32: return fastEmit_PPCISD_FTSQRT_MVT_v4f32_r(RetVT, Op0);
2284 case MVT::v2f64: return fastEmit_PPCISD_FTSQRT_MVT_v2f64_r(RetVT, Op0);
2285 default: return Register();
2286 }
2287}
2288
2289// FastEmit functions for PPCISD::GET_TLS_MOD_AIX.
2290
2291Register fastEmit_PPCISD_GET_TLS_MOD_AIX_MVT_i32_r(MVT RetVT, Register Op0) {
2292 if (RetVT.SimpleTy != MVT::i32)
2293 return Register();
2294 return fastEmitInst_r(MachineInstOpcode: PPC::GETtlsMOD32AIX, RC: &PPC::GPRCRegClass, Op0);
2295}
2296
2297Register fastEmit_PPCISD_GET_TLS_MOD_AIX_MVT_i64_r(MVT RetVT, Register Op0) {
2298 if (RetVT.SimpleTy != MVT::i64)
2299 return Register();
2300 return fastEmitInst_r(MachineInstOpcode: PPC::GETtlsMOD64AIX, RC: &PPC::G8RCRegClass, Op0);
2301}
2302
2303Register fastEmit_PPCISD_GET_TLS_MOD_AIX_r(MVT VT, MVT RetVT, Register Op0) {
2304 switch (VT.SimpleTy) {
2305 case MVT::i32: return fastEmit_PPCISD_GET_TLS_MOD_AIX_MVT_i32_r(RetVT, Op0);
2306 case MVT::i64: return fastEmit_PPCISD_GET_TLS_MOD_AIX_MVT_i64_r(RetVT, Op0);
2307 default: return Register();
2308 }
2309}
2310
2311// FastEmit functions for PPCISD::MFVSR.
2312
2313Register fastEmit_PPCISD_MFVSR_MVT_f64_MVT_i32_r(Register Op0) {
2314 if ((Subtarget->hasDirectMove()) && (Subtarget->hasVSX())) {
2315 return fastEmitInst_r(MachineInstOpcode: PPC::MFVSRWZ, RC: &PPC::GPRCRegClass, Op0);
2316 }
2317 return Register();
2318}
2319
2320Register fastEmit_PPCISD_MFVSR_MVT_f64_MVT_i64_r(Register Op0) {
2321 if ((Subtarget->hasDirectMove()) && (Subtarget->hasVSX())) {
2322 return fastEmitInst_r(MachineInstOpcode: PPC::MFVSRD, RC: &PPC::G8RCRegClass, Op0);
2323 }
2324 return Register();
2325}
2326
2327Register fastEmit_PPCISD_MFVSR_MVT_f64_r(MVT RetVT, Register Op0) {
2328switch (RetVT.SimpleTy) {
2329 case MVT::i32: return fastEmit_PPCISD_MFVSR_MVT_f64_MVT_i32_r(Op0);
2330 case MVT::i64: return fastEmit_PPCISD_MFVSR_MVT_f64_MVT_i64_r(Op0);
2331 default: return Register();
2332}
2333}
2334
2335Register fastEmit_PPCISD_MFVSR_r(MVT VT, MVT RetVT, Register Op0) {
2336 switch (VT.SimpleTy) {
2337 case MVT::f64: return fastEmit_PPCISD_MFVSR_MVT_f64_r(RetVT, Op0);
2338 default: return Register();
2339 }
2340}
2341
2342// FastEmit functions for PPCISD::MTCTR.
2343
2344Register fastEmit_PPCISD_MTCTR_MVT_i32_r(MVT RetVT, Register Op0) {
2345 if (RetVT.SimpleTy != MVT::isVoid)
2346 return Register();
2347 return fastEmitInst_r(MachineInstOpcode: PPC::MTCTR, RC: &PPC::GPRCRegClass, Op0);
2348}
2349
2350Register fastEmit_PPCISD_MTCTR_MVT_i64_r(MVT RetVT, Register Op0) {
2351 if (RetVT.SimpleTy != MVT::isVoid)
2352 return Register();
2353 return fastEmitInst_r(MachineInstOpcode: PPC::MTCTR8, RC: &PPC::G8RCRegClass, Op0);
2354}
2355
2356Register fastEmit_PPCISD_MTCTR_r(MVT VT, MVT RetVT, Register Op0) {
2357 switch (VT.SimpleTy) {
2358 case MVT::i32: return fastEmit_PPCISD_MTCTR_MVT_i32_r(RetVT, Op0);
2359 case MVT::i64: return fastEmit_PPCISD_MTCTR_MVT_i64_r(RetVT, Op0);
2360 default: return Register();
2361 }
2362}
2363
2364// FastEmit functions for PPCISD::MTVSRA.
2365
2366Register fastEmit_PPCISD_MTVSRA_MVT_i32_r(MVT RetVT, Register Op0) {
2367 if (RetVT.SimpleTy != MVT::f64)
2368 return Register();
2369 if ((Subtarget->hasDirectMove()) && (Subtarget->hasVSX())) {
2370 return fastEmitInst_r(MachineInstOpcode: PPC::MTVSRWA, RC: &PPC::VSFRCRegClass, Op0);
2371 }
2372 return Register();
2373}
2374
2375Register fastEmit_PPCISD_MTVSRA_MVT_i64_r(MVT RetVT, Register Op0) {
2376 if (RetVT.SimpleTy != MVT::f64)
2377 return Register();
2378 if ((Subtarget->hasDirectMove()) && (Subtarget->hasVSX())) {
2379 return fastEmitInst_r(MachineInstOpcode: PPC::MTVSRD, RC: &PPC::VSFRCRegClass, Op0);
2380 }
2381 return Register();
2382}
2383
2384Register fastEmit_PPCISD_MTVSRA_r(MVT VT, MVT RetVT, Register Op0) {
2385 switch (VT.SimpleTy) {
2386 case MVT::i32: return fastEmit_PPCISD_MTVSRA_MVT_i32_r(RetVT, Op0);
2387 case MVT::i64: return fastEmit_PPCISD_MTVSRA_MVT_i64_r(RetVT, Op0);
2388 default: return Register();
2389 }
2390}
2391
2392// FastEmit functions for PPCISD::MTVSRZ.
2393
2394Register fastEmit_PPCISD_MTVSRZ_MVT_i32_r(MVT RetVT, Register Op0) {
2395 if (RetVT.SimpleTy != MVT::f64)
2396 return Register();
2397 if ((Subtarget->hasDirectMove()) && (Subtarget->hasVSX())) {
2398 return fastEmitInst_r(MachineInstOpcode: PPC::MTVSRWZ, RC: &PPC::VSFRCRegClass, Op0);
2399 }
2400 return Register();
2401}
2402
2403Register fastEmit_PPCISD_MTVSRZ_r(MVT VT, MVT RetVT, Register Op0) {
2404 switch (VT.SimpleTy) {
2405 case MVT::i32: return fastEmit_PPCISD_MTVSRZ_MVT_i32_r(RetVT, Op0);
2406 default: return Register();
2407 }
2408}
2409
2410// FastEmit functions for PPCISD::SCALAR_TO_VECTOR_PERMUTED.
2411
2412Register fastEmit_PPCISD_SCALAR_TO_VECTOR_PERMUTED_MVT_f32_r(MVT RetVT, Register Op0) {
2413 if (RetVT.SimpleTy != MVT::v4f32)
2414 return Register();
2415 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX()) && (Subtarget->isLittleEndian())) {
2416 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSPN, RC: &PPC::VSRCRegClass, Op0);
2417 }
2418 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX()) && (!Subtarget->isLittleEndian())) {
2419 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSPN, RC: &PPC::VSRCRegClass, Op0);
2420 }
2421 return Register();
2422}
2423
2424Register fastEmit_PPCISD_SCALAR_TO_VECTOR_PERMUTED_r(MVT VT, MVT RetVT, Register Op0) {
2425 switch (VT.SimpleTy) {
2426 case MVT::f32: return fastEmit_PPCISD_SCALAR_TO_VECTOR_PERMUTED_MVT_f32_r(RetVT, Op0);
2427 default: return Register();
2428 }
2429}
2430
2431// FastEmit functions for PPCISD::SETBC.
2432
2433Register fastEmit_PPCISD_SETBC_MVT_i1_r(MVT RetVT, Register Op0) {
2434 if (RetVT.SimpleTy != MVT::i32)
2435 return Register();
2436 if ((Subtarget->isISA3_1())) {
2437 return fastEmitInst_r(MachineInstOpcode: PPC::SETBC, RC: &PPC::GPRCRegClass, Op0);
2438 }
2439 return Register();
2440}
2441
2442Register fastEmit_PPCISD_SETBC_r(MVT VT, MVT RetVT, Register Op0) {
2443 switch (VT.SimpleTy) {
2444 case MVT::i1: return fastEmit_PPCISD_SETBC_MVT_i1_r(RetVT, Op0);
2445 default: return Register();
2446 }
2447}
2448
2449// FastEmit functions for PPCISD::SETBCR.
2450
2451Register fastEmit_PPCISD_SETBCR_MVT_i1_r(MVT RetVT, Register Op0) {
2452 if (RetVT.SimpleTy != MVT::i32)
2453 return Register();
2454 if ((Subtarget->isISA3_1())) {
2455 return fastEmitInst_r(MachineInstOpcode: PPC::SETBCR, RC: &PPC::GPRCRegClass, Op0);
2456 }
2457 return Register();
2458}
2459
2460Register fastEmit_PPCISD_SETBCR_r(MVT VT, MVT RetVT, Register Op0) {
2461 switch (VT.SimpleTy) {
2462 case MVT::i1: return fastEmit_PPCISD_SETBCR_MVT_i1_r(RetVT, Op0);
2463 default: return Register();
2464 }
2465}
2466
2467// FastEmit functions for PPCISD::STRICT_FCFID.
2468
2469Register fastEmit_PPCISD_STRICT_FCFID_MVT_f64_r(MVT RetVT, Register Op0) {
2470 if (RetVT.SimpleTy != MVT::f64)
2471 return Register();
2472 if ((Subtarget->hasVSX())) {
2473 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVSXDDP, RC: &PPC::VSFRCRegClass, Op0);
2474 }
2475 return fastEmitInst_r(MachineInstOpcode: PPC::FCFID, RC: &PPC::F8RCRegClass, Op0);
2476}
2477
2478Register fastEmit_PPCISD_STRICT_FCFID_r(MVT VT, MVT RetVT, Register Op0) {
2479 switch (VT.SimpleTy) {
2480 case MVT::f64: return fastEmit_PPCISD_STRICT_FCFID_MVT_f64_r(RetVT, Op0);
2481 default: return Register();
2482 }
2483}
2484
2485// FastEmit functions for PPCISD::STRICT_FCFIDS.
2486
2487Register fastEmit_PPCISD_STRICT_FCFIDS_MVT_f64_r(MVT RetVT, Register Op0) {
2488 if (RetVT.SimpleTy != MVT::f32)
2489 return Register();
2490 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
2491 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVSXDSP, RC: &PPC::VSSRCRegClass, Op0);
2492 }
2493 return fastEmitInst_r(MachineInstOpcode: PPC::FCFIDS, RC: &PPC::F4RCRegClass, Op0);
2494}
2495
2496Register fastEmit_PPCISD_STRICT_FCFIDS_r(MVT VT, MVT RetVT, Register Op0) {
2497 switch (VT.SimpleTy) {
2498 case MVT::f64: return fastEmit_PPCISD_STRICT_FCFIDS_MVT_f64_r(RetVT, Op0);
2499 default: return Register();
2500 }
2501}
2502
2503// FastEmit functions for PPCISD::STRICT_FCFIDU.
2504
2505Register fastEmit_PPCISD_STRICT_FCFIDU_MVT_f64_r(MVT RetVT, Register Op0) {
2506 if (RetVT.SimpleTy != MVT::f64)
2507 return Register();
2508 if ((Subtarget->hasVSX())) {
2509 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVUXDDP, RC: &PPC::VSFRCRegClass, Op0);
2510 }
2511 return fastEmitInst_r(MachineInstOpcode: PPC::FCFIDU, RC: &PPC::F8RCRegClass, Op0);
2512}
2513
2514Register fastEmit_PPCISD_STRICT_FCFIDU_r(MVT VT, MVT RetVT, Register Op0) {
2515 switch (VT.SimpleTy) {
2516 case MVT::f64: return fastEmit_PPCISD_STRICT_FCFIDU_MVT_f64_r(RetVT, Op0);
2517 default: return Register();
2518 }
2519}
2520
2521// FastEmit functions for PPCISD::STRICT_FCFIDUS.
2522
2523Register fastEmit_PPCISD_STRICT_FCFIDUS_MVT_f64_r(MVT RetVT, Register Op0) {
2524 if (RetVT.SimpleTy != MVT::f32)
2525 return Register();
2526 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
2527 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVUXDSP, RC: &PPC::VSSRCRegClass, Op0);
2528 }
2529 return fastEmitInst_r(MachineInstOpcode: PPC::FCFIDUS, RC: &PPC::F4RCRegClass, Op0);
2530}
2531
2532Register fastEmit_PPCISD_STRICT_FCFIDUS_r(MVT VT, MVT RetVT, Register Op0) {
2533 switch (VT.SimpleTy) {
2534 case MVT::f64: return fastEmit_PPCISD_STRICT_FCFIDUS_MVT_f64_r(RetVT, Op0);
2535 default: return Register();
2536 }
2537}
2538
2539// FastEmit functions for PPCISD::STRICT_FCTIDUZ.
2540
2541Register fastEmit_PPCISD_STRICT_FCTIDUZ_MVT_f32_r(MVT RetVT, Register Op0) {
2542 if (RetVT.SimpleTy != MVT::f32)
2543 return Register();
2544 if ((Subtarget->hasVSX())) {
2545 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPUXDSs, RC: &PPC::VSSRCRegClass, Op0);
2546 }
2547 return Register();
2548}
2549
2550Register fastEmit_PPCISD_STRICT_FCTIDUZ_MVT_f64_r(MVT RetVT, Register Op0) {
2551 if (RetVT.SimpleTy != MVT::f64)
2552 return Register();
2553 if ((Subtarget->hasVSX())) {
2554 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPUXDS, RC: &PPC::VSFRCRegClass, Op0);
2555 }
2556 return fastEmitInst_r(MachineInstOpcode: PPC::FCTIDUZ, RC: &PPC::F8RCRegClass, Op0);
2557}
2558
2559Register fastEmit_PPCISD_STRICT_FCTIDUZ_MVT_f128_r(MVT RetVT, Register Op0) {
2560 if (RetVT.SimpleTy != MVT::f128)
2561 return Register();
2562 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
2563 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVQPUDZ, RC: &PPC::VRRCRegClass, Op0);
2564 }
2565 return Register();
2566}
2567
2568Register fastEmit_PPCISD_STRICT_FCTIDUZ_r(MVT VT, MVT RetVT, Register Op0) {
2569 switch (VT.SimpleTy) {
2570 case MVT::f32: return fastEmit_PPCISD_STRICT_FCTIDUZ_MVT_f32_r(RetVT, Op0);
2571 case MVT::f64: return fastEmit_PPCISD_STRICT_FCTIDUZ_MVT_f64_r(RetVT, Op0);
2572 case MVT::f128: return fastEmit_PPCISD_STRICT_FCTIDUZ_MVT_f128_r(RetVT, Op0);
2573 default: return Register();
2574 }
2575}
2576
2577// FastEmit functions for PPCISD::STRICT_FCTIDZ.
2578
2579Register fastEmit_PPCISD_STRICT_FCTIDZ_MVT_f32_r(MVT RetVT, Register Op0) {
2580 if (RetVT.SimpleTy != MVT::f32)
2581 return Register();
2582 if ((Subtarget->hasVSX())) {
2583 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSXDSs, RC: &PPC::VSSRCRegClass, Op0);
2584 }
2585 return Register();
2586}
2587
2588Register fastEmit_PPCISD_STRICT_FCTIDZ_MVT_f64_r(MVT RetVT, Register Op0) {
2589 if (RetVT.SimpleTy != MVT::f64)
2590 return Register();
2591 if ((Subtarget->hasVSX())) {
2592 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSXDS, RC: &PPC::VSFRCRegClass, Op0);
2593 }
2594 return fastEmitInst_r(MachineInstOpcode: PPC::FCTIDZ, RC: &PPC::F8RCRegClass, Op0);
2595}
2596
2597Register fastEmit_PPCISD_STRICT_FCTIDZ_MVT_f128_r(MVT RetVT, Register Op0) {
2598 if (RetVT.SimpleTy != MVT::f128)
2599 return Register();
2600 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
2601 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVQPSDZ, RC: &PPC::VRRCRegClass, Op0);
2602 }
2603 return Register();
2604}
2605
2606Register fastEmit_PPCISD_STRICT_FCTIDZ_r(MVT VT, MVT RetVT, Register Op0) {
2607 switch (VT.SimpleTy) {
2608 case MVT::f32: return fastEmit_PPCISD_STRICT_FCTIDZ_MVT_f32_r(RetVT, Op0);
2609 case MVT::f64: return fastEmit_PPCISD_STRICT_FCTIDZ_MVT_f64_r(RetVT, Op0);
2610 case MVT::f128: return fastEmit_PPCISD_STRICT_FCTIDZ_MVT_f128_r(RetVT, Op0);
2611 default: return Register();
2612 }
2613}
2614
2615// FastEmit functions for PPCISD::STRICT_FCTIWUZ.
2616
2617Register fastEmit_PPCISD_STRICT_FCTIWUZ_MVT_f32_r(MVT RetVT, Register Op0) {
2618 if (RetVT.SimpleTy != MVT::f32)
2619 return Register();
2620 if ((Subtarget->hasVSX())) {
2621 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPUXWSs, RC: &PPC::VSSRCRegClass, Op0);
2622 }
2623 return Register();
2624}
2625
2626Register fastEmit_PPCISD_STRICT_FCTIWUZ_MVT_f64_r(MVT RetVT, Register Op0) {
2627 if (RetVT.SimpleTy != MVT::f64)
2628 return Register();
2629 if ((Subtarget->hasVSX())) {
2630 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPUXWS, RC: &PPC::VSFRCRegClass, Op0);
2631 }
2632 return fastEmitInst_r(MachineInstOpcode: PPC::FCTIWUZ, RC: &PPC::F8RCRegClass, Op0);
2633}
2634
2635Register fastEmit_PPCISD_STRICT_FCTIWUZ_MVT_f128_r(MVT RetVT, Register Op0) {
2636 if (RetVT.SimpleTy != MVT::f128)
2637 return Register();
2638 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
2639 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVQPUWZ, RC: &PPC::VRRCRegClass, Op0);
2640 }
2641 return Register();
2642}
2643
2644Register fastEmit_PPCISD_STRICT_FCTIWUZ_r(MVT VT, MVT RetVT, Register Op0) {
2645 switch (VT.SimpleTy) {
2646 case MVT::f32: return fastEmit_PPCISD_STRICT_FCTIWUZ_MVT_f32_r(RetVT, Op0);
2647 case MVT::f64: return fastEmit_PPCISD_STRICT_FCTIWUZ_MVT_f64_r(RetVT, Op0);
2648 case MVT::f128: return fastEmit_PPCISD_STRICT_FCTIWUZ_MVT_f128_r(RetVT, Op0);
2649 default: return Register();
2650 }
2651}
2652
2653// FastEmit functions for PPCISD::STRICT_FCTIWZ.
2654
2655Register fastEmit_PPCISD_STRICT_FCTIWZ_MVT_f32_r(MVT RetVT, Register Op0) {
2656 if (RetVT.SimpleTy != MVT::f32)
2657 return Register();
2658 if ((Subtarget->hasVSX())) {
2659 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSXWSs, RC: &PPC::VSSRCRegClass, Op0);
2660 }
2661 return Register();
2662}
2663
2664Register fastEmit_PPCISD_STRICT_FCTIWZ_MVT_f64_r(MVT RetVT, Register Op0) {
2665 if (RetVT.SimpleTy != MVT::f64)
2666 return Register();
2667 if ((Subtarget->hasVSX())) {
2668 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVDPSXWS, RC: &PPC::VSFRCRegClass, Op0);
2669 }
2670 if ((Subtarget->hasFPU())) {
2671 return fastEmitInst_r(MachineInstOpcode: PPC::FCTIWZ, RC: &PPC::F8RCRegClass, Op0);
2672 }
2673 return Register();
2674}
2675
2676Register fastEmit_PPCISD_STRICT_FCTIWZ_MVT_f128_r(MVT RetVT, Register Op0) {
2677 if (RetVT.SimpleTy != MVT::f128)
2678 return Register();
2679 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
2680 return fastEmitInst_r(MachineInstOpcode: PPC::XSCVQPSWZ, RC: &PPC::VRRCRegClass, Op0);
2681 }
2682 return Register();
2683}
2684
2685Register fastEmit_PPCISD_STRICT_FCTIWZ_r(MVT VT, MVT RetVT, Register Op0) {
2686 switch (VT.SimpleTy) {
2687 case MVT::f32: return fastEmit_PPCISD_STRICT_FCTIWZ_MVT_f32_r(RetVT, Op0);
2688 case MVT::f64: return fastEmit_PPCISD_STRICT_FCTIWZ_MVT_f64_r(RetVT, Op0);
2689 case MVT::f128: return fastEmit_PPCISD_STRICT_FCTIWZ_MVT_f128_r(RetVT, Op0);
2690 default: return Register();
2691 }
2692}
2693
2694// FastEmit functions for PPCISD::TLSLD_AIX.
2695
2696Register fastEmit_PPCISD_TLSLD_AIX_MVT_i32_r(MVT RetVT, Register Op0) {
2697 if (RetVT.SimpleTy != MVT::i32)
2698 return Register();
2699 return fastEmitInst_r(MachineInstOpcode: PPC::TLSLDAIX, RC: &PPC::GPRCRegClass, Op0);
2700}
2701
2702Register fastEmit_PPCISD_TLSLD_AIX_MVT_i64_r(MVT RetVT, Register Op0) {
2703 if (RetVT.SimpleTy != MVT::i64)
2704 return Register();
2705 return fastEmitInst_r(MachineInstOpcode: PPC::TLSLDAIX8, RC: &PPC::G8RCRegClass, Op0);
2706}
2707
2708Register fastEmit_PPCISD_TLSLD_AIX_r(MVT VT, MVT RetVT, Register Op0) {
2709 switch (VT.SimpleTy) {
2710 case MVT::i32: return fastEmit_PPCISD_TLSLD_AIX_MVT_i32_r(RetVT, Op0);
2711 case MVT::i64: return fastEmit_PPCISD_TLSLD_AIX_MVT_i64_r(RetVT, Op0);
2712 default: return Register();
2713 }
2714}
2715
2716// FastEmit functions for PPCISD::XXMFACC.
2717
2718Register fastEmit_PPCISD_XXMFACC_MVT_v512i1_r(MVT RetVT, Register Op0) {
2719 if (RetVT.SimpleTy != MVT::v512i1)
2720 return Register();
2721 if ((!Subtarget->isISAFuture()) && (Subtarget->hasMMA())) {
2722 return fastEmitInst_r(MachineInstOpcode: PPC::XXMFACC, RC: &PPC::ACCRCRegClass, Op0);
2723 }
2724 return Register();
2725}
2726
2727Register fastEmit_PPCISD_XXMFACC_r(MVT VT, MVT RetVT, Register Op0) {
2728 switch (VT.SimpleTy) {
2729 case MVT::v512i1: return fastEmit_PPCISD_XXMFACC_MVT_v512i1_r(RetVT, Op0);
2730 default: return Register();
2731 }
2732}
2733
2734// FastEmit functions for PPCISD::XXSPLTI_SP_TO_DP.
2735
2736Register fastEmit_PPCISD_XXSPLTI_SP_TO_DP_MVT_i32_r(MVT RetVT, Register Op0) {
2737 if (RetVT.SimpleTy != MVT::v2f64)
2738 return Register();
2739 if ((Subtarget->hasPrefixInstrs())) {
2740 return fastEmitInst_r(MachineInstOpcode: PPC::XXSPLTIDP, RC: &PPC::VSRCRegClass, Op0);
2741 }
2742 return Register();
2743}
2744
2745Register fastEmit_PPCISD_XXSPLTI_SP_TO_DP_r(MVT VT, MVT RetVT, Register Op0) {
2746 switch (VT.SimpleTy) {
2747 case MVT::i32: return fastEmit_PPCISD_XXSPLTI_SP_TO_DP_MVT_i32_r(RetVT, Op0);
2748 default: return Register();
2749 }
2750}
2751
2752// Top-level FastEmit function.
2753
2754Register fastEmit_r(MVT VT, MVT RetVT, unsigned Opcode, Register Op0) override {
2755 switch (Opcode) {
2756 case ISD::ANY_EXTEND: return fastEmit_ISD_ANY_EXTEND_r(VT, RetVT, Op0);
2757 case ISD::BITCAST: return fastEmit_ISD_BITCAST_r(VT, RetVT, Op0);
2758 case ISD::BSWAP: return fastEmit_ISD_BSWAP_r(VT, RetVT, Op0);
2759 case ISD::CTLZ: return fastEmit_ISD_CTLZ_r(VT, RetVT, Op0);
2760 case ISD::CTPOP: return fastEmit_ISD_CTPOP_r(VT, RetVT, Op0);
2761 case ISD::CTTZ: return fastEmit_ISD_CTTZ_r(VT, RetVT, Op0);
2762 case ISD::FABS: return fastEmit_ISD_FABS_r(VT, RetVT, Op0);
2763 case ISD::FCEIL: return fastEmit_ISD_FCEIL_r(VT, RetVT, Op0);
2764 case ISD::FFLOOR: return fastEmit_ISD_FFLOOR_r(VT, RetVT, Op0);
2765 case ISD::FNEARBYINT: return fastEmit_ISD_FNEARBYINT_r(VT, RetVT, Op0);
2766 case ISD::FNEG: return fastEmit_ISD_FNEG_r(VT, RetVT, Op0);
2767 case ISD::FP_EXTEND: return fastEmit_ISD_FP_EXTEND_r(VT, RetVT, Op0);
2768 case ISD::FP_ROUND: return fastEmit_ISD_FP_ROUND_r(VT, RetVT, Op0);
2769 case ISD::FP_TO_SINT: return fastEmit_ISD_FP_TO_SINT_r(VT, RetVT, Op0);
2770 case ISD::FP_TO_UINT: return fastEmit_ISD_FP_TO_UINT_r(VT, RetVT, Op0);
2771 case ISD::FRINT: return fastEmit_ISD_FRINT_r(VT, RetVT, Op0);
2772 case ISD::FROUND: return fastEmit_ISD_FROUND_r(VT, RetVT, Op0);
2773 case ISD::FSQRT: return fastEmit_ISD_FSQRT_r(VT, RetVT, Op0);
2774 case ISD::FTRUNC: return fastEmit_ISD_FTRUNC_r(VT, RetVT, Op0);
2775 case ISD::SCALAR_TO_VECTOR: return fastEmit_ISD_SCALAR_TO_VECTOR_r(VT, RetVT, Op0);
2776 case ISD::SIGN_EXTEND: return fastEmit_ISD_SIGN_EXTEND_r(VT, RetVT, Op0);
2777 case ISD::SINT_TO_FP: return fastEmit_ISD_SINT_TO_FP_r(VT, RetVT, Op0);
2778 case ISD::STRICT_FCEIL: return fastEmit_ISD_STRICT_FCEIL_r(VT, RetVT, Op0);
2779 case ISD::STRICT_FFLOOR: return fastEmit_ISD_STRICT_FFLOOR_r(VT, RetVT, Op0);
2780 case ISD::STRICT_FNEARBYINT: return fastEmit_ISD_STRICT_FNEARBYINT_r(VT, RetVT, Op0);
2781 case ISD::STRICT_FP_EXTEND: return fastEmit_ISD_STRICT_FP_EXTEND_r(VT, RetVT, Op0);
2782 case ISD::STRICT_FP_ROUND: return fastEmit_ISD_STRICT_FP_ROUND_r(VT, RetVT, Op0);
2783 case ISD::STRICT_FP_TO_SINT: return fastEmit_ISD_STRICT_FP_TO_SINT_r(VT, RetVT, Op0);
2784 case ISD::STRICT_FP_TO_UINT: return fastEmit_ISD_STRICT_FP_TO_UINT_r(VT, RetVT, Op0);
2785 case ISD::STRICT_FRINT: return fastEmit_ISD_STRICT_FRINT_r(VT, RetVT, Op0);
2786 case ISD::STRICT_FROUND: return fastEmit_ISD_STRICT_FROUND_r(VT, RetVT, Op0);
2787 case ISD::STRICT_FSQRT: return fastEmit_ISD_STRICT_FSQRT_r(VT, RetVT, Op0);
2788 case ISD::STRICT_FTRUNC: return fastEmit_ISD_STRICT_FTRUNC_r(VT, RetVT, Op0);
2789 case ISD::STRICT_SINT_TO_FP: return fastEmit_ISD_STRICT_SINT_TO_FP_r(VT, RetVT, Op0);
2790 case ISD::STRICT_UINT_TO_FP: return fastEmit_ISD_STRICT_UINT_TO_FP_r(VT, RetVT, Op0);
2791 case ISD::TRUNCATE: return fastEmit_ISD_TRUNCATE_r(VT, RetVT, Op0);
2792 case ISD::UINT_TO_FP: return fastEmit_ISD_UINT_TO_FP_r(VT, RetVT, Op0);
2793 case ISD::ZERO_EXTEND: return fastEmit_ISD_ZERO_EXTEND_r(VT, RetVT, Op0);
2794 case PPCISD::FCFID: return fastEmit_PPCISD_FCFID_r(VT, RetVT, Op0);
2795 case PPCISD::FCFIDS: return fastEmit_PPCISD_FCFIDS_r(VT, RetVT, Op0);
2796 case PPCISD::FCFIDU: return fastEmit_PPCISD_FCFIDU_r(VT, RetVT, Op0);
2797 case PPCISD::FCFIDUS: return fastEmit_PPCISD_FCFIDUS_r(VT, RetVT, Op0);
2798 case PPCISD::FCTIDUZ: return fastEmit_PPCISD_FCTIDUZ_r(VT, RetVT, Op0);
2799 case PPCISD::FCTIDZ: return fastEmit_PPCISD_FCTIDZ_r(VT, RetVT, Op0);
2800 case PPCISD::FCTIWUZ: return fastEmit_PPCISD_FCTIWUZ_r(VT, RetVT, Op0);
2801 case PPCISD::FCTIWZ: return fastEmit_PPCISD_FCTIWZ_r(VT, RetVT, Op0);
2802 case PPCISD::FRE: return fastEmit_PPCISD_FRE_r(VT, RetVT, Op0);
2803 case PPCISD::FRSQRTE: return fastEmit_PPCISD_FRSQRTE_r(VT, RetVT, Op0);
2804 case PPCISD::FSQRT: return fastEmit_PPCISD_FSQRT_r(VT, RetVT, Op0);
2805 case PPCISD::FTSQRT: return fastEmit_PPCISD_FTSQRT_r(VT, RetVT, Op0);
2806 case PPCISD::GET_TLS_MOD_AIX: return fastEmit_PPCISD_GET_TLS_MOD_AIX_r(VT, RetVT, Op0);
2807 case PPCISD::MFVSR: return fastEmit_PPCISD_MFVSR_r(VT, RetVT, Op0);
2808 case PPCISD::MTCTR: return fastEmit_PPCISD_MTCTR_r(VT, RetVT, Op0);
2809 case PPCISD::MTVSRA: return fastEmit_PPCISD_MTVSRA_r(VT, RetVT, Op0);
2810 case PPCISD::MTVSRZ: return fastEmit_PPCISD_MTVSRZ_r(VT, RetVT, Op0);
2811 case PPCISD::SCALAR_TO_VECTOR_PERMUTED: return fastEmit_PPCISD_SCALAR_TO_VECTOR_PERMUTED_r(VT, RetVT, Op0);
2812 case PPCISD::SETBC: return fastEmit_PPCISD_SETBC_r(VT, RetVT, Op0);
2813 case PPCISD::SETBCR: return fastEmit_PPCISD_SETBCR_r(VT, RetVT, Op0);
2814 case PPCISD::STRICT_FCFID: return fastEmit_PPCISD_STRICT_FCFID_r(VT, RetVT, Op0);
2815 case PPCISD::STRICT_FCFIDS: return fastEmit_PPCISD_STRICT_FCFIDS_r(VT, RetVT, Op0);
2816 case PPCISD::STRICT_FCFIDU: return fastEmit_PPCISD_STRICT_FCFIDU_r(VT, RetVT, Op0);
2817 case PPCISD::STRICT_FCFIDUS: return fastEmit_PPCISD_STRICT_FCFIDUS_r(VT, RetVT, Op0);
2818 case PPCISD::STRICT_FCTIDUZ: return fastEmit_PPCISD_STRICT_FCTIDUZ_r(VT, RetVT, Op0);
2819 case PPCISD::STRICT_FCTIDZ: return fastEmit_PPCISD_STRICT_FCTIDZ_r(VT, RetVT, Op0);
2820 case PPCISD::STRICT_FCTIWUZ: return fastEmit_PPCISD_STRICT_FCTIWUZ_r(VT, RetVT, Op0);
2821 case PPCISD::STRICT_FCTIWZ: return fastEmit_PPCISD_STRICT_FCTIWZ_r(VT, RetVT, Op0);
2822 case PPCISD::TLSLD_AIX: return fastEmit_PPCISD_TLSLD_AIX_r(VT, RetVT, Op0);
2823 case PPCISD::XXMFACC: return fastEmit_PPCISD_XXMFACC_r(VT, RetVT, Op0);
2824 case PPCISD::XXSPLTI_SP_TO_DP: return fastEmit_PPCISD_XXSPLTI_SP_TO_DP_r(VT, RetVT, Op0);
2825 default: return Register();
2826 }
2827}
2828
2829// FastEmit functions for ISD::ABDU.
2830
2831Register fastEmit_ISD_ABDU_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2832 if (RetVT.SimpleTy != MVT::v16i8)
2833 return Register();
2834 if ((Subtarget->hasP9Altivec()) && (Subtarget->hasVSX())) {
2835 return fastEmitInst_rr(MachineInstOpcode: PPC::VABSDUB, RC: &PPC::VRRCRegClass, Op0, Op1);
2836 }
2837 return Register();
2838}
2839
2840Register fastEmit_ISD_ABDU_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2841 if (RetVT.SimpleTy != MVT::v8i16)
2842 return Register();
2843 if ((Subtarget->hasP9Altivec()) && (Subtarget->hasVSX())) {
2844 return fastEmitInst_rr(MachineInstOpcode: PPC::VABSDUH, RC: &PPC::VRRCRegClass, Op0, Op1);
2845 }
2846 return Register();
2847}
2848
2849Register fastEmit_ISD_ABDU_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2850 if (RetVT.SimpleTy != MVT::v4i32)
2851 return Register();
2852 if ((Subtarget->hasP9Altivec()) && (Subtarget->hasVSX())) {
2853 return fastEmitInst_rr(MachineInstOpcode: PPC::VABSDUW, RC: &PPC::VRRCRegClass, Op0, Op1);
2854 }
2855 return Register();
2856}
2857
2858Register fastEmit_ISD_ABDU_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2859 switch (VT.SimpleTy) {
2860 case MVT::v16i8: return fastEmit_ISD_ABDU_MVT_v16i8_rr(RetVT, Op0, Op1);
2861 case MVT::v8i16: return fastEmit_ISD_ABDU_MVT_v8i16_rr(RetVT, Op0, Op1);
2862 case MVT::v4i32: return fastEmit_ISD_ABDU_MVT_v4i32_rr(RetVT, Op0, Op1);
2863 default: return Register();
2864 }
2865}
2866
2867// FastEmit functions for ISD::ADD.
2868
2869Register fastEmit_ISD_ADD_MVT_i1_rr(MVT RetVT, Register Op0, Register Op1) {
2870 if (RetVT.SimpleTy != MVT::i1)
2871 return Register();
2872 return fastEmitInst_rr(MachineInstOpcode: PPC::CRXOR, RC: &PPC::CRBITRCRegClass, Op0, Op1);
2873}
2874
2875Register fastEmit_ISD_ADD_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2876 if (RetVT.SimpleTy != MVT::i32)
2877 return Register();
2878 return fastEmitInst_rr(MachineInstOpcode: PPC::ADD4, RC: &PPC::GPRCRegClass, Op0, Op1);
2879}
2880
2881Register fastEmit_ISD_ADD_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2882 if (RetVT.SimpleTy != MVT::i64)
2883 return Register();
2884 return fastEmitInst_rr(MachineInstOpcode: PPC::ADD8, RC: &PPC::G8RCRegClass, Op0, Op1);
2885}
2886
2887Register fastEmit_ISD_ADD_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2888 if (RetVT.SimpleTy != MVT::v16i8)
2889 return Register();
2890 if ((Subtarget->hasAltivec())) {
2891 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDUBM, RC: &PPC::VRRCRegClass, Op0, Op1);
2892 }
2893 return Register();
2894}
2895
2896Register fastEmit_ISD_ADD_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
2897 if (RetVT.SimpleTy != MVT::v8i16)
2898 return Register();
2899 if ((Subtarget->hasAltivec())) {
2900 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDUHM, RC: &PPC::VRRCRegClass, Op0, Op1);
2901 }
2902 return Register();
2903}
2904
2905Register fastEmit_ISD_ADD_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2906 if (RetVT.SimpleTy != MVT::v4i32)
2907 return Register();
2908 if ((Subtarget->hasFutureVector())) {
2909 return fastEmitInst_rr(MachineInstOpcode: PPC::XVADDUWM, RC: &PPC::VSRCRegClass, Op0, Op1);
2910 }
2911 if ((Subtarget->hasAltivec())) {
2912 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDUWM, RC: &PPC::VRRCRegClass, Op0, Op1);
2913 }
2914 return Register();
2915}
2916
2917Register fastEmit_ISD_ADD_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
2918 if (RetVT.SimpleTy != MVT::v2i64)
2919 return Register();
2920 if ((Subtarget->hasP8Altivec())) {
2921 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDUDM, RC: &PPC::VRRCRegClass, Op0, Op1);
2922 }
2923 return Register();
2924}
2925
2926Register fastEmit_ISD_ADD_MVT_v1i128_rr(MVT RetVT, Register Op0, Register Op1) {
2927 if (RetVT.SimpleTy != MVT::v1i128)
2928 return Register();
2929 if ((Subtarget->hasP8Altivec())) {
2930 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDUQM, RC: &PPC::VRRCRegClass, Op0, Op1);
2931 }
2932 return Register();
2933}
2934
2935Register fastEmit_ISD_ADD_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2936 switch (VT.SimpleTy) {
2937 case MVT::i1: return fastEmit_ISD_ADD_MVT_i1_rr(RetVT, Op0, Op1);
2938 case MVT::i32: return fastEmit_ISD_ADD_MVT_i32_rr(RetVT, Op0, Op1);
2939 case MVT::i64: return fastEmit_ISD_ADD_MVT_i64_rr(RetVT, Op0, Op1);
2940 case MVT::v16i8: return fastEmit_ISD_ADD_MVT_v16i8_rr(RetVT, Op0, Op1);
2941 case MVT::v8i16: return fastEmit_ISD_ADD_MVT_v8i16_rr(RetVT, Op0, Op1);
2942 case MVT::v4i32: return fastEmit_ISD_ADD_MVT_v4i32_rr(RetVT, Op0, Op1);
2943 case MVT::v2i64: return fastEmit_ISD_ADD_MVT_v2i64_rr(RetVT, Op0, Op1);
2944 case MVT::v1i128: return fastEmit_ISD_ADD_MVT_v1i128_rr(RetVT, Op0, Op1);
2945 default: return Register();
2946 }
2947}
2948
2949// FastEmit functions for ISD::AND.
2950
2951Register fastEmit_ISD_AND_MVT_i1_rr(MVT RetVT, Register Op0, Register Op1) {
2952 if (RetVT.SimpleTy != MVT::i1)
2953 return Register();
2954 return fastEmitInst_rr(MachineInstOpcode: PPC::CRAND, RC: &PPC::CRBITRCRegClass, Op0, Op1);
2955}
2956
2957Register fastEmit_ISD_AND_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
2958 if (RetVT.SimpleTy != MVT::i32)
2959 return Register();
2960 return fastEmitInst_rr(MachineInstOpcode: PPC::AND, RC: &PPC::GPRCRegClass, Op0, Op1);
2961}
2962
2963Register fastEmit_ISD_AND_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
2964 if (RetVT.SimpleTy != MVT::i64)
2965 return Register();
2966 return fastEmitInst_rr(MachineInstOpcode: PPC::AND8, RC: &PPC::G8RCRegClass, Op0, Op1);
2967}
2968
2969Register fastEmit_ISD_AND_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
2970 if (RetVT.SimpleTy != MVT::v4i32)
2971 return Register();
2972 if ((Subtarget->hasVSX())) {
2973 return fastEmitInst_rr(MachineInstOpcode: PPC::XXLAND, RC: &PPC::VSRCRegClass, Op0, Op1);
2974 }
2975 if ((Subtarget->hasAltivec())) {
2976 return fastEmitInst_rr(MachineInstOpcode: PPC::VAND, RC: &PPC::VRRCRegClass, Op0, Op1);
2977 }
2978 return Register();
2979}
2980
2981Register fastEmit_ISD_AND_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
2982 switch (VT.SimpleTy) {
2983 case MVT::i1: return fastEmit_ISD_AND_MVT_i1_rr(RetVT, Op0, Op1);
2984 case MVT::i32: return fastEmit_ISD_AND_MVT_i32_rr(RetVT, Op0, Op1);
2985 case MVT::i64: return fastEmit_ISD_AND_MVT_i64_rr(RetVT, Op0, Op1);
2986 case MVT::v4i32: return fastEmit_ISD_AND_MVT_v4i32_rr(RetVT, Op0, Op1);
2987 default: return Register();
2988 }
2989}
2990
2991// FastEmit functions for ISD::AVGCEILS.
2992
2993Register fastEmit_ISD_AVGCEILS_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
2994 if (RetVT.SimpleTy != MVT::v16i8)
2995 return Register();
2996 if ((Subtarget->hasAltivec())) {
2997 return fastEmitInst_rr(MachineInstOpcode: PPC::VAVGSB, RC: &PPC::VRRCRegClass, Op0, Op1);
2998 }
2999 return Register();
3000}
3001
3002Register fastEmit_ISD_AVGCEILS_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
3003 if (RetVT.SimpleTy != MVT::v8i16)
3004 return Register();
3005 if ((Subtarget->hasAltivec())) {
3006 return fastEmitInst_rr(MachineInstOpcode: PPC::VAVGSH, RC: &PPC::VRRCRegClass, Op0, Op1);
3007 }
3008 return Register();
3009}
3010
3011Register fastEmit_ISD_AVGCEILS_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3012 if (RetVT.SimpleTy != MVT::v4i32)
3013 return Register();
3014 if ((Subtarget->hasAltivec())) {
3015 return fastEmitInst_rr(MachineInstOpcode: PPC::VAVGSW, RC: &PPC::VRRCRegClass, Op0, Op1);
3016 }
3017 return Register();
3018}
3019
3020Register fastEmit_ISD_AVGCEILS_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3021 switch (VT.SimpleTy) {
3022 case MVT::v16i8: return fastEmit_ISD_AVGCEILS_MVT_v16i8_rr(RetVT, Op0, Op1);
3023 case MVT::v8i16: return fastEmit_ISD_AVGCEILS_MVT_v8i16_rr(RetVT, Op0, Op1);
3024 case MVT::v4i32: return fastEmit_ISD_AVGCEILS_MVT_v4i32_rr(RetVT, Op0, Op1);
3025 default: return Register();
3026 }
3027}
3028
3029// FastEmit functions for ISD::AVGCEILU.
3030
3031Register fastEmit_ISD_AVGCEILU_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
3032 if (RetVT.SimpleTy != MVT::v16i8)
3033 return Register();
3034 if ((Subtarget->hasAltivec())) {
3035 return fastEmitInst_rr(MachineInstOpcode: PPC::VAVGUB, RC: &PPC::VRRCRegClass, Op0, Op1);
3036 }
3037 return Register();
3038}
3039
3040Register fastEmit_ISD_AVGCEILU_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
3041 if (RetVT.SimpleTy != MVT::v8i16)
3042 return Register();
3043 if ((Subtarget->hasAltivec())) {
3044 return fastEmitInst_rr(MachineInstOpcode: PPC::VAVGUH, RC: &PPC::VRRCRegClass, Op0, Op1);
3045 }
3046 return Register();
3047}
3048
3049Register fastEmit_ISD_AVGCEILU_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3050 if (RetVT.SimpleTy != MVT::v4i32)
3051 return Register();
3052 if ((Subtarget->hasAltivec())) {
3053 return fastEmitInst_rr(MachineInstOpcode: PPC::VAVGUW, RC: &PPC::VRRCRegClass, Op0, Op1);
3054 }
3055 return Register();
3056}
3057
3058Register fastEmit_ISD_AVGCEILU_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3059 switch (VT.SimpleTy) {
3060 case MVT::v16i8: return fastEmit_ISD_AVGCEILU_MVT_v16i8_rr(RetVT, Op0, Op1);
3061 case MVT::v8i16: return fastEmit_ISD_AVGCEILU_MVT_v8i16_rr(RetVT, Op0, Op1);
3062 case MVT::v4i32: return fastEmit_ISD_AVGCEILU_MVT_v4i32_rr(RetVT, Op0, Op1);
3063 default: return Register();
3064 }
3065}
3066
3067// FastEmit functions for ISD::BUILD_VECTOR.
3068
3069Register fastEmit_ISD_BUILD_VECTOR_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
3070 if (RetVT.SimpleTy != MVT::v2i64)
3071 return Register();
3072 if ((Subtarget->hasDirectMove()) && (Subtarget->hasVSX()) && (!Subtarget->isLittleEndian()) && (Subtarget->isISA3_0()) && (Subtarget->isPPC64())) {
3073 return fastEmitInst_rr(MachineInstOpcode: PPC::MTVSRDD, RC: &PPC::VSRCRegClass, Op0, Op1);
3074 }
3075 return Register();
3076}
3077
3078Register fastEmit_ISD_BUILD_VECTOR_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3079 switch (VT.SimpleTy) {
3080 case MVT::i64: return fastEmit_ISD_BUILD_VECTOR_MVT_i64_rr(RetVT, Op0, Op1);
3081 default: return Register();
3082 }
3083}
3084
3085// FastEmit functions for ISD::FADD.
3086
3087Register fastEmit_ISD_FADD_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
3088 if (RetVT.SimpleTy != MVT::f32)
3089 return Register();
3090 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
3091 return fastEmitInst_rr(MachineInstOpcode: PPC::XSADDSP, RC: &PPC::VSSRCRegClass, Op0, Op1);
3092 }
3093 if ((Subtarget->hasSPE())) {
3094 return fastEmitInst_rr(MachineInstOpcode: PPC::EFSADD, RC: &PPC::GPRCRegClass, Op0, Op1);
3095 }
3096 if ((Subtarget->hasFPU())) {
3097 return fastEmitInst_rr(MachineInstOpcode: PPC::FADDS, RC: &PPC::F4RCRegClass, Op0, Op1);
3098 }
3099 return Register();
3100}
3101
3102Register fastEmit_ISD_FADD_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
3103 if (RetVT.SimpleTy != MVT::f64)
3104 return Register();
3105 if ((Subtarget->hasVSX())) {
3106 return fastEmitInst_rr(MachineInstOpcode: PPC::XSADDDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
3107 }
3108 if ((Subtarget->hasSPE())) {
3109 return fastEmitInst_rr(MachineInstOpcode: PPC::EFDADD, RC: &PPC::SPERCRegClass, Op0, Op1);
3110 }
3111 if ((Subtarget->hasFPU())) {
3112 return fastEmitInst_rr(MachineInstOpcode: PPC::FADD, RC: &PPC::F8RCRegClass, Op0, Op1);
3113 }
3114 return Register();
3115}
3116
3117Register fastEmit_ISD_FADD_MVT_f128_rr(MVT RetVT, Register Op0, Register Op1) {
3118 if (RetVT.SimpleTy != MVT::f128)
3119 return Register();
3120 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
3121 return fastEmitInst_rr(MachineInstOpcode: PPC::XSADDQP, RC: &PPC::VRRCRegClass, Op0, Op1);
3122 }
3123 return Register();
3124}
3125
3126Register fastEmit_ISD_FADD_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
3127 if (RetVT.SimpleTy != MVT::v4f32)
3128 return Register();
3129 if ((Subtarget->hasVSX())) {
3130 return fastEmitInst_rr(MachineInstOpcode: PPC::XVADDSP, RC: &PPC::VSRCRegClass, Op0, Op1);
3131 }
3132 if ((Subtarget->hasAltivec())) {
3133 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDFP, RC: &PPC::VRRCRegClass, Op0, Op1);
3134 }
3135 return Register();
3136}
3137
3138Register fastEmit_ISD_FADD_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
3139 if (RetVT.SimpleTy != MVT::v2f64)
3140 return Register();
3141 if ((Subtarget->hasVSX())) {
3142 return fastEmitInst_rr(MachineInstOpcode: PPC::XVADDDP, RC: &PPC::VSRCRegClass, Op0, Op1);
3143 }
3144 return Register();
3145}
3146
3147Register fastEmit_ISD_FADD_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3148 switch (VT.SimpleTy) {
3149 case MVT::f32: return fastEmit_ISD_FADD_MVT_f32_rr(RetVT, Op0, Op1);
3150 case MVT::f64: return fastEmit_ISD_FADD_MVT_f64_rr(RetVT, Op0, Op1);
3151 case MVT::f128: return fastEmit_ISD_FADD_MVT_f128_rr(RetVT, Op0, Op1);
3152 case MVT::v4f32: return fastEmit_ISD_FADD_MVT_v4f32_rr(RetVT, Op0, Op1);
3153 case MVT::v2f64: return fastEmit_ISD_FADD_MVT_v2f64_rr(RetVT, Op0, Op1);
3154 default: return Register();
3155 }
3156}
3157
3158// FastEmit functions for ISD::FDIV.
3159
3160Register fastEmit_ISD_FDIV_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
3161 if (RetVT.SimpleTy != MVT::f32)
3162 return Register();
3163 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
3164 return fastEmitInst_rr(MachineInstOpcode: PPC::XSDIVSP, RC: &PPC::VSSRCRegClass, Op0, Op1);
3165 }
3166 if ((Subtarget->hasSPE())) {
3167 return fastEmitInst_rr(MachineInstOpcode: PPC::EFSDIV, RC: &PPC::GPRCRegClass, Op0, Op1);
3168 }
3169 if ((Subtarget->hasFPU())) {
3170 return fastEmitInst_rr(MachineInstOpcode: PPC::FDIVS, RC: &PPC::F4RCRegClass, Op0, Op1);
3171 }
3172 return Register();
3173}
3174
3175Register fastEmit_ISD_FDIV_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
3176 if (RetVT.SimpleTy != MVT::f64)
3177 return Register();
3178 if ((Subtarget->hasVSX())) {
3179 return fastEmitInst_rr(MachineInstOpcode: PPC::XSDIVDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
3180 }
3181 if ((Subtarget->hasSPE())) {
3182 return fastEmitInst_rr(MachineInstOpcode: PPC::EFDDIV, RC: &PPC::SPERCRegClass, Op0, Op1);
3183 }
3184 if ((Subtarget->hasFPU())) {
3185 return fastEmitInst_rr(MachineInstOpcode: PPC::FDIV, RC: &PPC::F8RCRegClass, Op0, Op1);
3186 }
3187 return Register();
3188}
3189
3190Register fastEmit_ISD_FDIV_MVT_f128_rr(MVT RetVT, Register Op0, Register Op1) {
3191 if (RetVT.SimpleTy != MVT::f128)
3192 return Register();
3193 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
3194 return fastEmitInst_rr(MachineInstOpcode: PPC::XSDIVQP, RC: &PPC::VRRCRegClass, Op0, Op1);
3195 }
3196 return Register();
3197}
3198
3199Register fastEmit_ISD_FDIV_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
3200 if (RetVT.SimpleTy != MVT::v4f32)
3201 return Register();
3202 if ((Subtarget->hasVSX())) {
3203 return fastEmitInst_rr(MachineInstOpcode: PPC::XVDIVSP, RC: &PPC::VSRCRegClass, Op0, Op1);
3204 }
3205 return Register();
3206}
3207
3208Register fastEmit_ISD_FDIV_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
3209 if (RetVT.SimpleTy != MVT::v2f64)
3210 return Register();
3211 if ((Subtarget->hasVSX())) {
3212 return fastEmitInst_rr(MachineInstOpcode: PPC::XVDIVDP, RC: &PPC::VSRCRegClass, Op0, Op1);
3213 }
3214 return Register();
3215}
3216
3217Register fastEmit_ISD_FDIV_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3218 switch (VT.SimpleTy) {
3219 case MVT::f32: return fastEmit_ISD_FDIV_MVT_f32_rr(RetVT, Op0, Op1);
3220 case MVT::f64: return fastEmit_ISD_FDIV_MVT_f64_rr(RetVT, Op0, Op1);
3221 case MVT::f128: return fastEmit_ISD_FDIV_MVT_f128_rr(RetVT, Op0, Op1);
3222 case MVT::v4f32: return fastEmit_ISD_FDIV_MVT_v4f32_rr(RetVT, Op0, Op1);
3223 case MVT::v2f64: return fastEmit_ISD_FDIV_MVT_v2f64_rr(RetVT, Op0, Op1);
3224 default: return Register();
3225 }
3226}
3227
3228// FastEmit functions for ISD::FMAXNUM.
3229
3230Register fastEmit_ISD_FMAXNUM_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
3231 if (RetVT.SimpleTy != MVT::f64)
3232 return Register();
3233 if ((Subtarget->hasVSX())) {
3234 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMAXDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
3235 }
3236 return Register();
3237}
3238
3239Register fastEmit_ISD_FMAXNUM_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
3240 if (RetVT.SimpleTy != MVT::v4f32)
3241 return Register();
3242 if ((Subtarget->hasVSX())) {
3243 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMAXSP, RC: &PPC::VSRCRegClass, Op0, Op1);
3244 }
3245 return Register();
3246}
3247
3248Register fastEmit_ISD_FMAXNUM_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
3249 if (RetVT.SimpleTy != MVT::v2f64)
3250 return Register();
3251 if ((Subtarget->hasVSX())) {
3252 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMAXDP, RC: &PPC::VSRCRegClass, Op0, Op1);
3253 }
3254 return Register();
3255}
3256
3257Register fastEmit_ISD_FMAXNUM_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3258 switch (VT.SimpleTy) {
3259 case MVT::f64: return fastEmit_ISD_FMAXNUM_MVT_f64_rr(RetVT, Op0, Op1);
3260 case MVT::v4f32: return fastEmit_ISD_FMAXNUM_MVT_v4f32_rr(RetVT, Op0, Op1);
3261 case MVT::v2f64: return fastEmit_ISD_FMAXNUM_MVT_v2f64_rr(RetVT, Op0, Op1);
3262 default: return Register();
3263 }
3264}
3265
3266// FastEmit functions for ISD::FMAXNUM_IEEE.
3267
3268Register fastEmit_ISD_FMAXNUM_IEEE_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
3269 if (RetVT.SimpleTy != MVT::f64)
3270 return Register();
3271 if ((Subtarget->hasVSX())) {
3272 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMAXDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
3273 }
3274 return Register();
3275}
3276
3277Register fastEmit_ISD_FMAXNUM_IEEE_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
3278 if (RetVT.SimpleTy != MVT::v4f32)
3279 return Register();
3280 if ((Subtarget->hasVSX())) {
3281 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMAXSP, RC: &PPC::VSRCRegClass, Op0, Op1);
3282 }
3283 return Register();
3284}
3285
3286Register fastEmit_ISD_FMAXNUM_IEEE_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
3287 if (RetVT.SimpleTy != MVT::v2f64)
3288 return Register();
3289 if ((Subtarget->hasVSX())) {
3290 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMAXDP, RC: &PPC::VSRCRegClass, Op0, Op1);
3291 }
3292 return Register();
3293}
3294
3295Register fastEmit_ISD_FMAXNUM_IEEE_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3296 switch (VT.SimpleTy) {
3297 case MVT::f64: return fastEmit_ISD_FMAXNUM_IEEE_MVT_f64_rr(RetVT, Op0, Op1);
3298 case MVT::v4f32: return fastEmit_ISD_FMAXNUM_IEEE_MVT_v4f32_rr(RetVT, Op0, Op1);
3299 case MVT::v2f64: return fastEmit_ISD_FMAXNUM_IEEE_MVT_v2f64_rr(RetVT, Op0, Op1);
3300 default: return Register();
3301 }
3302}
3303
3304// FastEmit functions for ISD::FMINNUM.
3305
3306Register fastEmit_ISD_FMINNUM_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
3307 if (RetVT.SimpleTy != MVT::f64)
3308 return Register();
3309 if ((Subtarget->hasVSX())) {
3310 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMINDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
3311 }
3312 return Register();
3313}
3314
3315Register fastEmit_ISD_FMINNUM_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
3316 if (RetVT.SimpleTy != MVT::v4f32)
3317 return Register();
3318 if ((Subtarget->hasVSX())) {
3319 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMINSP, RC: &PPC::VSRCRegClass, Op0, Op1);
3320 }
3321 return Register();
3322}
3323
3324Register fastEmit_ISD_FMINNUM_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
3325 if (RetVT.SimpleTy != MVT::v2f64)
3326 return Register();
3327 if ((Subtarget->hasVSX())) {
3328 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMINDP, RC: &PPC::VSRCRegClass, Op0, Op1);
3329 }
3330 return Register();
3331}
3332
3333Register fastEmit_ISD_FMINNUM_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3334 switch (VT.SimpleTy) {
3335 case MVT::f64: return fastEmit_ISD_FMINNUM_MVT_f64_rr(RetVT, Op0, Op1);
3336 case MVT::v4f32: return fastEmit_ISD_FMINNUM_MVT_v4f32_rr(RetVT, Op0, Op1);
3337 case MVT::v2f64: return fastEmit_ISD_FMINNUM_MVT_v2f64_rr(RetVT, Op0, Op1);
3338 default: return Register();
3339 }
3340}
3341
3342// FastEmit functions for ISD::FMINNUM_IEEE.
3343
3344Register fastEmit_ISD_FMINNUM_IEEE_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
3345 if (RetVT.SimpleTy != MVT::f64)
3346 return Register();
3347 if ((Subtarget->hasVSX())) {
3348 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMINDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
3349 }
3350 return Register();
3351}
3352
3353Register fastEmit_ISD_FMINNUM_IEEE_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
3354 if (RetVT.SimpleTy != MVT::v4f32)
3355 return Register();
3356 if ((Subtarget->hasVSX())) {
3357 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMINSP, RC: &PPC::VSRCRegClass, Op0, Op1);
3358 }
3359 return Register();
3360}
3361
3362Register fastEmit_ISD_FMINNUM_IEEE_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
3363 if (RetVT.SimpleTy != MVT::v2f64)
3364 return Register();
3365 if ((Subtarget->hasVSX())) {
3366 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMINDP, RC: &PPC::VSRCRegClass, Op0, Op1);
3367 }
3368 return Register();
3369}
3370
3371Register fastEmit_ISD_FMINNUM_IEEE_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3372 switch (VT.SimpleTy) {
3373 case MVT::f64: return fastEmit_ISD_FMINNUM_IEEE_MVT_f64_rr(RetVT, Op0, Op1);
3374 case MVT::v4f32: return fastEmit_ISD_FMINNUM_IEEE_MVT_v4f32_rr(RetVT, Op0, Op1);
3375 case MVT::v2f64: return fastEmit_ISD_FMINNUM_IEEE_MVT_v2f64_rr(RetVT, Op0, Op1);
3376 default: return Register();
3377 }
3378}
3379
3380// FastEmit functions for ISD::FMUL.
3381
3382Register fastEmit_ISD_FMUL_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
3383 if (RetVT.SimpleTy != MVT::f32)
3384 return Register();
3385 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
3386 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMULSP, RC: &PPC::VSSRCRegClass, Op0, Op1);
3387 }
3388 if ((Subtarget->hasSPE())) {
3389 return fastEmitInst_rr(MachineInstOpcode: PPC::EFSMUL, RC: &PPC::GPRCRegClass, Op0, Op1);
3390 }
3391 if ((Subtarget->hasFPU())) {
3392 return fastEmitInst_rr(MachineInstOpcode: PPC::FMULS, RC: &PPC::F4RCRegClass, Op0, Op1);
3393 }
3394 return Register();
3395}
3396
3397Register fastEmit_ISD_FMUL_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
3398 if (RetVT.SimpleTy != MVT::f64)
3399 return Register();
3400 if ((Subtarget->hasVSX())) {
3401 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMULDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
3402 }
3403 if ((Subtarget->hasSPE())) {
3404 return fastEmitInst_rr(MachineInstOpcode: PPC::EFDMUL, RC: &PPC::SPERCRegClass, Op0, Op1);
3405 }
3406 if ((Subtarget->hasFPU())) {
3407 return fastEmitInst_rr(MachineInstOpcode: PPC::FMUL, RC: &PPC::F8RCRegClass, Op0, Op1);
3408 }
3409 return Register();
3410}
3411
3412Register fastEmit_ISD_FMUL_MVT_f128_rr(MVT RetVT, Register Op0, Register Op1) {
3413 if (RetVT.SimpleTy != MVT::f128)
3414 return Register();
3415 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
3416 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMULQP, RC: &PPC::VRRCRegClass, Op0, Op1);
3417 }
3418 return Register();
3419}
3420
3421Register fastEmit_ISD_FMUL_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
3422 if (RetVT.SimpleTy != MVT::v4f32)
3423 return Register();
3424 if ((Subtarget->hasVSX())) {
3425 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMULSP, RC: &PPC::VSRCRegClass, Op0, Op1);
3426 }
3427 return Register();
3428}
3429
3430Register fastEmit_ISD_FMUL_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
3431 if (RetVT.SimpleTy != MVT::v2f64)
3432 return Register();
3433 if ((Subtarget->hasVSX())) {
3434 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMULDP, RC: &PPC::VSRCRegClass, Op0, Op1);
3435 }
3436 return Register();
3437}
3438
3439Register fastEmit_ISD_FMUL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3440 switch (VT.SimpleTy) {
3441 case MVT::f32: return fastEmit_ISD_FMUL_MVT_f32_rr(RetVT, Op0, Op1);
3442 case MVT::f64: return fastEmit_ISD_FMUL_MVT_f64_rr(RetVT, Op0, Op1);
3443 case MVT::f128: return fastEmit_ISD_FMUL_MVT_f128_rr(RetVT, Op0, Op1);
3444 case MVT::v4f32: return fastEmit_ISD_FMUL_MVT_v4f32_rr(RetVT, Op0, Op1);
3445 case MVT::v2f64: return fastEmit_ISD_FMUL_MVT_v2f64_rr(RetVT, Op0, Op1);
3446 default: return Register();
3447 }
3448}
3449
3450// FastEmit functions for ISD::FSUB.
3451
3452Register fastEmit_ISD_FSUB_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
3453 if (RetVT.SimpleTy != MVT::f32)
3454 return Register();
3455 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
3456 return fastEmitInst_rr(MachineInstOpcode: PPC::XSSUBSP, RC: &PPC::VSSRCRegClass, Op0, Op1);
3457 }
3458 if ((Subtarget->hasSPE())) {
3459 return fastEmitInst_rr(MachineInstOpcode: PPC::EFSSUB, RC: &PPC::GPRCRegClass, Op0, Op1);
3460 }
3461 if ((Subtarget->hasFPU())) {
3462 return fastEmitInst_rr(MachineInstOpcode: PPC::FSUBS, RC: &PPC::F4RCRegClass, Op0, Op1);
3463 }
3464 return Register();
3465}
3466
3467Register fastEmit_ISD_FSUB_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
3468 if (RetVT.SimpleTy != MVT::f64)
3469 return Register();
3470 if ((Subtarget->hasVSX())) {
3471 return fastEmitInst_rr(MachineInstOpcode: PPC::XSSUBDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
3472 }
3473 if ((Subtarget->hasSPE())) {
3474 return fastEmitInst_rr(MachineInstOpcode: PPC::EFDSUB, RC: &PPC::SPERCRegClass, Op0, Op1);
3475 }
3476 if ((Subtarget->hasFPU())) {
3477 return fastEmitInst_rr(MachineInstOpcode: PPC::FSUB, RC: &PPC::F8RCRegClass, Op0, Op1);
3478 }
3479 return Register();
3480}
3481
3482Register fastEmit_ISD_FSUB_MVT_f128_rr(MVT RetVT, Register Op0, Register Op1) {
3483 if (RetVT.SimpleTy != MVT::f128)
3484 return Register();
3485 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
3486 return fastEmitInst_rr(MachineInstOpcode: PPC::XSSUBQP, RC: &PPC::VRRCRegClass, Op0, Op1);
3487 }
3488 return Register();
3489}
3490
3491Register fastEmit_ISD_FSUB_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
3492 if (RetVT.SimpleTy != MVT::v4f32)
3493 return Register();
3494 if ((Subtarget->hasVSX())) {
3495 return fastEmitInst_rr(MachineInstOpcode: PPC::XVSUBSP, RC: &PPC::VSRCRegClass, Op0, Op1);
3496 }
3497 if ((Subtarget->hasAltivec())) {
3498 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBFP, RC: &PPC::VRRCRegClass, Op0, Op1);
3499 }
3500 return Register();
3501}
3502
3503Register fastEmit_ISD_FSUB_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
3504 if (RetVT.SimpleTy != MVT::v2f64)
3505 return Register();
3506 if ((Subtarget->hasVSX())) {
3507 return fastEmitInst_rr(MachineInstOpcode: PPC::XVSUBDP, RC: &PPC::VSRCRegClass, Op0, Op1);
3508 }
3509 return Register();
3510}
3511
3512Register fastEmit_ISD_FSUB_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3513 switch (VT.SimpleTy) {
3514 case MVT::f32: return fastEmit_ISD_FSUB_MVT_f32_rr(RetVT, Op0, Op1);
3515 case MVT::f64: return fastEmit_ISD_FSUB_MVT_f64_rr(RetVT, Op0, Op1);
3516 case MVT::f128: return fastEmit_ISD_FSUB_MVT_f128_rr(RetVT, Op0, Op1);
3517 case MVT::v4f32: return fastEmit_ISD_FSUB_MVT_v4f32_rr(RetVT, Op0, Op1);
3518 case MVT::v2f64: return fastEmit_ISD_FSUB_MVT_v2f64_rr(RetVT, Op0, Op1);
3519 default: return Register();
3520 }
3521}
3522
3523// FastEmit functions for ISD::MUL.
3524
3525Register fastEmit_ISD_MUL_MVT_i1_rr(MVT RetVT, Register Op0, Register Op1) {
3526 if (RetVT.SimpleTy != MVT::i1)
3527 return Register();
3528 return fastEmitInst_rr(MachineInstOpcode: PPC::CRAND, RC: &PPC::CRBITRCRegClass, Op0, Op1);
3529}
3530
3531Register fastEmit_ISD_MUL_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
3532 if (RetVT.SimpleTy != MVT::i32)
3533 return Register();
3534 return fastEmitInst_rr(MachineInstOpcode: PPC::MULLW, RC: &PPC::GPRCRegClass, Op0, Op1);
3535}
3536
3537Register fastEmit_ISD_MUL_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
3538 if (RetVT.SimpleTy != MVT::i64)
3539 return Register();
3540 return fastEmitInst_rr(MachineInstOpcode: PPC::MULLD, RC: &PPC::G8RCRegClass, Op0, Op1);
3541}
3542
3543Register fastEmit_ISD_MUL_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3544 if (RetVT.SimpleTy != MVT::v4i32)
3545 return Register();
3546 if ((Subtarget->hasFutureVector())) {
3547 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMULUWM, RC: &PPC::VSRCRegClass, Op0, Op1);
3548 }
3549 if ((Subtarget->hasP8Altivec())) {
3550 return fastEmitInst_rr(MachineInstOpcode: PPC::VMULUWM, RC: &PPC::VRRCRegClass, Op0, Op1);
3551 }
3552 return Register();
3553}
3554
3555Register fastEmit_ISD_MUL_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
3556 if (RetVT.SimpleTy != MVT::v2i64)
3557 return Register();
3558 if ((Subtarget->isISA3_1())) {
3559 return fastEmitInst_rr(MachineInstOpcode: PPC::VMULLD, RC: &PPC::VRRCRegClass, Op0, Op1);
3560 }
3561 return Register();
3562}
3563
3564Register fastEmit_ISD_MUL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3565 switch (VT.SimpleTy) {
3566 case MVT::i1: return fastEmit_ISD_MUL_MVT_i1_rr(RetVT, Op0, Op1);
3567 case MVT::i32: return fastEmit_ISD_MUL_MVT_i32_rr(RetVT, Op0, Op1);
3568 case MVT::i64: return fastEmit_ISD_MUL_MVT_i64_rr(RetVT, Op0, Op1);
3569 case MVT::v4i32: return fastEmit_ISD_MUL_MVT_v4i32_rr(RetVT, Op0, Op1);
3570 case MVT::v2i64: return fastEmit_ISD_MUL_MVT_v2i64_rr(RetVT, Op0, Op1);
3571 default: return Register();
3572 }
3573}
3574
3575// FastEmit functions for ISD::MULHS.
3576
3577Register fastEmit_ISD_MULHS_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
3578 if (RetVT.SimpleTy != MVT::i32)
3579 return Register();
3580 return fastEmitInst_rr(MachineInstOpcode: PPC::MULHW, RC: &PPC::GPRCRegClass, Op0, Op1);
3581}
3582
3583Register fastEmit_ISD_MULHS_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
3584 if (RetVT.SimpleTy != MVT::i64)
3585 return Register();
3586 return fastEmitInst_rr(MachineInstOpcode: PPC::MULHD, RC: &PPC::G8RCRegClass, Op0, Op1);
3587}
3588
3589Register fastEmit_ISD_MULHS_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3590 if (RetVT.SimpleTy != MVT::v4i32)
3591 return Register();
3592 if ((Subtarget->isISA3_1())) {
3593 return fastEmitInst_rr(MachineInstOpcode: PPC::VMULHSW, RC: &PPC::VRRCRegClass, Op0, Op1);
3594 }
3595 return Register();
3596}
3597
3598Register fastEmit_ISD_MULHS_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
3599 if (RetVT.SimpleTy != MVT::v2i64)
3600 return Register();
3601 if ((Subtarget->isISA3_1())) {
3602 return fastEmitInst_rr(MachineInstOpcode: PPC::VMULHSD, RC: &PPC::VRRCRegClass, Op0, Op1);
3603 }
3604 return Register();
3605}
3606
3607Register fastEmit_ISD_MULHS_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3608 switch (VT.SimpleTy) {
3609 case MVT::i32: return fastEmit_ISD_MULHS_MVT_i32_rr(RetVT, Op0, Op1);
3610 case MVT::i64: return fastEmit_ISD_MULHS_MVT_i64_rr(RetVT, Op0, Op1);
3611 case MVT::v4i32: return fastEmit_ISD_MULHS_MVT_v4i32_rr(RetVT, Op0, Op1);
3612 case MVT::v2i64: return fastEmit_ISD_MULHS_MVT_v2i64_rr(RetVT, Op0, Op1);
3613 default: return Register();
3614 }
3615}
3616
3617// FastEmit functions for ISD::MULHU.
3618
3619Register fastEmit_ISD_MULHU_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
3620 if (RetVT.SimpleTy != MVT::i32)
3621 return Register();
3622 return fastEmitInst_rr(MachineInstOpcode: PPC::MULHWU, RC: &PPC::GPRCRegClass, Op0, Op1);
3623}
3624
3625Register fastEmit_ISD_MULHU_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
3626 if (RetVT.SimpleTy != MVT::i64)
3627 return Register();
3628 return fastEmitInst_rr(MachineInstOpcode: PPC::MULHDU, RC: &PPC::G8RCRegClass, Op0, Op1);
3629}
3630
3631Register fastEmit_ISD_MULHU_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3632 if (RetVT.SimpleTy != MVT::v4i32)
3633 return Register();
3634 if ((Subtarget->isISA3_1())) {
3635 return fastEmitInst_rr(MachineInstOpcode: PPC::VMULHUW, RC: &PPC::VRRCRegClass, Op0, Op1);
3636 }
3637 return Register();
3638}
3639
3640Register fastEmit_ISD_MULHU_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
3641 if (RetVT.SimpleTy != MVT::v2i64)
3642 return Register();
3643 if ((Subtarget->isISA3_1())) {
3644 return fastEmitInst_rr(MachineInstOpcode: PPC::VMULHUD, RC: &PPC::VRRCRegClass, Op0, Op1);
3645 }
3646 return Register();
3647}
3648
3649Register fastEmit_ISD_MULHU_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3650 switch (VT.SimpleTy) {
3651 case MVT::i32: return fastEmit_ISD_MULHU_MVT_i32_rr(RetVT, Op0, Op1);
3652 case MVT::i64: return fastEmit_ISD_MULHU_MVT_i64_rr(RetVT, Op0, Op1);
3653 case MVT::v4i32: return fastEmit_ISD_MULHU_MVT_v4i32_rr(RetVT, Op0, Op1);
3654 case MVT::v2i64: return fastEmit_ISD_MULHU_MVT_v2i64_rr(RetVT, Op0, Op1);
3655 default: return Register();
3656 }
3657}
3658
3659// FastEmit functions for ISD::OR.
3660
3661Register fastEmit_ISD_OR_MVT_i1_rr(MVT RetVT, Register Op0, Register Op1) {
3662 if (RetVT.SimpleTy != MVT::i1)
3663 return Register();
3664 return fastEmitInst_rr(MachineInstOpcode: PPC::CROR, RC: &PPC::CRBITRCRegClass, Op0, Op1);
3665}
3666
3667Register fastEmit_ISD_OR_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
3668 if (RetVT.SimpleTy != MVT::i32)
3669 return Register();
3670 return fastEmitInst_rr(MachineInstOpcode: PPC::OR, RC: &PPC::GPRCRegClass, Op0, Op1);
3671}
3672
3673Register fastEmit_ISD_OR_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
3674 if (RetVT.SimpleTy != MVT::i64)
3675 return Register();
3676 return fastEmitInst_rr(MachineInstOpcode: PPC::OR8, RC: &PPC::G8RCRegClass, Op0, Op1);
3677}
3678
3679Register fastEmit_ISD_OR_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3680 if (RetVT.SimpleTy != MVT::v4i32)
3681 return Register();
3682 if ((Subtarget->hasVSX())) {
3683 return fastEmitInst_rr(MachineInstOpcode: PPC::XXLOR, RC: &PPC::VSRCRegClass, Op0, Op1);
3684 }
3685 if ((Subtarget->hasAltivec())) {
3686 return fastEmitInst_rr(MachineInstOpcode: PPC::VOR, RC: &PPC::VRRCRegClass, Op0, Op1);
3687 }
3688 return Register();
3689}
3690
3691Register fastEmit_ISD_OR_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3692 switch (VT.SimpleTy) {
3693 case MVT::i1: return fastEmit_ISD_OR_MVT_i1_rr(RetVT, Op0, Op1);
3694 case MVT::i32: return fastEmit_ISD_OR_MVT_i32_rr(RetVT, Op0, Op1);
3695 case MVT::i64: return fastEmit_ISD_OR_MVT_i64_rr(RetVT, Op0, Op1);
3696 case MVT::v4i32: return fastEmit_ISD_OR_MVT_v4i32_rr(RetVT, Op0, Op1);
3697 default: return Register();
3698 }
3699}
3700
3701// FastEmit functions for ISD::ROTL.
3702
3703Register fastEmit_ISD_ROTL_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
3704 if (RetVT.SimpleTy != MVT::v16i8)
3705 return Register();
3706 if ((Subtarget->hasAltivec())) {
3707 return fastEmitInst_rr(MachineInstOpcode: PPC::VRLB, RC: &PPC::VRRCRegClass, Op0, Op1);
3708 }
3709 return Register();
3710}
3711
3712Register fastEmit_ISD_ROTL_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
3713 if (RetVT.SimpleTy != MVT::v8i16)
3714 return Register();
3715 if ((Subtarget->hasAltivec())) {
3716 return fastEmitInst_rr(MachineInstOpcode: PPC::VRLH, RC: &PPC::VRRCRegClass, Op0, Op1);
3717 }
3718 return Register();
3719}
3720
3721Register fastEmit_ISD_ROTL_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3722 if (RetVT.SimpleTy != MVT::v4i32)
3723 return Register();
3724 if ((Subtarget->hasFutureVector())) {
3725 return fastEmitInst_rr(MachineInstOpcode: PPC::XVRLW, RC: &PPC::VSRCRegClass, Op0, Op1);
3726 }
3727 if ((!Subtarget->isISAFuture())) {
3728 return fastEmitInst_rr(MachineInstOpcode: PPC::VRLW, RC: &PPC::VRRCRegClass, Op0, Op1);
3729 }
3730 return Register();
3731}
3732
3733Register fastEmit_ISD_ROTL_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
3734 if (RetVT.SimpleTy != MVT::v2i64)
3735 return Register();
3736 if ((Subtarget->hasP8Altivec())) {
3737 return fastEmitInst_rr(MachineInstOpcode: PPC::VRLD, RC: &PPC::VRRCRegClass, Op0, Op1);
3738 }
3739 return Register();
3740}
3741
3742Register fastEmit_ISD_ROTL_MVT_v1i128_rr(MVT RetVT, Register Op0, Register Op1) {
3743 if (RetVT.SimpleTy != MVT::v1i128)
3744 return Register();
3745 if ((Subtarget->isISA3_1())) {
3746 return fastEmitInst_rr(MachineInstOpcode: PPC::VRLQ, RC: &PPC::VRRCRegClass, Op0, Op1);
3747 }
3748 return Register();
3749}
3750
3751Register fastEmit_ISD_ROTL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3752 switch (VT.SimpleTy) {
3753 case MVT::v16i8: return fastEmit_ISD_ROTL_MVT_v16i8_rr(RetVT, Op0, Op1);
3754 case MVT::v8i16: return fastEmit_ISD_ROTL_MVT_v8i16_rr(RetVT, Op0, Op1);
3755 case MVT::v4i32: return fastEmit_ISD_ROTL_MVT_v4i32_rr(RetVT, Op0, Op1);
3756 case MVT::v2i64: return fastEmit_ISD_ROTL_MVT_v2i64_rr(RetVT, Op0, Op1);
3757 case MVT::v1i128: return fastEmit_ISD_ROTL_MVT_v1i128_rr(RetVT, Op0, Op1);
3758 default: return Register();
3759 }
3760}
3761
3762// FastEmit functions for ISD::SADDSAT.
3763
3764Register fastEmit_ISD_SADDSAT_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
3765 if (RetVT.SimpleTy != MVT::v16i8)
3766 return Register();
3767 if ((Subtarget->hasAltivec())) {
3768 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDSBS, RC: &PPC::VRRCRegClass, Op0, Op1);
3769 }
3770 return Register();
3771}
3772
3773Register fastEmit_ISD_SADDSAT_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
3774 if (RetVT.SimpleTy != MVT::v8i16)
3775 return Register();
3776 if ((Subtarget->hasAltivec())) {
3777 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDSHS, RC: &PPC::VRRCRegClass, Op0, Op1);
3778 }
3779 return Register();
3780}
3781
3782Register fastEmit_ISD_SADDSAT_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3783 if (RetVT.SimpleTy != MVT::v4i32)
3784 return Register();
3785 if ((Subtarget->hasAltivec())) {
3786 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDSWS, RC: &PPC::VRRCRegClass, Op0, Op1);
3787 }
3788 return Register();
3789}
3790
3791Register fastEmit_ISD_SADDSAT_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3792 switch (VT.SimpleTy) {
3793 case MVT::v16i8: return fastEmit_ISD_SADDSAT_MVT_v16i8_rr(RetVT, Op0, Op1);
3794 case MVT::v8i16: return fastEmit_ISD_SADDSAT_MVT_v8i16_rr(RetVT, Op0, Op1);
3795 case MVT::v4i32: return fastEmit_ISD_SADDSAT_MVT_v4i32_rr(RetVT, Op0, Op1);
3796 default: return Register();
3797 }
3798}
3799
3800// FastEmit functions for ISD::SDIV.
3801
3802Register fastEmit_ISD_SDIV_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
3803 if (RetVT.SimpleTy != MVT::i32)
3804 return Register();
3805 return fastEmitInst_rr(MachineInstOpcode: PPC::DIVW, RC: &PPC::GPRCRegClass, Op0, Op1);
3806}
3807
3808Register fastEmit_ISD_SDIV_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
3809 if (RetVT.SimpleTy != MVT::i64)
3810 return Register();
3811 return fastEmitInst_rr(MachineInstOpcode: PPC::DIVD, RC: &PPC::G8RCRegClass, Op0, Op1);
3812}
3813
3814Register fastEmit_ISD_SDIV_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3815 if (RetVT.SimpleTy != MVT::v4i32)
3816 return Register();
3817 if ((Subtarget->isISA3_1())) {
3818 return fastEmitInst_rr(MachineInstOpcode: PPC::VDIVSW, RC: &PPC::VRRCRegClass, Op0, Op1);
3819 }
3820 return Register();
3821}
3822
3823Register fastEmit_ISD_SDIV_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
3824 if (RetVT.SimpleTy != MVT::v2i64)
3825 return Register();
3826 if ((Subtarget->isISA3_1())) {
3827 return fastEmitInst_rr(MachineInstOpcode: PPC::VDIVSD, RC: &PPC::VRRCRegClass, Op0, Op1);
3828 }
3829 return Register();
3830}
3831
3832Register fastEmit_ISD_SDIV_MVT_v1i128_rr(MVT RetVT, Register Op0, Register Op1) {
3833 if (RetVT.SimpleTy != MVT::v1i128)
3834 return Register();
3835 if ((Subtarget->isISA3_1())) {
3836 return fastEmitInst_rr(MachineInstOpcode: PPC::VDIVSQ, RC: &PPC::VRRCRegClass, Op0, Op1);
3837 }
3838 return Register();
3839}
3840
3841Register fastEmit_ISD_SDIV_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3842 switch (VT.SimpleTy) {
3843 case MVT::i32: return fastEmit_ISD_SDIV_MVT_i32_rr(RetVT, Op0, Op1);
3844 case MVT::i64: return fastEmit_ISD_SDIV_MVT_i64_rr(RetVT, Op0, Op1);
3845 case MVT::v4i32: return fastEmit_ISD_SDIV_MVT_v4i32_rr(RetVT, Op0, Op1);
3846 case MVT::v2i64: return fastEmit_ISD_SDIV_MVT_v2i64_rr(RetVT, Op0, Op1);
3847 case MVT::v1i128: return fastEmit_ISD_SDIV_MVT_v1i128_rr(RetVT, Op0, Op1);
3848 default: return Register();
3849 }
3850}
3851
3852// FastEmit functions for ISD::SHL.
3853
3854Register fastEmit_ISD_SHL_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
3855 if (RetVT.SimpleTy != MVT::i32)
3856 return Register();
3857 return fastEmitInst_rr(MachineInstOpcode: PPC::SLW, RC: &PPC::GPRCRegClass, Op0, Op1);
3858}
3859
3860Register fastEmit_ISD_SHL_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
3861 if (RetVT.SimpleTy != MVT::v16i8)
3862 return Register();
3863 if ((Subtarget->hasAltivec())) {
3864 return fastEmitInst_rr(MachineInstOpcode: PPC::VSLB, RC: &PPC::VRRCRegClass, Op0, Op1);
3865 }
3866 return Register();
3867}
3868
3869Register fastEmit_ISD_SHL_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
3870 if (RetVT.SimpleTy != MVT::v8i16)
3871 return Register();
3872 if ((Subtarget->hasAltivec())) {
3873 return fastEmitInst_rr(MachineInstOpcode: PPC::VSLH, RC: &PPC::VRRCRegClass, Op0, Op1);
3874 }
3875 return Register();
3876}
3877
3878Register fastEmit_ISD_SHL_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3879 if (RetVT.SimpleTy != MVT::v4i32)
3880 return Register();
3881 if ((Subtarget->hasAltivec())) {
3882 return fastEmitInst_rr(MachineInstOpcode: PPC::VSLW, RC: &PPC::VRRCRegClass, Op0, Op1);
3883 }
3884 return Register();
3885}
3886
3887Register fastEmit_ISD_SHL_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
3888 if (RetVT.SimpleTy != MVT::v2i64)
3889 return Register();
3890 if ((Subtarget->hasP8Altivec())) {
3891 return fastEmitInst_rr(MachineInstOpcode: PPC::VSLD, RC: &PPC::VRRCRegClass, Op0, Op1);
3892 }
3893 return Register();
3894}
3895
3896Register fastEmit_ISD_SHL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3897 switch (VT.SimpleTy) {
3898 case MVT::i32: return fastEmit_ISD_SHL_MVT_i32_rr(RetVT, Op0, Op1);
3899 case MVT::v16i8: return fastEmit_ISD_SHL_MVT_v16i8_rr(RetVT, Op0, Op1);
3900 case MVT::v8i16: return fastEmit_ISD_SHL_MVT_v8i16_rr(RetVT, Op0, Op1);
3901 case MVT::v4i32: return fastEmit_ISD_SHL_MVT_v4i32_rr(RetVT, Op0, Op1);
3902 case MVT::v2i64: return fastEmit_ISD_SHL_MVT_v2i64_rr(RetVT, Op0, Op1);
3903 default: return Register();
3904 }
3905}
3906
3907// FastEmit functions for ISD::SMAX.
3908
3909Register fastEmit_ISD_SMAX_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
3910 if (RetVT.SimpleTy != MVT::v16i8)
3911 return Register();
3912 if ((Subtarget->hasAltivec())) {
3913 return fastEmitInst_rr(MachineInstOpcode: PPC::VMAXSB, RC: &PPC::VRRCRegClass, Op0, Op1);
3914 }
3915 return Register();
3916}
3917
3918Register fastEmit_ISD_SMAX_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
3919 if (RetVT.SimpleTy != MVT::v8i16)
3920 return Register();
3921 if ((Subtarget->hasAltivec())) {
3922 return fastEmitInst_rr(MachineInstOpcode: PPC::VMAXSH, RC: &PPC::VRRCRegClass, Op0, Op1);
3923 }
3924 return Register();
3925}
3926
3927Register fastEmit_ISD_SMAX_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3928 if (RetVT.SimpleTy != MVT::v4i32)
3929 return Register();
3930 if ((Subtarget->hasAltivec())) {
3931 return fastEmitInst_rr(MachineInstOpcode: PPC::VMAXSW, RC: &PPC::VRRCRegClass, Op0, Op1);
3932 }
3933 return Register();
3934}
3935
3936Register fastEmit_ISD_SMAX_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3937 switch (VT.SimpleTy) {
3938 case MVT::v16i8: return fastEmit_ISD_SMAX_MVT_v16i8_rr(RetVT, Op0, Op1);
3939 case MVT::v8i16: return fastEmit_ISD_SMAX_MVT_v8i16_rr(RetVT, Op0, Op1);
3940 case MVT::v4i32: return fastEmit_ISD_SMAX_MVT_v4i32_rr(RetVT, Op0, Op1);
3941 default: return Register();
3942 }
3943}
3944
3945// FastEmit functions for ISD::SMIN.
3946
3947Register fastEmit_ISD_SMIN_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
3948 if (RetVT.SimpleTy != MVT::v16i8)
3949 return Register();
3950 if ((Subtarget->hasAltivec())) {
3951 return fastEmitInst_rr(MachineInstOpcode: PPC::VMINSB, RC: &PPC::VRRCRegClass, Op0, Op1);
3952 }
3953 return Register();
3954}
3955
3956Register fastEmit_ISD_SMIN_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
3957 if (RetVT.SimpleTy != MVT::v8i16)
3958 return Register();
3959 if ((Subtarget->hasAltivec())) {
3960 return fastEmitInst_rr(MachineInstOpcode: PPC::VMINSH, RC: &PPC::VRRCRegClass, Op0, Op1);
3961 }
3962 return Register();
3963}
3964
3965Register fastEmit_ISD_SMIN_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
3966 if (RetVT.SimpleTy != MVT::v4i32)
3967 return Register();
3968 if ((Subtarget->hasAltivec())) {
3969 return fastEmitInst_rr(MachineInstOpcode: PPC::VMINSW, RC: &PPC::VRRCRegClass, Op0, Op1);
3970 }
3971 return Register();
3972}
3973
3974Register fastEmit_ISD_SMIN_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
3975 switch (VT.SimpleTy) {
3976 case MVT::v16i8: return fastEmit_ISD_SMIN_MVT_v16i8_rr(RetVT, Op0, Op1);
3977 case MVT::v8i16: return fastEmit_ISD_SMIN_MVT_v8i16_rr(RetVT, Op0, Op1);
3978 case MVT::v4i32: return fastEmit_ISD_SMIN_MVT_v4i32_rr(RetVT, Op0, Op1);
3979 default: return Register();
3980 }
3981}
3982
3983// FastEmit functions for ISD::SRA.
3984
3985Register fastEmit_ISD_SRA_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
3986 if (RetVT.SimpleTy != MVT::i32)
3987 return Register();
3988 return fastEmitInst_rr(MachineInstOpcode: PPC::SRAW, RC: &PPC::GPRCRegClass, Op0, Op1);
3989}
3990
3991Register fastEmit_ISD_SRA_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
3992 if (RetVT.SimpleTy != MVT::v16i8)
3993 return Register();
3994 if ((Subtarget->hasAltivec())) {
3995 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRAB, RC: &PPC::VRRCRegClass, Op0, Op1);
3996 }
3997 return Register();
3998}
3999
4000Register fastEmit_ISD_SRA_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
4001 if (RetVT.SimpleTy != MVT::v8i16)
4002 return Register();
4003 if ((Subtarget->hasAltivec())) {
4004 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRAH, RC: &PPC::VRRCRegClass, Op0, Op1);
4005 }
4006 return Register();
4007}
4008
4009Register fastEmit_ISD_SRA_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4010 if (RetVT.SimpleTy != MVT::v4i32)
4011 return Register();
4012 if ((Subtarget->hasAltivec())) {
4013 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRAW, RC: &PPC::VRRCRegClass, Op0, Op1);
4014 }
4015 return Register();
4016}
4017
4018Register fastEmit_ISD_SRA_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
4019 if (RetVT.SimpleTy != MVT::v2i64)
4020 return Register();
4021 if ((Subtarget->hasP8Altivec())) {
4022 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRAD, RC: &PPC::VRRCRegClass, Op0, Op1);
4023 }
4024 return Register();
4025}
4026
4027Register fastEmit_ISD_SRA_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4028 switch (VT.SimpleTy) {
4029 case MVT::i32: return fastEmit_ISD_SRA_MVT_i32_rr(RetVT, Op0, Op1);
4030 case MVT::v16i8: return fastEmit_ISD_SRA_MVT_v16i8_rr(RetVT, Op0, Op1);
4031 case MVT::v8i16: return fastEmit_ISD_SRA_MVT_v8i16_rr(RetVT, Op0, Op1);
4032 case MVT::v4i32: return fastEmit_ISD_SRA_MVT_v4i32_rr(RetVT, Op0, Op1);
4033 case MVT::v2i64: return fastEmit_ISD_SRA_MVT_v2i64_rr(RetVT, Op0, Op1);
4034 default: return Register();
4035 }
4036}
4037
4038// FastEmit functions for ISD::SREM.
4039
4040Register fastEmit_ISD_SREM_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
4041 if (RetVT.SimpleTy != MVT::i32)
4042 return Register();
4043 if ((Subtarget->isISA3_0())) {
4044 return fastEmitInst_rr(MachineInstOpcode: PPC::MODSW, RC: &PPC::GPRCRegClass, Op0, Op1);
4045 }
4046 return Register();
4047}
4048
4049Register fastEmit_ISD_SREM_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
4050 if (RetVT.SimpleTy != MVT::i64)
4051 return Register();
4052 if ((Subtarget->isISA3_0())) {
4053 return fastEmitInst_rr(MachineInstOpcode: PPC::MODSD, RC: &PPC::G8RCRegClass, Op0, Op1);
4054 }
4055 return Register();
4056}
4057
4058Register fastEmit_ISD_SREM_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4059 if (RetVT.SimpleTy != MVT::v4i32)
4060 return Register();
4061 if ((Subtarget->isISA3_1())) {
4062 return fastEmitInst_rr(MachineInstOpcode: PPC::VMODSW, RC: &PPC::VRRCRegClass, Op0, Op1);
4063 }
4064 return Register();
4065}
4066
4067Register fastEmit_ISD_SREM_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
4068 if (RetVT.SimpleTy != MVT::v2i64)
4069 return Register();
4070 if ((Subtarget->isISA3_1())) {
4071 return fastEmitInst_rr(MachineInstOpcode: PPC::VMODSD, RC: &PPC::VRRCRegClass, Op0, Op1);
4072 }
4073 return Register();
4074}
4075
4076Register fastEmit_ISD_SREM_MVT_v1i128_rr(MVT RetVT, Register Op0, Register Op1) {
4077 if (RetVT.SimpleTy != MVT::v1i128)
4078 return Register();
4079 if ((Subtarget->isISA3_1())) {
4080 return fastEmitInst_rr(MachineInstOpcode: PPC::VMODSQ, RC: &PPC::VRRCRegClass, Op0, Op1);
4081 }
4082 return Register();
4083}
4084
4085Register fastEmit_ISD_SREM_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4086 switch (VT.SimpleTy) {
4087 case MVT::i32: return fastEmit_ISD_SREM_MVT_i32_rr(RetVT, Op0, Op1);
4088 case MVT::i64: return fastEmit_ISD_SREM_MVT_i64_rr(RetVT, Op0, Op1);
4089 case MVT::v4i32: return fastEmit_ISD_SREM_MVT_v4i32_rr(RetVT, Op0, Op1);
4090 case MVT::v2i64: return fastEmit_ISD_SREM_MVT_v2i64_rr(RetVT, Op0, Op1);
4091 case MVT::v1i128: return fastEmit_ISD_SREM_MVT_v1i128_rr(RetVT, Op0, Op1);
4092 default: return Register();
4093 }
4094}
4095
4096// FastEmit functions for ISD::SRL.
4097
4098Register fastEmit_ISD_SRL_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
4099 if (RetVT.SimpleTy != MVT::i32)
4100 return Register();
4101 return fastEmitInst_rr(MachineInstOpcode: PPC::SRW, RC: &PPC::GPRCRegClass, Op0, Op1);
4102}
4103
4104Register fastEmit_ISD_SRL_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
4105 if (RetVT.SimpleTy != MVT::v16i8)
4106 return Register();
4107 if ((Subtarget->hasAltivec())) {
4108 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRB, RC: &PPC::VRRCRegClass, Op0, Op1);
4109 }
4110 return Register();
4111}
4112
4113Register fastEmit_ISD_SRL_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
4114 if (RetVT.SimpleTy != MVT::v8i16)
4115 return Register();
4116 if ((Subtarget->hasAltivec())) {
4117 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRH, RC: &PPC::VRRCRegClass, Op0, Op1);
4118 }
4119 return Register();
4120}
4121
4122Register fastEmit_ISD_SRL_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4123 if (RetVT.SimpleTy != MVT::v4i32)
4124 return Register();
4125 if ((Subtarget->hasAltivec())) {
4126 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRW, RC: &PPC::VRRCRegClass, Op0, Op1);
4127 }
4128 return Register();
4129}
4130
4131Register fastEmit_ISD_SRL_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
4132 if (RetVT.SimpleTy != MVT::v2i64)
4133 return Register();
4134 if ((Subtarget->hasP8Altivec())) {
4135 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRD, RC: &PPC::VRRCRegClass, Op0, Op1);
4136 }
4137 return Register();
4138}
4139
4140Register fastEmit_ISD_SRL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4141 switch (VT.SimpleTy) {
4142 case MVT::i32: return fastEmit_ISD_SRL_MVT_i32_rr(RetVT, Op0, Op1);
4143 case MVT::v16i8: return fastEmit_ISD_SRL_MVT_v16i8_rr(RetVT, Op0, Op1);
4144 case MVT::v8i16: return fastEmit_ISD_SRL_MVT_v8i16_rr(RetVT, Op0, Op1);
4145 case MVT::v4i32: return fastEmit_ISD_SRL_MVT_v4i32_rr(RetVT, Op0, Op1);
4146 case MVT::v2i64: return fastEmit_ISD_SRL_MVT_v2i64_rr(RetVT, Op0, Op1);
4147 default: return Register();
4148 }
4149}
4150
4151// FastEmit functions for ISD::SSUBSAT.
4152
4153Register fastEmit_ISD_SSUBSAT_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
4154 if (RetVT.SimpleTy != MVT::v16i8)
4155 return Register();
4156 if ((Subtarget->hasAltivec())) {
4157 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBSBS, RC: &PPC::VRRCRegClass, Op0, Op1);
4158 }
4159 return Register();
4160}
4161
4162Register fastEmit_ISD_SSUBSAT_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
4163 if (RetVT.SimpleTy != MVT::v8i16)
4164 return Register();
4165 if ((Subtarget->hasAltivec())) {
4166 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBSHS, RC: &PPC::VRRCRegClass, Op0, Op1);
4167 }
4168 return Register();
4169}
4170
4171Register fastEmit_ISD_SSUBSAT_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4172 if (RetVT.SimpleTy != MVT::v4i32)
4173 return Register();
4174 if ((Subtarget->hasAltivec())) {
4175 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBSWS, RC: &PPC::VRRCRegClass, Op0, Op1);
4176 }
4177 return Register();
4178}
4179
4180Register fastEmit_ISD_SSUBSAT_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4181 switch (VT.SimpleTy) {
4182 case MVT::v16i8: return fastEmit_ISD_SSUBSAT_MVT_v16i8_rr(RetVT, Op0, Op1);
4183 case MVT::v8i16: return fastEmit_ISD_SSUBSAT_MVT_v8i16_rr(RetVT, Op0, Op1);
4184 case MVT::v4i32: return fastEmit_ISD_SSUBSAT_MVT_v4i32_rr(RetVT, Op0, Op1);
4185 default: return Register();
4186 }
4187}
4188
4189// FastEmit functions for ISD::STRICT_FADD.
4190
4191Register fastEmit_ISD_STRICT_FADD_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
4192 if (RetVT.SimpleTy != MVT::f32)
4193 return Register();
4194 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
4195 return fastEmitInst_rr(MachineInstOpcode: PPC::XSADDSP, RC: &PPC::VSSRCRegClass, Op0, Op1);
4196 }
4197 if ((Subtarget->hasSPE())) {
4198 return fastEmitInst_rr(MachineInstOpcode: PPC::EFSADD, RC: &PPC::GPRCRegClass, Op0, Op1);
4199 }
4200 if ((Subtarget->hasFPU())) {
4201 return fastEmitInst_rr(MachineInstOpcode: PPC::FADDS, RC: &PPC::F4RCRegClass, Op0, Op1);
4202 }
4203 return Register();
4204}
4205
4206Register fastEmit_ISD_STRICT_FADD_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
4207 if (RetVT.SimpleTy != MVT::f64)
4208 return Register();
4209 if ((Subtarget->hasVSX())) {
4210 return fastEmitInst_rr(MachineInstOpcode: PPC::XSADDDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
4211 }
4212 if ((Subtarget->hasSPE())) {
4213 return fastEmitInst_rr(MachineInstOpcode: PPC::EFDADD, RC: &PPC::SPERCRegClass, Op0, Op1);
4214 }
4215 if ((Subtarget->hasFPU())) {
4216 return fastEmitInst_rr(MachineInstOpcode: PPC::FADD, RC: &PPC::F8RCRegClass, Op0, Op1);
4217 }
4218 return Register();
4219}
4220
4221Register fastEmit_ISD_STRICT_FADD_MVT_f128_rr(MVT RetVT, Register Op0, Register Op1) {
4222 if (RetVT.SimpleTy != MVT::f128)
4223 return Register();
4224 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
4225 return fastEmitInst_rr(MachineInstOpcode: PPC::XSADDQP, RC: &PPC::VRRCRegClass, Op0, Op1);
4226 }
4227 return Register();
4228}
4229
4230Register fastEmit_ISD_STRICT_FADD_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
4231 if (RetVT.SimpleTy != MVT::v4f32)
4232 return Register();
4233 if ((Subtarget->hasVSX())) {
4234 return fastEmitInst_rr(MachineInstOpcode: PPC::XVADDSP, RC: &PPC::VSRCRegClass, Op0, Op1);
4235 }
4236 return Register();
4237}
4238
4239Register fastEmit_ISD_STRICT_FADD_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
4240 if (RetVT.SimpleTy != MVT::v2f64)
4241 return Register();
4242 if ((Subtarget->hasVSX())) {
4243 return fastEmitInst_rr(MachineInstOpcode: PPC::XVADDDP, RC: &PPC::VSRCRegClass, Op0, Op1);
4244 }
4245 return Register();
4246}
4247
4248Register fastEmit_ISD_STRICT_FADD_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4249 switch (VT.SimpleTy) {
4250 case MVT::f32: return fastEmit_ISD_STRICT_FADD_MVT_f32_rr(RetVT, Op0, Op1);
4251 case MVT::f64: return fastEmit_ISD_STRICT_FADD_MVT_f64_rr(RetVT, Op0, Op1);
4252 case MVT::f128: return fastEmit_ISD_STRICT_FADD_MVT_f128_rr(RetVT, Op0, Op1);
4253 case MVT::v4f32: return fastEmit_ISD_STRICT_FADD_MVT_v4f32_rr(RetVT, Op0, Op1);
4254 case MVT::v2f64: return fastEmit_ISD_STRICT_FADD_MVT_v2f64_rr(RetVT, Op0, Op1);
4255 default: return Register();
4256 }
4257}
4258
4259// FastEmit functions for ISD::STRICT_FDIV.
4260
4261Register fastEmit_ISD_STRICT_FDIV_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
4262 if (RetVT.SimpleTy != MVT::f32)
4263 return Register();
4264 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
4265 return fastEmitInst_rr(MachineInstOpcode: PPC::XSDIVSP, RC: &PPC::VSSRCRegClass, Op0, Op1);
4266 }
4267 if ((Subtarget->hasSPE())) {
4268 return fastEmitInst_rr(MachineInstOpcode: PPC::EFSDIV, RC: &PPC::GPRCRegClass, Op0, Op1);
4269 }
4270 if ((Subtarget->hasFPU())) {
4271 return fastEmitInst_rr(MachineInstOpcode: PPC::FDIVS, RC: &PPC::F4RCRegClass, Op0, Op1);
4272 }
4273 return Register();
4274}
4275
4276Register fastEmit_ISD_STRICT_FDIV_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
4277 if (RetVT.SimpleTy != MVT::f64)
4278 return Register();
4279 if ((Subtarget->hasVSX())) {
4280 return fastEmitInst_rr(MachineInstOpcode: PPC::XSDIVDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
4281 }
4282 if ((Subtarget->hasSPE())) {
4283 return fastEmitInst_rr(MachineInstOpcode: PPC::EFDDIV, RC: &PPC::SPERCRegClass, Op0, Op1);
4284 }
4285 if ((Subtarget->hasFPU())) {
4286 return fastEmitInst_rr(MachineInstOpcode: PPC::FDIV, RC: &PPC::F8RCRegClass, Op0, Op1);
4287 }
4288 return Register();
4289}
4290
4291Register fastEmit_ISD_STRICT_FDIV_MVT_f128_rr(MVT RetVT, Register Op0, Register Op1) {
4292 if (RetVT.SimpleTy != MVT::f128)
4293 return Register();
4294 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
4295 return fastEmitInst_rr(MachineInstOpcode: PPC::XSDIVQP, RC: &PPC::VRRCRegClass, Op0, Op1);
4296 }
4297 return Register();
4298}
4299
4300Register fastEmit_ISD_STRICT_FDIV_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
4301 if (RetVT.SimpleTy != MVT::v4f32)
4302 return Register();
4303 if ((Subtarget->hasVSX())) {
4304 return fastEmitInst_rr(MachineInstOpcode: PPC::XVDIVSP, RC: &PPC::VSRCRegClass, Op0, Op1);
4305 }
4306 return Register();
4307}
4308
4309Register fastEmit_ISD_STRICT_FDIV_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
4310 if (RetVT.SimpleTy != MVT::v2f64)
4311 return Register();
4312 if ((Subtarget->hasVSX())) {
4313 return fastEmitInst_rr(MachineInstOpcode: PPC::XVDIVDP, RC: &PPC::VSRCRegClass, Op0, Op1);
4314 }
4315 return Register();
4316}
4317
4318Register fastEmit_ISD_STRICT_FDIV_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4319 switch (VT.SimpleTy) {
4320 case MVT::f32: return fastEmit_ISD_STRICT_FDIV_MVT_f32_rr(RetVT, Op0, Op1);
4321 case MVT::f64: return fastEmit_ISD_STRICT_FDIV_MVT_f64_rr(RetVT, Op0, Op1);
4322 case MVT::f128: return fastEmit_ISD_STRICT_FDIV_MVT_f128_rr(RetVT, Op0, Op1);
4323 case MVT::v4f32: return fastEmit_ISD_STRICT_FDIV_MVT_v4f32_rr(RetVT, Op0, Op1);
4324 case MVT::v2f64: return fastEmit_ISD_STRICT_FDIV_MVT_v2f64_rr(RetVT, Op0, Op1);
4325 default: return Register();
4326 }
4327}
4328
4329// FastEmit functions for ISD::STRICT_FMAXNUM.
4330
4331Register fastEmit_ISD_STRICT_FMAXNUM_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
4332 if (RetVT.SimpleTy != MVT::v4f32)
4333 return Register();
4334 if ((Subtarget->hasVSX())) {
4335 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMAXSP, RC: &PPC::VSRCRegClass, Op0, Op1);
4336 }
4337 return Register();
4338}
4339
4340Register fastEmit_ISD_STRICT_FMAXNUM_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
4341 if (RetVT.SimpleTy != MVT::v2f64)
4342 return Register();
4343 if ((Subtarget->hasVSX())) {
4344 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMAXDP, RC: &PPC::VSRCRegClass, Op0, Op1);
4345 }
4346 return Register();
4347}
4348
4349Register fastEmit_ISD_STRICT_FMAXNUM_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4350 switch (VT.SimpleTy) {
4351 case MVT::v4f32: return fastEmit_ISD_STRICT_FMAXNUM_MVT_v4f32_rr(RetVT, Op0, Op1);
4352 case MVT::v2f64: return fastEmit_ISD_STRICT_FMAXNUM_MVT_v2f64_rr(RetVT, Op0, Op1);
4353 default: return Register();
4354 }
4355}
4356
4357// FastEmit functions for ISD::STRICT_FMINNUM.
4358
4359Register fastEmit_ISD_STRICT_FMINNUM_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
4360 if (RetVT.SimpleTy != MVT::v4f32)
4361 return Register();
4362 if ((Subtarget->hasVSX())) {
4363 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMINSP, RC: &PPC::VSRCRegClass, Op0, Op1);
4364 }
4365 return Register();
4366}
4367
4368Register fastEmit_ISD_STRICT_FMINNUM_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
4369 if (RetVT.SimpleTy != MVT::v2f64)
4370 return Register();
4371 if ((Subtarget->hasVSX())) {
4372 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMINDP, RC: &PPC::VSRCRegClass, Op0, Op1);
4373 }
4374 return Register();
4375}
4376
4377Register fastEmit_ISD_STRICT_FMINNUM_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4378 switch (VT.SimpleTy) {
4379 case MVT::v4f32: return fastEmit_ISD_STRICT_FMINNUM_MVT_v4f32_rr(RetVT, Op0, Op1);
4380 case MVT::v2f64: return fastEmit_ISD_STRICT_FMINNUM_MVT_v2f64_rr(RetVT, Op0, Op1);
4381 default: return Register();
4382 }
4383}
4384
4385// FastEmit functions for ISD::STRICT_FMUL.
4386
4387Register fastEmit_ISD_STRICT_FMUL_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
4388 if (RetVT.SimpleTy != MVT::f32)
4389 return Register();
4390 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
4391 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMULSP, RC: &PPC::VSSRCRegClass, Op0, Op1);
4392 }
4393 if ((Subtarget->hasSPE())) {
4394 return fastEmitInst_rr(MachineInstOpcode: PPC::EFSMUL, RC: &PPC::GPRCRegClass, Op0, Op1);
4395 }
4396 if ((Subtarget->hasFPU())) {
4397 return fastEmitInst_rr(MachineInstOpcode: PPC::FMULS, RC: &PPC::F4RCRegClass, Op0, Op1);
4398 }
4399 return Register();
4400}
4401
4402Register fastEmit_ISD_STRICT_FMUL_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
4403 if (RetVT.SimpleTy != MVT::f64)
4404 return Register();
4405 if ((Subtarget->hasVSX())) {
4406 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMULDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
4407 }
4408 if ((Subtarget->hasSPE())) {
4409 return fastEmitInst_rr(MachineInstOpcode: PPC::EFDMUL, RC: &PPC::SPERCRegClass, Op0, Op1);
4410 }
4411 if ((Subtarget->hasFPU())) {
4412 return fastEmitInst_rr(MachineInstOpcode: PPC::FMUL, RC: &PPC::F8RCRegClass, Op0, Op1);
4413 }
4414 return Register();
4415}
4416
4417Register fastEmit_ISD_STRICT_FMUL_MVT_f128_rr(MVT RetVT, Register Op0, Register Op1) {
4418 if (RetVT.SimpleTy != MVT::f128)
4419 return Register();
4420 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
4421 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMULQP, RC: &PPC::VRRCRegClass, Op0, Op1);
4422 }
4423 return Register();
4424}
4425
4426Register fastEmit_ISD_STRICT_FMUL_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
4427 if (RetVT.SimpleTy != MVT::v4f32)
4428 return Register();
4429 if ((Subtarget->hasVSX())) {
4430 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMULSP, RC: &PPC::VSRCRegClass, Op0, Op1);
4431 }
4432 return Register();
4433}
4434
4435Register fastEmit_ISD_STRICT_FMUL_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
4436 if (RetVT.SimpleTy != MVT::v2f64)
4437 return Register();
4438 if ((Subtarget->hasVSX())) {
4439 return fastEmitInst_rr(MachineInstOpcode: PPC::XVMULDP, RC: &PPC::VSRCRegClass, Op0, Op1);
4440 }
4441 return Register();
4442}
4443
4444Register fastEmit_ISD_STRICT_FMUL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4445 switch (VT.SimpleTy) {
4446 case MVT::f32: return fastEmit_ISD_STRICT_FMUL_MVT_f32_rr(RetVT, Op0, Op1);
4447 case MVT::f64: return fastEmit_ISD_STRICT_FMUL_MVT_f64_rr(RetVT, Op0, Op1);
4448 case MVT::f128: return fastEmit_ISD_STRICT_FMUL_MVT_f128_rr(RetVT, Op0, Op1);
4449 case MVT::v4f32: return fastEmit_ISD_STRICT_FMUL_MVT_v4f32_rr(RetVT, Op0, Op1);
4450 case MVT::v2f64: return fastEmit_ISD_STRICT_FMUL_MVT_v2f64_rr(RetVT, Op0, Op1);
4451 default: return Register();
4452 }
4453}
4454
4455// FastEmit functions for ISD::STRICT_FSUB.
4456
4457Register fastEmit_ISD_STRICT_FSUB_MVT_f32_rr(MVT RetVT, Register Op0, Register Op1) {
4458 if (RetVT.SimpleTy != MVT::f32)
4459 return Register();
4460 if ((Subtarget->hasP8Vector()) && (Subtarget->hasVSX())) {
4461 return fastEmitInst_rr(MachineInstOpcode: PPC::XSSUBSP, RC: &PPC::VSSRCRegClass, Op0, Op1);
4462 }
4463 if ((Subtarget->hasSPE())) {
4464 return fastEmitInst_rr(MachineInstOpcode: PPC::EFSSUB, RC: &PPC::GPRCRegClass, Op0, Op1);
4465 }
4466 if ((Subtarget->hasFPU())) {
4467 return fastEmitInst_rr(MachineInstOpcode: PPC::FSUBS, RC: &PPC::F4RCRegClass, Op0, Op1);
4468 }
4469 return Register();
4470}
4471
4472Register fastEmit_ISD_STRICT_FSUB_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
4473 if (RetVT.SimpleTy != MVT::f64)
4474 return Register();
4475 if ((Subtarget->hasVSX())) {
4476 return fastEmitInst_rr(MachineInstOpcode: PPC::XSSUBDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
4477 }
4478 if ((Subtarget->hasSPE())) {
4479 return fastEmitInst_rr(MachineInstOpcode: PPC::EFDSUB, RC: &PPC::SPERCRegClass, Op0, Op1);
4480 }
4481 if ((Subtarget->hasFPU())) {
4482 return fastEmitInst_rr(MachineInstOpcode: PPC::FSUB, RC: &PPC::F8RCRegClass, Op0, Op1);
4483 }
4484 return Register();
4485}
4486
4487Register fastEmit_ISD_STRICT_FSUB_MVT_f128_rr(MVT RetVT, Register Op0, Register Op1) {
4488 if (RetVT.SimpleTy != MVT::f128)
4489 return Register();
4490 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
4491 return fastEmitInst_rr(MachineInstOpcode: PPC::XSSUBQP, RC: &PPC::VRRCRegClass, Op0, Op1);
4492 }
4493 return Register();
4494}
4495
4496Register fastEmit_ISD_STRICT_FSUB_MVT_v4f32_rr(MVT RetVT, Register Op0, Register Op1) {
4497 if (RetVT.SimpleTy != MVT::v4f32)
4498 return Register();
4499 if ((Subtarget->hasVSX())) {
4500 return fastEmitInst_rr(MachineInstOpcode: PPC::XVSUBSP, RC: &PPC::VSRCRegClass, Op0, Op1);
4501 }
4502 return Register();
4503}
4504
4505Register fastEmit_ISD_STRICT_FSUB_MVT_v2f64_rr(MVT RetVT, Register Op0, Register Op1) {
4506 if (RetVT.SimpleTy != MVT::v2f64)
4507 return Register();
4508 if ((Subtarget->hasVSX())) {
4509 return fastEmitInst_rr(MachineInstOpcode: PPC::XVSUBDP, RC: &PPC::VSRCRegClass, Op0, Op1);
4510 }
4511 return Register();
4512}
4513
4514Register fastEmit_ISD_STRICT_FSUB_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4515 switch (VT.SimpleTy) {
4516 case MVT::f32: return fastEmit_ISD_STRICT_FSUB_MVT_f32_rr(RetVT, Op0, Op1);
4517 case MVT::f64: return fastEmit_ISD_STRICT_FSUB_MVT_f64_rr(RetVT, Op0, Op1);
4518 case MVT::f128: return fastEmit_ISD_STRICT_FSUB_MVT_f128_rr(RetVT, Op0, Op1);
4519 case MVT::v4f32: return fastEmit_ISD_STRICT_FSUB_MVT_v4f32_rr(RetVT, Op0, Op1);
4520 case MVT::v2f64: return fastEmit_ISD_STRICT_FSUB_MVT_v2f64_rr(RetVT, Op0, Op1);
4521 default: return Register();
4522 }
4523}
4524
4525// FastEmit functions for ISD::SUB.
4526
4527Register fastEmit_ISD_SUB_MVT_i1_rr(MVT RetVT, Register Op0, Register Op1) {
4528 if (RetVT.SimpleTy != MVT::i1)
4529 return Register();
4530 return fastEmitInst_rr(MachineInstOpcode: PPC::CRXOR, RC: &PPC::CRBITRCRegClass, Op0, Op1);
4531}
4532
4533Register fastEmit_ISD_SUB_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
4534 if (RetVT.SimpleTy != MVT::v16i8)
4535 return Register();
4536 if ((Subtarget->hasAltivec())) {
4537 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBUBM, RC: &PPC::VRRCRegClass, Op0, Op1);
4538 }
4539 return Register();
4540}
4541
4542Register fastEmit_ISD_SUB_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
4543 if (RetVT.SimpleTy != MVT::v8i16)
4544 return Register();
4545 if ((Subtarget->hasAltivec())) {
4546 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBUHM, RC: &PPC::VRRCRegClass, Op0, Op1);
4547 }
4548 return Register();
4549}
4550
4551Register fastEmit_ISD_SUB_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4552 if (RetVT.SimpleTy != MVT::v4i32)
4553 return Register();
4554 if ((Subtarget->hasFutureVector())) {
4555 return fastEmitInst_rr(MachineInstOpcode: PPC::XVSUBUWM, RC: &PPC::VSRCRegClass, Op0, Op1);
4556 }
4557 if ((Subtarget->hasAltivec())) {
4558 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBUWM, RC: &PPC::VRRCRegClass, Op0, Op1);
4559 }
4560 return Register();
4561}
4562
4563Register fastEmit_ISD_SUB_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
4564 if (RetVT.SimpleTy != MVT::v2i64)
4565 return Register();
4566 if ((Subtarget->hasP8Altivec())) {
4567 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBUDM, RC: &PPC::VRRCRegClass, Op0, Op1);
4568 }
4569 return Register();
4570}
4571
4572Register fastEmit_ISD_SUB_MVT_v1i128_rr(MVT RetVT, Register Op0, Register Op1) {
4573 if (RetVT.SimpleTy != MVT::v1i128)
4574 return Register();
4575 if ((Subtarget->hasP8Altivec())) {
4576 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBUQM, RC: &PPC::VRRCRegClass, Op0, Op1);
4577 }
4578 return Register();
4579}
4580
4581Register fastEmit_ISD_SUB_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4582 switch (VT.SimpleTy) {
4583 case MVT::i1: return fastEmit_ISD_SUB_MVT_i1_rr(RetVT, Op0, Op1);
4584 case MVT::v16i8: return fastEmit_ISD_SUB_MVT_v16i8_rr(RetVT, Op0, Op1);
4585 case MVT::v8i16: return fastEmit_ISD_SUB_MVT_v8i16_rr(RetVT, Op0, Op1);
4586 case MVT::v4i32: return fastEmit_ISD_SUB_MVT_v4i32_rr(RetVT, Op0, Op1);
4587 case MVT::v2i64: return fastEmit_ISD_SUB_MVT_v2i64_rr(RetVT, Op0, Op1);
4588 case MVT::v1i128: return fastEmit_ISD_SUB_MVT_v1i128_rr(RetVT, Op0, Op1);
4589 default: return Register();
4590 }
4591}
4592
4593// FastEmit functions for ISD::UADDSAT.
4594
4595Register fastEmit_ISD_UADDSAT_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
4596 if (RetVT.SimpleTy != MVT::v16i8)
4597 return Register();
4598 if ((Subtarget->hasAltivec())) {
4599 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDUBS, RC: &PPC::VRRCRegClass, Op0, Op1);
4600 }
4601 return Register();
4602}
4603
4604Register fastEmit_ISD_UADDSAT_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
4605 if (RetVT.SimpleTy != MVT::v8i16)
4606 return Register();
4607 if ((Subtarget->hasAltivec())) {
4608 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDUHS, RC: &PPC::VRRCRegClass, Op0, Op1);
4609 }
4610 return Register();
4611}
4612
4613Register fastEmit_ISD_UADDSAT_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4614 if (RetVT.SimpleTy != MVT::v4i32)
4615 return Register();
4616 if ((Subtarget->hasAltivec())) {
4617 return fastEmitInst_rr(MachineInstOpcode: PPC::VADDUWS, RC: &PPC::VRRCRegClass, Op0, Op1);
4618 }
4619 return Register();
4620}
4621
4622Register fastEmit_ISD_UADDSAT_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4623 switch (VT.SimpleTy) {
4624 case MVT::v16i8: return fastEmit_ISD_UADDSAT_MVT_v16i8_rr(RetVT, Op0, Op1);
4625 case MVT::v8i16: return fastEmit_ISD_UADDSAT_MVT_v8i16_rr(RetVT, Op0, Op1);
4626 case MVT::v4i32: return fastEmit_ISD_UADDSAT_MVT_v4i32_rr(RetVT, Op0, Op1);
4627 default: return Register();
4628 }
4629}
4630
4631// FastEmit functions for ISD::UDIV.
4632
4633Register fastEmit_ISD_UDIV_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
4634 if (RetVT.SimpleTy != MVT::i32)
4635 return Register();
4636 return fastEmitInst_rr(MachineInstOpcode: PPC::DIVWU, RC: &PPC::GPRCRegClass, Op0, Op1);
4637}
4638
4639Register fastEmit_ISD_UDIV_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
4640 if (RetVT.SimpleTy != MVT::i64)
4641 return Register();
4642 return fastEmitInst_rr(MachineInstOpcode: PPC::DIVDU, RC: &PPC::G8RCRegClass, Op0, Op1);
4643}
4644
4645Register fastEmit_ISD_UDIV_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4646 if (RetVT.SimpleTy != MVT::v4i32)
4647 return Register();
4648 if ((Subtarget->isISA3_1())) {
4649 return fastEmitInst_rr(MachineInstOpcode: PPC::VDIVUW, RC: &PPC::VRRCRegClass, Op0, Op1);
4650 }
4651 return Register();
4652}
4653
4654Register fastEmit_ISD_UDIV_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
4655 if (RetVT.SimpleTy != MVT::v2i64)
4656 return Register();
4657 if ((Subtarget->isISA3_1())) {
4658 return fastEmitInst_rr(MachineInstOpcode: PPC::VDIVUD, RC: &PPC::VRRCRegClass, Op0, Op1);
4659 }
4660 return Register();
4661}
4662
4663Register fastEmit_ISD_UDIV_MVT_v1i128_rr(MVT RetVT, Register Op0, Register Op1) {
4664 if (RetVT.SimpleTy != MVT::v1i128)
4665 return Register();
4666 if ((Subtarget->isISA3_1())) {
4667 return fastEmitInst_rr(MachineInstOpcode: PPC::VDIVUQ, RC: &PPC::VRRCRegClass, Op0, Op1);
4668 }
4669 return Register();
4670}
4671
4672Register fastEmit_ISD_UDIV_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4673 switch (VT.SimpleTy) {
4674 case MVT::i32: return fastEmit_ISD_UDIV_MVT_i32_rr(RetVT, Op0, Op1);
4675 case MVT::i64: return fastEmit_ISD_UDIV_MVT_i64_rr(RetVT, Op0, Op1);
4676 case MVT::v4i32: return fastEmit_ISD_UDIV_MVT_v4i32_rr(RetVT, Op0, Op1);
4677 case MVT::v2i64: return fastEmit_ISD_UDIV_MVT_v2i64_rr(RetVT, Op0, Op1);
4678 case MVT::v1i128: return fastEmit_ISD_UDIV_MVT_v1i128_rr(RetVT, Op0, Op1);
4679 default: return Register();
4680 }
4681}
4682
4683// FastEmit functions for ISD::UMAX.
4684
4685Register fastEmit_ISD_UMAX_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
4686 if (RetVT.SimpleTy != MVT::v16i8)
4687 return Register();
4688 if ((Subtarget->hasAltivec())) {
4689 return fastEmitInst_rr(MachineInstOpcode: PPC::VMAXUB, RC: &PPC::VRRCRegClass, Op0, Op1);
4690 }
4691 return Register();
4692}
4693
4694Register fastEmit_ISD_UMAX_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
4695 if (RetVT.SimpleTy != MVT::v8i16)
4696 return Register();
4697 if ((Subtarget->hasAltivec())) {
4698 return fastEmitInst_rr(MachineInstOpcode: PPC::VMAXUH, RC: &PPC::VRRCRegClass, Op0, Op1);
4699 }
4700 return Register();
4701}
4702
4703Register fastEmit_ISD_UMAX_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4704 if (RetVT.SimpleTy != MVT::v4i32)
4705 return Register();
4706 if ((Subtarget->hasAltivec())) {
4707 return fastEmitInst_rr(MachineInstOpcode: PPC::VMAXUW, RC: &PPC::VRRCRegClass, Op0, Op1);
4708 }
4709 return Register();
4710}
4711
4712Register fastEmit_ISD_UMAX_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4713 switch (VT.SimpleTy) {
4714 case MVT::v16i8: return fastEmit_ISD_UMAX_MVT_v16i8_rr(RetVT, Op0, Op1);
4715 case MVT::v8i16: return fastEmit_ISD_UMAX_MVT_v8i16_rr(RetVT, Op0, Op1);
4716 case MVT::v4i32: return fastEmit_ISD_UMAX_MVT_v4i32_rr(RetVT, Op0, Op1);
4717 default: return Register();
4718 }
4719}
4720
4721// FastEmit functions for ISD::UMIN.
4722
4723Register fastEmit_ISD_UMIN_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
4724 if (RetVT.SimpleTy != MVT::v16i8)
4725 return Register();
4726 if ((Subtarget->hasAltivec())) {
4727 return fastEmitInst_rr(MachineInstOpcode: PPC::VMINUB, RC: &PPC::VRRCRegClass, Op0, Op1);
4728 }
4729 return Register();
4730}
4731
4732Register fastEmit_ISD_UMIN_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
4733 if (RetVT.SimpleTy != MVT::v8i16)
4734 return Register();
4735 if ((Subtarget->hasAltivec())) {
4736 return fastEmitInst_rr(MachineInstOpcode: PPC::VMINUH, RC: &PPC::VRRCRegClass, Op0, Op1);
4737 }
4738 return Register();
4739}
4740
4741Register fastEmit_ISD_UMIN_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4742 if (RetVT.SimpleTy != MVT::v4i32)
4743 return Register();
4744 if ((Subtarget->hasAltivec())) {
4745 return fastEmitInst_rr(MachineInstOpcode: PPC::VMINUW, RC: &PPC::VRRCRegClass, Op0, Op1);
4746 }
4747 return Register();
4748}
4749
4750Register fastEmit_ISD_UMIN_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4751 switch (VT.SimpleTy) {
4752 case MVT::v16i8: return fastEmit_ISD_UMIN_MVT_v16i8_rr(RetVT, Op0, Op1);
4753 case MVT::v8i16: return fastEmit_ISD_UMIN_MVT_v8i16_rr(RetVT, Op0, Op1);
4754 case MVT::v4i32: return fastEmit_ISD_UMIN_MVT_v4i32_rr(RetVT, Op0, Op1);
4755 default: return Register();
4756 }
4757}
4758
4759// FastEmit functions for ISD::UREM.
4760
4761Register fastEmit_ISD_UREM_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
4762 if (RetVT.SimpleTy != MVT::i32)
4763 return Register();
4764 if ((Subtarget->isISA3_0())) {
4765 return fastEmitInst_rr(MachineInstOpcode: PPC::MODUW, RC: &PPC::GPRCRegClass, Op0, Op1);
4766 }
4767 return Register();
4768}
4769
4770Register fastEmit_ISD_UREM_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
4771 if (RetVT.SimpleTy != MVT::i64)
4772 return Register();
4773 if ((Subtarget->isISA3_0())) {
4774 return fastEmitInst_rr(MachineInstOpcode: PPC::MODUD, RC: &PPC::G8RCRegClass, Op0, Op1);
4775 }
4776 return Register();
4777}
4778
4779Register fastEmit_ISD_UREM_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4780 if (RetVT.SimpleTy != MVT::v4i32)
4781 return Register();
4782 if ((Subtarget->isISA3_1())) {
4783 return fastEmitInst_rr(MachineInstOpcode: PPC::VMODUW, RC: &PPC::VRRCRegClass, Op0, Op1);
4784 }
4785 return Register();
4786}
4787
4788Register fastEmit_ISD_UREM_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
4789 if (RetVT.SimpleTy != MVT::v2i64)
4790 return Register();
4791 if ((Subtarget->isISA3_1())) {
4792 return fastEmitInst_rr(MachineInstOpcode: PPC::VMODUD, RC: &PPC::VRRCRegClass, Op0, Op1);
4793 }
4794 return Register();
4795}
4796
4797Register fastEmit_ISD_UREM_MVT_v1i128_rr(MVT RetVT, Register Op0, Register Op1) {
4798 if (RetVT.SimpleTy != MVT::v1i128)
4799 return Register();
4800 if ((Subtarget->isISA3_1())) {
4801 return fastEmitInst_rr(MachineInstOpcode: PPC::VMODUQ, RC: &PPC::VRRCRegClass, Op0, Op1);
4802 }
4803 return Register();
4804}
4805
4806Register fastEmit_ISD_UREM_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4807 switch (VT.SimpleTy) {
4808 case MVT::i32: return fastEmit_ISD_UREM_MVT_i32_rr(RetVT, Op0, Op1);
4809 case MVT::i64: return fastEmit_ISD_UREM_MVT_i64_rr(RetVT, Op0, Op1);
4810 case MVT::v4i32: return fastEmit_ISD_UREM_MVT_v4i32_rr(RetVT, Op0, Op1);
4811 case MVT::v2i64: return fastEmit_ISD_UREM_MVT_v2i64_rr(RetVT, Op0, Op1);
4812 case MVT::v1i128: return fastEmit_ISD_UREM_MVT_v1i128_rr(RetVT, Op0, Op1);
4813 default: return Register();
4814 }
4815}
4816
4817// FastEmit functions for ISD::USUBSAT.
4818
4819Register fastEmit_ISD_USUBSAT_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
4820 if (RetVT.SimpleTy != MVT::v16i8)
4821 return Register();
4822 if ((Subtarget->hasAltivec())) {
4823 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBUBS, RC: &PPC::VRRCRegClass, Op0, Op1);
4824 }
4825 return Register();
4826}
4827
4828Register fastEmit_ISD_USUBSAT_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
4829 if (RetVT.SimpleTy != MVT::v8i16)
4830 return Register();
4831 if ((Subtarget->hasAltivec())) {
4832 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBUHS, RC: &PPC::VRRCRegClass, Op0, Op1);
4833 }
4834 return Register();
4835}
4836
4837Register fastEmit_ISD_USUBSAT_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4838 if (RetVT.SimpleTy != MVT::v4i32)
4839 return Register();
4840 if ((Subtarget->hasAltivec())) {
4841 return fastEmitInst_rr(MachineInstOpcode: PPC::VSUBUWS, RC: &PPC::VRRCRegClass, Op0, Op1);
4842 }
4843 return Register();
4844}
4845
4846Register fastEmit_ISD_USUBSAT_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4847 switch (VT.SimpleTy) {
4848 case MVT::v16i8: return fastEmit_ISD_USUBSAT_MVT_v16i8_rr(RetVT, Op0, Op1);
4849 case MVT::v8i16: return fastEmit_ISD_USUBSAT_MVT_v8i16_rr(RetVT, Op0, Op1);
4850 case MVT::v4i32: return fastEmit_ISD_USUBSAT_MVT_v4i32_rr(RetVT, Op0, Op1);
4851 default: return Register();
4852 }
4853}
4854
4855// FastEmit functions for ISD::XOR.
4856
4857Register fastEmit_ISD_XOR_MVT_i1_rr(MVT RetVT, Register Op0, Register Op1) {
4858 if (RetVT.SimpleTy != MVT::i1)
4859 return Register();
4860 return fastEmitInst_rr(MachineInstOpcode: PPC::CRXOR, RC: &PPC::CRBITRCRegClass, Op0, Op1);
4861}
4862
4863Register fastEmit_ISD_XOR_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
4864 if (RetVT.SimpleTy != MVT::i32)
4865 return Register();
4866 return fastEmitInst_rr(MachineInstOpcode: PPC::XOR, RC: &PPC::GPRCRegClass, Op0, Op1);
4867}
4868
4869Register fastEmit_ISD_XOR_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
4870 if (RetVT.SimpleTy != MVT::i64)
4871 return Register();
4872 return fastEmitInst_rr(MachineInstOpcode: PPC::XOR8, RC: &PPC::G8RCRegClass, Op0, Op1);
4873}
4874
4875Register fastEmit_ISD_XOR_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
4876 if (RetVT.SimpleTy != MVT::v4i32)
4877 return Register();
4878 if ((Subtarget->hasVSX())) {
4879 return fastEmitInst_rr(MachineInstOpcode: PPC::XXLXOR, RC: &PPC::VSRCRegClass, Op0, Op1);
4880 }
4881 if ((Subtarget->hasAltivec())) {
4882 return fastEmitInst_rr(MachineInstOpcode: PPC::VXOR, RC: &PPC::VRRCRegClass, Op0, Op1);
4883 }
4884 return Register();
4885}
4886
4887Register fastEmit_ISD_XOR_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4888 switch (VT.SimpleTy) {
4889 case MVT::i1: return fastEmit_ISD_XOR_MVT_i1_rr(RetVT, Op0, Op1);
4890 case MVT::i32: return fastEmit_ISD_XOR_MVT_i32_rr(RetVT, Op0, Op1);
4891 case MVT::i64: return fastEmit_ISD_XOR_MVT_i64_rr(RetVT, Op0, Op1);
4892 case MVT::v4i32: return fastEmit_ISD_XOR_MVT_v4i32_rr(RetVT, Op0, Op1);
4893 default: return Register();
4894 }
4895}
4896
4897// FastEmit functions for PPCISD::ADD_TLS.
4898
4899Register fastEmit_PPCISD_ADD_TLS_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
4900 if (RetVT.SimpleTy != MVT::i32)
4901 return Register();
4902 return fastEmitInst_rr(MachineInstOpcode: PPC::ADD4TLS, RC: &PPC::GPRCRegClass, Op0, Op1);
4903}
4904
4905Register fastEmit_PPCISD_ADD_TLS_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
4906 if (RetVT.SimpleTy != MVT::i64)
4907 return Register();
4908 return fastEmitInst_rr(MachineInstOpcode: PPC::ADD8TLS, RC: &PPC::G8RCRegClass, Op0, Op1);
4909}
4910
4911Register fastEmit_PPCISD_ADD_TLS_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4912 switch (VT.SimpleTy) {
4913 case MVT::i32: return fastEmit_PPCISD_ADD_TLS_MVT_i32_rr(RetVT, Op0, Op1);
4914 case MVT::i64: return fastEmit_PPCISD_ADD_TLS_MVT_i64_rr(RetVT, Op0, Op1);
4915 default: return Register();
4916 }
4917}
4918
4919// FastEmit functions for PPCISD::CMPB.
4920
4921Register fastEmit_PPCISD_CMPB_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
4922 if (RetVT.SimpleTy != MVT::i32)
4923 return Register();
4924 return fastEmitInst_rr(MachineInstOpcode: PPC::CMPB, RC: &PPC::GPRCRegClass, Op0, Op1);
4925}
4926
4927Register fastEmit_PPCISD_CMPB_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
4928 if (RetVT.SimpleTy != MVT::i64)
4929 return Register();
4930 return fastEmitInst_rr(MachineInstOpcode: PPC::CMPB8, RC: &PPC::G8RCRegClass, Op0, Op1);
4931}
4932
4933Register fastEmit_PPCISD_CMPB_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4934 switch (VT.SimpleTy) {
4935 case MVT::i32: return fastEmit_PPCISD_CMPB_MVT_i32_rr(RetVT, Op0, Op1);
4936 case MVT::i64: return fastEmit_PPCISD_CMPB_MVT_i64_rr(RetVT, Op0, Op1);
4937 default: return Register();
4938 }
4939}
4940
4941// FastEmit functions for PPCISD::FADDRTZ.
4942
4943Register fastEmit_PPCISD_FADDRTZ_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
4944 if (RetVT.SimpleTy != MVT::f64)
4945 return Register();
4946 if ((Subtarget->hasFPU())) {
4947 return fastEmitInst_rr(MachineInstOpcode: PPC::FADDrtz, RC: &PPC::F8RCRegClass, Op0, Op1);
4948 }
4949 return Register();
4950}
4951
4952Register fastEmit_PPCISD_FADDRTZ_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4953 switch (VT.SimpleTy) {
4954 case MVT::f64: return fastEmit_PPCISD_FADDRTZ_MVT_f64_rr(RetVT, Op0, Op1);
4955 default: return Register();
4956 }
4957}
4958
4959// FastEmit functions for PPCISD::GET_TLS_ADDR.
4960
4961Register fastEmit_PPCISD_GET_TLS_ADDR_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
4962 if (RetVT.SimpleTy != MVT::i32)
4963 return Register();
4964 return fastEmitInst_rr(MachineInstOpcode: PPC::GETtlsADDR32AIX, RC: &PPC::GPRCRegClass, Op0, Op1);
4965}
4966
4967Register fastEmit_PPCISD_GET_TLS_ADDR_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
4968 if (RetVT.SimpleTy != MVT::i64)
4969 return Register();
4970 return fastEmitInst_rr(MachineInstOpcode: PPC::GETtlsADDR64AIX, RC: &PPC::G8RCRegClass, Op0, Op1);
4971}
4972
4973Register fastEmit_PPCISD_GET_TLS_ADDR_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4974 switch (VT.SimpleTy) {
4975 case MVT::i32: return fastEmit_PPCISD_GET_TLS_ADDR_MVT_i32_rr(RetVT, Op0, Op1);
4976 case MVT::i64: return fastEmit_PPCISD_GET_TLS_ADDR_MVT_i64_rr(RetVT, Op0, Op1);
4977 default: return Register();
4978 }
4979}
4980
4981// FastEmit functions for PPCISD::INST512.
4982
4983Register fastEmit_PPCISD_INST512_MVT_v256i1_rr(MVT RetVT, Register Op0, Register Op1) {
4984 if (RetVT.SimpleTy != MVT::v512i1)
4985 return Register();
4986 if ((Subtarget->isISAFuture()) && (Subtarget->hasMMA())) {
4987 return fastEmitInst_rr(MachineInstOpcode: PPC::DMXXINSTDMR512, RC: &PPC::WACCRCRegClass, Op0, Op1);
4988 }
4989 return Register();
4990}
4991
4992Register fastEmit_PPCISD_INST512_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
4993 switch (VT.SimpleTy) {
4994 case MVT::v256i1: return fastEmit_PPCISD_INST512_MVT_v256i1_rr(RetVT, Op0, Op1);
4995 default: return Register();
4996 }
4997}
4998
4999// FastEmit functions for PPCISD::INST512HI.
5000
5001Register fastEmit_PPCISD_INST512HI_MVT_v256i1_rr(MVT RetVT, Register Op0, Register Op1) {
5002 if (RetVT.SimpleTy != MVT::v512i1)
5003 return Register();
5004 if ((Subtarget->isISAFuture()) && (Subtarget->hasMMA())) {
5005 return fastEmitInst_rr(MachineInstOpcode: PPC::DMXXINSTDMR512_HI, RC: &PPC::WACC_HIRCRegClass, Op0, Op1);
5006 }
5007 return Register();
5008}
5009
5010Register fastEmit_PPCISD_INST512HI_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
5011 switch (VT.SimpleTy) {
5012 case MVT::v256i1: return fastEmit_PPCISD_INST512HI_MVT_v256i1_rr(RetVT, Op0, Op1);
5013 default: return Register();
5014 }
5015}
5016
5017// FastEmit functions for PPCISD::SHL.
5018
5019Register fastEmit_PPCISD_SHL_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
5020 if (RetVT.SimpleTy != MVT::i32)
5021 return Register();
5022 return fastEmitInst_rr(MachineInstOpcode: PPC::SLW, RC: &PPC::GPRCRegClass, Op0, Op1);
5023}
5024
5025Register fastEmit_PPCISD_SHL_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
5026 if (RetVT.SimpleTy != MVT::v16i8)
5027 return Register();
5028 if ((Subtarget->hasAltivec())) {
5029 return fastEmitInst_rr(MachineInstOpcode: PPC::VSLB, RC: &PPC::VRRCRegClass, Op0, Op1);
5030 }
5031 return Register();
5032}
5033
5034Register fastEmit_PPCISD_SHL_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
5035 if (RetVT.SimpleTy != MVT::v8i16)
5036 return Register();
5037 if ((Subtarget->hasAltivec())) {
5038 return fastEmitInst_rr(MachineInstOpcode: PPC::VSLH, RC: &PPC::VRRCRegClass, Op0, Op1);
5039 }
5040 return Register();
5041}
5042
5043Register fastEmit_PPCISD_SHL_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
5044 if (RetVT.SimpleTy != MVT::v4i32)
5045 return Register();
5046 if ((Subtarget->hasAltivec())) {
5047 return fastEmitInst_rr(MachineInstOpcode: PPC::VSLW, RC: &PPC::VRRCRegClass, Op0, Op1);
5048 }
5049 return Register();
5050}
5051
5052Register fastEmit_PPCISD_SHL_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
5053 if (RetVT.SimpleTy != MVT::v2i64)
5054 return Register();
5055 if ((Subtarget->hasP8Altivec())) {
5056 return fastEmitInst_rr(MachineInstOpcode: PPC::VSLD, RC: &PPC::VRRCRegClass, Op0, Op1);
5057 }
5058 return Register();
5059}
5060
5061Register fastEmit_PPCISD_SHL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
5062 switch (VT.SimpleTy) {
5063 case MVT::i32: return fastEmit_PPCISD_SHL_MVT_i32_rr(RetVT, Op0, Op1);
5064 case MVT::v16i8: return fastEmit_PPCISD_SHL_MVT_v16i8_rr(RetVT, Op0, Op1);
5065 case MVT::v8i16: return fastEmit_PPCISD_SHL_MVT_v8i16_rr(RetVT, Op0, Op1);
5066 case MVT::v4i32: return fastEmit_PPCISD_SHL_MVT_v4i32_rr(RetVT, Op0, Op1);
5067 case MVT::v2i64: return fastEmit_PPCISD_SHL_MVT_v2i64_rr(RetVT, Op0, Op1);
5068 default: return Register();
5069 }
5070}
5071
5072// FastEmit functions for PPCISD::SRA.
5073
5074Register fastEmit_PPCISD_SRA_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
5075 if (RetVT.SimpleTy != MVT::i32)
5076 return Register();
5077 return fastEmitInst_rr(MachineInstOpcode: PPC::SRAW, RC: &PPC::GPRCRegClass, Op0, Op1);
5078}
5079
5080Register fastEmit_PPCISD_SRA_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
5081 if (RetVT.SimpleTy != MVT::v16i8)
5082 return Register();
5083 if ((Subtarget->hasAltivec())) {
5084 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRAB, RC: &PPC::VRRCRegClass, Op0, Op1);
5085 }
5086 return Register();
5087}
5088
5089Register fastEmit_PPCISD_SRA_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
5090 if (RetVT.SimpleTy != MVT::v8i16)
5091 return Register();
5092 if ((Subtarget->hasAltivec())) {
5093 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRAH, RC: &PPC::VRRCRegClass, Op0, Op1);
5094 }
5095 return Register();
5096}
5097
5098Register fastEmit_PPCISD_SRA_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
5099 if (RetVT.SimpleTy != MVT::v4i32)
5100 return Register();
5101 if ((Subtarget->hasAltivec())) {
5102 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRAW, RC: &PPC::VRRCRegClass, Op0, Op1);
5103 }
5104 return Register();
5105}
5106
5107Register fastEmit_PPCISD_SRA_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
5108 if (RetVT.SimpleTy != MVT::v2i64)
5109 return Register();
5110 if ((Subtarget->hasP8Altivec())) {
5111 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRAD, RC: &PPC::VRRCRegClass, Op0, Op1);
5112 }
5113 return Register();
5114}
5115
5116Register fastEmit_PPCISD_SRA_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
5117 switch (VT.SimpleTy) {
5118 case MVT::i32: return fastEmit_PPCISD_SRA_MVT_i32_rr(RetVT, Op0, Op1);
5119 case MVT::v16i8: return fastEmit_PPCISD_SRA_MVT_v16i8_rr(RetVT, Op0, Op1);
5120 case MVT::v8i16: return fastEmit_PPCISD_SRA_MVT_v8i16_rr(RetVT, Op0, Op1);
5121 case MVT::v4i32: return fastEmit_PPCISD_SRA_MVT_v4i32_rr(RetVT, Op0, Op1);
5122 case MVT::v2i64: return fastEmit_PPCISD_SRA_MVT_v2i64_rr(RetVT, Op0, Op1);
5123 default: return Register();
5124 }
5125}
5126
5127// FastEmit functions for PPCISD::SRL.
5128
5129Register fastEmit_PPCISD_SRL_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
5130 if (RetVT.SimpleTy != MVT::i32)
5131 return Register();
5132 return fastEmitInst_rr(MachineInstOpcode: PPC::SRW, RC: &PPC::GPRCRegClass, Op0, Op1);
5133}
5134
5135Register fastEmit_PPCISD_SRL_MVT_v16i8_rr(MVT RetVT, Register Op0, Register Op1) {
5136 if (RetVT.SimpleTy != MVT::v16i8)
5137 return Register();
5138 if ((Subtarget->hasAltivec())) {
5139 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRB, RC: &PPC::VRRCRegClass, Op0, Op1);
5140 }
5141 return Register();
5142}
5143
5144Register fastEmit_PPCISD_SRL_MVT_v8i16_rr(MVT RetVT, Register Op0, Register Op1) {
5145 if (RetVT.SimpleTy != MVT::v8i16)
5146 return Register();
5147 if ((Subtarget->hasAltivec())) {
5148 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRH, RC: &PPC::VRRCRegClass, Op0, Op1);
5149 }
5150 return Register();
5151}
5152
5153Register fastEmit_PPCISD_SRL_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
5154 if (RetVT.SimpleTy != MVT::v4i32)
5155 return Register();
5156 if ((Subtarget->hasAltivec())) {
5157 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRW, RC: &PPC::VRRCRegClass, Op0, Op1);
5158 }
5159 return Register();
5160}
5161
5162Register fastEmit_PPCISD_SRL_MVT_v2i64_rr(MVT RetVT, Register Op0, Register Op1) {
5163 if (RetVT.SimpleTy != MVT::v2i64)
5164 return Register();
5165 if ((Subtarget->hasP8Altivec())) {
5166 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRD, RC: &PPC::VRRCRegClass, Op0, Op1);
5167 }
5168 return Register();
5169}
5170
5171Register fastEmit_PPCISD_SRL_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
5172 switch (VT.SimpleTy) {
5173 case MVT::i32: return fastEmit_PPCISD_SRL_MVT_i32_rr(RetVT, Op0, Op1);
5174 case MVT::v16i8: return fastEmit_PPCISD_SRL_MVT_v16i8_rr(RetVT, Op0, Op1);
5175 case MVT::v8i16: return fastEmit_PPCISD_SRL_MVT_v8i16_rr(RetVT, Op0, Op1);
5176 case MVT::v4i32: return fastEmit_PPCISD_SRL_MVT_v4i32_rr(RetVT, Op0, Op1);
5177 case MVT::v2i64: return fastEmit_PPCISD_SRL_MVT_v2i64_rr(RetVT, Op0, Op1);
5178 default: return Register();
5179 }
5180}
5181
5182// FastEmit functions for PPCISD::STRICT_FADDRTZ.
5183
5184Register fastEmit_PPCISD_STRICT_FADDRTZ_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
5185 if (RetVT.SimpleTy != MVT::f64)
5186 return Register();
5187 if ((Subtarget->hasFPU())) {
5188 return fastEmitInst_rr(MachineInstOpcode: PPC::FADDrtz, RC: &PPC::F8RCRegClass, Op0, Op1);
5189 }
5190 return Register();
5191}
5192
5193Register fastEmit_PPCISD_STRICT_FADDRTZ_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
5194 switch (VT.SimpleTy) {
5195 case MVT::f64: return fastEmit_PPCISD_STRICT_FADDRTZ_MVT_f64_rr(RetVT, Op0, Op1);
5196 default: return Register();
5197 }
5198}
5199
5200// FastEmit functions for PPCISD::TLSGD_AIX.
5201
5202Register fastEmit_PPCISD_TLSGD_AIX_MVT_i32_rr(MVT RetVT, Register Op0, Register Op1) {
5203 if (RetVT.SimpleTy != MVT::i32)
5204 return Register();
5205 return fastEmitInst_rr(MachineInstOpcode: PPC::TLSGDAIX, RC: &PPC::GPRCRegClass, Op0, Op1);
5206}
5207
5208Register fastEmit_PPCISD_TLSGD_AIX_MVT_i64_rr(MVT RetVT, Register Op0, Register Op1) {
5209 if (RetVT.SimpleTy != MVT::i64)
5210 return Register();
5211 return fastEmitInst_rr(MachineInstOpcode: PPC::TLSGDAIX8, RC: &PPC::G8RCRegClass, Op0, Op1);
5212}
5213
5214Register fastEmit_PPCISD_TLSGD_AIX_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
5215 switch (VT.SimpleTy) {
5216 case MVT::i32: return fastEmit_PPCISD_TLSGD_AIX_MVT_i32_rr(RetVT, Op0, Op1);
5217 case MVT::i64: return fastEmit_PPCISD_TLSGD_AIX_MVT_i64_rr(RetVT, Op0, Op1);
5218 default: return Register();
5219 }
5220}
5221
5222// FastEmit functions for PPCISD::VSRQ.
5223
5224Register fastEmit_PPCISD_VSRQ_MVT_v4i32_rr(MVT RetVT, Register Op0, Register Op1) {
5225 if (RetVT.SimpleTy != MVT::v4i32)
5226 return Register();
5227 if ((Subtarget->isISA3_1())) {
5228 return fastEmitInst_rr(MachineInstOpcode: PPC::VSRQ, RC: &PPC::VRRCRegClass, Op0, Op1);
5229 }
5230 return Register();
5231}
5232
5233Register fastEmit_PPCISD_VSRQ_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
5234 switch (VT.SimpleTy) {
5235 case MVT::v4i32: return fastEmit_PPCISD_VSRQ_MVT_v4i32_rr(RetVT, Op0, Op1);
5236 default: return Register();
5237 }
5238}
5239
5240// FastEmit functions for PPCISD::XSMAXC.
5241
5242Register fastEmit_PPCISD_XSMAXC_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
5243 if (RetVT.SimpleTy != MVT::f64)
5244 return Register();
5245 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
5246 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMAXCDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
5247 }
5248 return Register();
5249}
5250
5251Register fastEmit_PPCISD_XSMAXC_MVT_f128_rr(MVT RetVT, Register Op0, Register Op1) {
5252 if (RetVT.SimpleTy != MVT::f128)
5253 return Register();
5254 if ((Subtarget->hasVSX()) && (Subtarget->isISA3_1())) {
5255 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMAXCQP, RC: &PPC::VRRCRegClass, Op0, Op1);
5256 }
5257 return Register();
5258}
5259
5260Register fastEmit_PPCISD_XSMAXC_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
5261 switch (VT.SimpleTy) {
5262 case MVT::f64: return fastEmit_PPCISD_XSMAXC_MVT_f64_rr(RetVT, Op0, Op1);
5263 case MVT::f128: return fastEmit_PPCISD_XSMAXC_MVT_f128_rr(RetVT, Op0, Op1);
5264 default: return Register();
5265 }
5266}
5267
5268// FastEmit functions for PPCISD::XSMINC.
5269
5270Register fastEmit_PPCISD_XSMINC_MVT_f64_rr(MVT RetVT, Register Op0, Register Op1) {
5271 if (RetVT.SimpleTy != MVT::f64)
5272 return Register();
5273 if ((Subtarget->hasP9Vector()) && (Subtarget->hasVSX())) {
5274 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMINCDP, RC: &PPC::VSFRCRegClass, Op0, Op1);
5275 }
5276 return Register();
5277}
5278
5279Register fastEmit_PPCISD_XSMINC_MVT_f128_rr(MVT RetVT, Register Op0, Register Op1) {
5280 if (RetVT.SimpleTy != MVT::f128)
5281 return Register();
5282 if ((Subtarget->hasVSX()) && (Subtarget->isISA3_1())) {
5283 return fastEmitInst_rr(MachineInstOpcode: PPC::XSMINCQP, RC: &PPC::VRRCRegClass, Op0, Op1);
5284 }
5285 return Register();
5286}
5287
5288Register fastEmit_PPCISD_XSMINC_rr(MVT VT, MVT RetVT, Register Op0, Register Op1) {
5289 switch (VT.SimpleTy) {
5290 case MVT::f64: return fastEmit_PPCISD_XSMINC_MVT_f64_rr(RetVT, Op0, Op1);
5291 case MVT::f128: return fastEmit_PPCISD_XSMINC_MVT_f128_rr(RetVT, Op0, Op1);
5292 default: return Register();
5293 }
5294}
5295
5296// Top-level FastEmit function.
5297
5298Register fastEmit_rr(MVT VT, MVT RetVT, unsigned Opcode, Register Op0, Register Op1) override {
5299 switch (Opcode) {
5300 case ISD::ABDU: return fastEmit_ISD_ABDU_rr(VT, RetVT, Op0, Op1);
5301 case ISD::ADD: return fastEmit_ISD_ADD_rr(VT, RetVT, Op0, Op1);
5302 case ISD::AND: return fastEmit_ISD_AND_rr(VT, RetVT, Op0, Op1);
5303 case ISD::AVGCEILS: return fastEmit_ISD_AVGCEILS_rr(VT, RetVT, Op0, Op1);
5304 case ISD::AVGCEILU: return fastEmit_ISD_AVGCEILU_rr(VT, RetVT, Op0, Op1);
5305 case ISD::BUILD_VECTOR: return fastEmit_ISD_BUILD_VECTOR_rr(VT, RetVT, Op0, Op1);
5306 case ISD::FADD: return fastEmit_ISD_FADD_rr(VT, RetVT, Op0, Op1);
5307 case ISD::FDIV: return fastEmit_ISD_FDIV_rr(VT, RetVT, Op0, Op1);
5308 case ISD::FMAXNUM: return fastEmit_ISD_FMAXNUM_rr(VT, RetVT, Op0, Op1);
5309 case ISD::FMAXNUM_IEEE: return fastEmit_ISD_FMAXNUM_IEEE_rr(VT, RetVT, Op0, Op1);
5310 case ISD::FMINNUM: return fastEmit_ISD_FMINNUM_rr(VT, RetVT, Op0, Op1);
5311 case ISD::FMINNUM_IEEE: return fastEmit_ISD_FMINNUM_IEEE_rr(VT, RetVT, Op0, Op1);
5312 case ISD::FMUL: return fastEmit_ISD_FMUL_rr(VT, RetVT, Op0, Op1);
5313 case ISD::FSUB: return fastEmit_ISD_FSUB_rr(VT, RetVT, Op0, Op1);
5314 case ISD::MUL: return fastEmit_ISD_MUL_rr(VT, RetVT, Op0, Op1);
5315 case ISD::MULHS: return fastEmit_ISD_MULHS_rr(VT, RetVT, Op0, Op1);
5316 case ISD::MULHU: return fastEmit_ISD_MULHU_rr(VT, RetVT, Op0, Op1);
5317 case ISD::OR: return fastEmit_ISD_OR_rr(VT, RetVT, Op0, Op1);
5318 case ISD::ROTL: return fastEmit_ISD_ROTL_rr(VT, RetVT, Op0, Op1);
5319 case ISD::SADDSAT: return fastEmit_ISD_SADDSAT_rr(VT, RetVT, Op0, Op1);
5320 case ISD::SDIV: return fastEmit_ISD_SDIV_rr(VT, RetVT, Op0, Op1);
5321 case ISD::SHL: return fastEmit_ISD_SHL_rr(VT, RetVT, Op0, Op1);
5322 case ISD::SMAX: return fastEmit_ISD_SMAX_rr(VT, RetVT, Op0, Op1);
5323 case ISD::SMIN: return fastEmit_ISD_SMIN_rr(VT, RetVT, Op0, Op1);
5324 case ISD::SRA: return fastEmit_ISD_SRA_rr(VT, RetVT, Op0, Op1);
5325 case ISD::SREM: return fastEmit_ISD_SREM_rr(VT, RetVT, Op0, Op1);
5326 case ISD::SRL: return fastEmit_ISD_SRL_rr(VT, RetVT, Op0, Op1);
5327 case ISD::SSUBSAT: return fastEmit_ISD_SSUBSAT_rr(VT, RetVT, Op0, Op1);
5328 case ISD::STRICT_FADD: return fastEmit_ISD_STRICT_FADD_rr(VT, RetVT, Op0, Op1);
5329 case ISD::STRICT_FDIV: return fastEmit_ISD_STRICT_FDIV_rr(VT, RetVT, Op0, Op1);
5330 case ISD::STRICT_FMAXNUM: return fastEmit_ISD_STRICT_FMAXNUM_rr(VT, RetVT, Op0, Op1);
5331 case ISD::STRICT_FMINNUM: return fastEmit_ISD_STRICT_FMINNUM_rr(VT, RetVT, Op0, Op1);
5332 case ISD::STRICT_FMUL: return fastEmit_ISD_STRICT_FMUL_rr(VT, RetVT, Op0, Op1);
5333 case ISD::STRICT_FSUB: return fastEmit_ISD_STRICT_FSUB_rr(VT, RetVT, Op0, Op1);
5334 case ISD::SUB: return fastEmit_ISD_SUB_rr(VT, RetVT, Op0, Op1);
5335 case ISD::UADDSAT: return fastEmit_ISD_UADDSAT_rr(VT, RetVT, Op0, Op1);
5336 case ISD::UDIV: return fastEmit_ISD_UDIV_rr(VT, RetVT, Op0, Op1);
5337 case ISD::UMAX: return fastEmit_ISD_UMAX_rr(VT, RetVT, Op0, Op1);
5338 case ISD::UMIN: return fastEmit_ISD_UMIN_rr(VT, RetVT, Op0, Op1);
5339 case ISD::UREM: return fastEmit_ISD_UREM_rr(VT, RetVT, Op0, Op1);
5340 case ISD::USUBSAT: return fastEmit_ISD_USUBSAT_rr(VT, RetVT, Op0, Op1);
5341 case ISD::XOR: return fastEmit_ISD_XOR_rr(VT, RetVT, Op0, Op1);
5342 case PPCISD::ADD_TLS: return fastEmit_PPCISD_ADD_TLS_rr(VT, RetVT, Op0, Op1);
5343 case PPCISD::CMPB: return fastEmit_PPCISD_CMPB_rr(VT, RetVT, Op0, Op1);
5344 case PPCISD::FADDRTZ: return fastEmit_PPCISD_FADDRTZ_rr(VT, RetVT, Op0, Op1);
5345 case PPCISD::GET_TLS_ADDR: return fastEmit_PPCISD_GET_TLS_ADDR_rr(VT, RetVT, Op0, Op1);
5346 case PPCISD::INST512: return fastEmit_PPCISD_INST512_rr(VT, RetVT, Op0, Op1);
5347 case PPCISD::INST512HI: return fastEmit_PPCISD_INST512HI_rr(VT, RetVT, Op0, Op1);
5348 case PPCISD::SHL: return fastEmit_PPCISD_SHL_rr(VT, RetVT, Op0, Op1);
5349 case PPCISD::SRA: return fastEmit_PPCISD_SRA_rr(VT, RetVT, Op0, Op1);
5350 case PPCISD::SRL: return fastEmit_PPCISD_SRL_rr(VT, RetVT, Op0, Op1);
5351 case PPCISD::STRICT_FADDRTZ: return fastEmit_PPCISD_STRICT_FADDRTZ_rr(VT, RetVT, Op0, Op1);
5352 case PPCISD::TLSGD_AIX: return fastEmit_PPCISD_TLSGD_AIX_rr(VT, RetVT, Op0, Op1);
5353 case PPCISD::VSRQ: return fastEmit_PPCISD_VSRQ_rr(VT, RetVT, Op0, Op1);
5354 case PPCISD::XSMAXC: return fastEmit_PPCISD_XSMAXC_rr(VT, RetVT, Op0, Op1);
5355 case PPCISD::XSMINC: return fastEmit_PPCISD_XSMINC_rr(VT, RetVT, Op0, Op1);
5356 default: return Register();
5357 }
5358}
5359
5360// FastEmit functions for ISD::SRA.
5361
5362Register fastEmit_ISD_SRA_MVT_i32_ri(MVT RetVT, Register Op0, uint64_t imm1) {
5363 if (RetVT.SimpleTy != MVT::i32)
5364 return Register();
5365 return fastEmitInst_ri(MachineInstOpcode: PPC::SRAWI, RC: &PPC::GPRCRegClass, Op0, Imm: imm1);
5366}
5367
5368Register fastEmit_ISD_SRA_MVT_i64_ri(MVT RetVT, Register Op0, uint64_t imm1) {
5369 if (RetVT.SimpleTy != MVT::i64)
5370 return Register();
5371 return fastEmitInst_ri(MachineInstOpcode: PPC::SRADI, RC: &PPC::G8RCRegClass, Op0, Imm: imm1);
5372}
5373
5374Register fastEmit_ISD_SRA_ri(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
5375 switch (VT.SimpleTy) {
5376 case MVT::i32: return fastEmit_ISD_SRA_MVT_i32_ri(RetVT, Op0, imm1);
5377 case MVT::i64: return fastEmit_ISD_SRA_MVT_i64_ri(RetVT, Op0, imm1);
5378 default: return Register();
5379 }
5380}
5381
5382// FastEmit functions for PPCISD::EXTSWSLI.
5383
5384Register fastEmit_PPCISD_EXTSWSLI_MVT_i32_ri(MVT RetVT, Register Op0, uint64_t imm1) {
5385 if (RetVT.SimpleTy != MVT::i64)
5386 return Register();
5387 if ((Subtarget->isISA3_0())) {
5388 return fastEmitInst_ri(MachineInstOpcode: PPC::EXTSWSLI_32_64, RC: &PPC::G8RCRegClass, Op0, Imm: imm1);
5389 }
5390 return Register();
5391}
5392
5393Register fastEmit_PPCISD_EXTSWSLI_ri(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
5394 switch (VT.SimpleTy) {
5395 case MVT::i32: return fastEmit_PPCISD_EXTSWSLI_MVT_i32_ri(RetVT, Op0, imm1);
5396 default: return Register();
5397 }
5398}
5399
5400// FastEmit functions for PPCISD::TC_RETURN.
5401
5402Register fastEmit_PPCISD_TC_RETURN_MVT_i32_ri(MVT RetVT, Register Op0, uint64_t imm1) {
5403 if (RetVT.SimpleTy != MVT::isVoid)
5404 return Register();
5405 return fastEmitInst_ri(MachineInstOpcode: PPC::TCRETURNri, RC: &PPC::CTRRCRegClass, Op0, Imm: imm1);
5406}
5407
5408Register fastEmit_PPCISD_TC_RETURN_MVT_i64_ri(MVT RetVT, Register Op0, uint64_t imm1) {
5409 if (RetVT.SimpleTy != MVT::isVoid)
5410 return Register();
5411 return fastEmitInst_ri(MachineInstOpcode: PPC::TCRETURNri8, RC: &PPC::CTRRC8RegClass, Op0, Imm: imm1);
5412}
5413
5414Register fastEmit_PPCISD_TC_RETURN_ri(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
5415 switch (VT.SimpleTy) {
5416 case MVT::i32: return fastEmit_PPCISD_TC_RETURN_MVT_i32_ri(RetVT, Op0, imm1);
5417 case MVT::i64: return fastEmit_PPCISD_TC_RETURN_MVT_i64_ri(RetVT, Op0, imm1);
5418 default: return Register();
5419 }
5420}
5421
5422// Top-level FastEmit function.
5423
5424Register fastEmit_ri(MVT VT, MVT RetVT, unsigned Opcode, Register Op0, uint64_t imm1) override {
5425 if (VT == MVT::i32 && Predicate_imm32SExt16(Imm: imm1))
5426 if (Register Reg = fastEmit_ri_Predicate_imm32SExt16(VT, RetVT, Opcode, Op0, imm1))
5427 return Reg;
5428
5429 if (VT == MVT::i64 && Predicate_imm64SExt16(Imm: imm1))
5430 if (Register Reg = fastEmit_ri_Predicate_imm64SExt16(VT, RetVT, Opcode, Op0, imm1))
5431 return Reg;
5432
5433 switch (Opcode) {
5434 case ISD::SRA: return fastEmit_ISD_SRA_ri(VT, RetVT, Op0, imm1);
5435 case PPCISD::EXTSWSLI: return fastEmit_PPCISD_EXTSWSLI_ri(VT, RetVT, Op0, imm1);
5436 case PPCISD::TC_RETURN: return fastEmit_PPCISD_TC_RETURN_ri(VT, RetVT, Op0, imm1);
5437 default: return Register();
5438 }
5439}
5440
5441// FastEmit functions for ISD::ADD.
5442
5443Register fastEmit_ISD_ADD_MVT_i32_ri_Predicate_imm32SExt16(MVT RetVT, Register Op0, uint64_t imm1) {
5444 if (RetVT.SimpleTy != MVT::i32)
5445 return Register();
5446 return fastEmitInst_ri(MachineInstOpcode: PPC::ADDI, RC: &PPC::GPRCRegClass, Op0, Imm: imm1);
5447}
5448
5449Register fastEmit_ISD_ADD_ri_Predicate_imm32SExt16(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
5450 switch (VT.SimpleTy) {
5451 case MVT::i32: return fastEmit_ISD_ADD_MVT_i32_ri_Predicate_imm32SExt16(RetVT, Op0, imm1);
5452 default: return Register();
5453 }
5454}
5455
5456// FastEmit functions for ISD::MUL.
5457
5458Register fastEmit_ISD_MUL_MVT_i32_ri_Predicate_imm32SExt16(MVT RetVT, Register Op0, uint64_t imm1) {
5459 if (RetVT.SimpleTy != MVT::i32)
5460 return Register();
5461 return fastEmitInst_ri(MachineInstOpcode: PPC::MULLI, RC: &PPC::GPRCRegClass, Op0, Imm: imm1);
5462}
5463
5464Register fastEmit_ISD_MUL_ri_Predicate_imm32SExt16(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
5465 switch (VT.SimpleTy) {
5466 case MVT::i32: return fastEmit_ISD_MUL_MVT_i32_ri_Predicate_imm32SExt16(RetVT, Op0, imm1);
5467 default: return Register();
5468 }
5469}
5470
5471// FastEmit functions for PPCISD::XXSPLT.
5472
5473Register fastEmit_PPCISD_XXSPLT_MVT_v4i32_ri_Predicate_imm32SExt16(MVT RetVT, Register Op0, uint64_t imm1) {
5474 if (RetVT.SimpleTy != MVT::v4i32)
5475 return Register();
5476 if ((Subtarget->hasVSX())) {
5477 return fastEmitInst_ri(MachineInstOpcode: PPC::XXSPLTW, RC: &PPC::VSRCRegClass, Op0, Imm: imm1);
5478 }
5479 return Register();
5480}
5481
5482Register fastEmit_PPCISD_XXSPLT_ri_Predicate_imm32SExt16(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
5483 switch (VT.SimpleTy) {
5484 case MVT::v4i32: return fastEmit_PPCISD_XXSPLT_MVT_v4i32_ri_Predicate_imm32SExt16(RetVT, Op0, imm1);
5485 default: return Register();
5486 }
5487}
5488
5489// Top-level FastEmit function.
5490
5491Register fastEmit_ri_Predicate_imm32SExt16(MVT VT, MVT RetVT, unsigned Opcode, Register Op0, uint64_t imm1) {
5492 switch (Opcode) {
5493 case ISD::ADD: return fastEmit_ISD_ADD_ri_Predicate_imm32SExt16(VT, RetVT, Op0, imm1);
5494 case ISD::MUL: return fastEmit_ISD_MUL_ri_Predicate_imm32SExt16(VT, RetVT, Op0, imm1);
5495 case PPCISD::XXSPLT: return fastEmit_PPCISD_XXSPLT_ri_Predicate_imm32SExt16(VT, RetVT, Op0, imm1);
5496 default: return Register();
5497 }
5498}
5499
5500// FastEmit functions for ISD::ADD.
5501
5502Register fastEmit_ISD_ADD_MVT_i64_ri_Predicate_imm64SExt16(MVT RetVT, Register Op0, uint64_t imm1) {
5503 if (RetVT.SimpleTy != MVT::i64)
5504 return Register();
5505 return fastEmitInst_ri(MachineInstOpcode: PPC::ADDI8, RC: &PPC::G8RCRegClass, Op0, Imm: imm1);
5506}
5507
5508Register fastEmit_ISD_ADD_ri_Predicate_imm64SExt16(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
5509 switch (VT.SimpleTy) {
5510 case MVT::i64: return fastEmit_ISD_ADD_MVT_i64_ri_Predicate_imm64SExt16(RetVT, Op0, imm1);
5511 default: return Register();
5512 }
5513}
5514
5515// FastEmit functions for ISD::MUL.
5516
5517Register fastEmit_ISD_MUL_MVT_i64_ri_Predicate_imm64SExt16(MVT RetVT, Register Op0, uint64_t imm1) {
5518 if (RetVT.SimpleTy != MVT::i64)
5519 return Register();
5520 return fastEmitInst_ri(MachineInstOpcode: PPC::MULLI8, RC: &PPC::G8RCRegClass, Op0, Imm: imm1);
5521}
5522
5523Register fastEmit_ISD_MUL_ri_Predicate_imm64SExt16(MVT VT, MVT RetVT, Register Op0, uint64_t imm1) {
5524 switch (VT.SimpleTy) {
5525 case MVT::i64: return fastEmit_ISD_MUL_MVT_i64_ri_Predicate_imm64SExt16(RetVT, Op0, imm1);
5526 default: return Register();
5527 }
5528}
5529
5530// Top-level FastEmit function.
5531
5532Register fastEmit_ri_Predicate_imm64SExt16(MVT VT, MVT RetVT, unsigned Opcode, Register Op0, uint64_t imm1) {
5533 switch (Opcode) {
5534 case ISD::ADD: return fastEmit_ISD_ADD_ri_Predicate_imm64SExt16(VT, RetVT, Op0, imm1);
5535 case ISD::MUL: return fastEmit_ISD_MUL_ri_Predicate_imm64SExt16(VT, RetVT, Op0, imm1);
5536 default: return Register();
5537 }
5538}
5539
5540