79 : STI(ST), XLen(STI.getXLen()), sXLen(
LLT::scalar(XLen)),
80 iXLen(
LLT::integer(XLen)) {
136 auto BoolVecTys = {nxv1s1, nxv2s1, nxv4s1, nxv8s1, nxv16s1, nxv32s1, nxv64s1};
138 auto IntOrFPVecTys = {nxv1s8, nxv2s8, nxv4s8, nxv8s8, nxv16s8, nxv32s8,
139 nxv64s8, nxv1s16, nxv2s16, nxv4s16, nxv8s16, nxv16s16,
140 nxv32s16, nxv1s32, nxv2s32, nxv4s32, nxv8s32, nxv16s32,
141 nxv1s64, nxv2s64, nxv4s64, nxv8s64};
143 auto PtrVecTys = {nxv1p0, nxv2p0, nxv4p0, nxv8p0, nxv16p0};
159 {G_UADDE, G_UADDO, G_USUBE, G_USUBO, G_READ_REGISTER, G_WRITE_REGISTER})
168 {G_UADDSAT, G_SADDSAT, G_USUBSAT, G_SSUBSAT, G_SSHLSAT, G_USHLSAT})
172 .legalFor({{sXLen, sXLen}})
173 .customFor(ST.is64Bit(), {{s32, s32}})
174 .widenScalarToNextPow2(0)
178 getActionDefinitionsBuilder({G_ZEXT, G_SEXT, G_ANYEXT})
179 .legalFor({{s32, s16}})
180 .legalFor(
ST.is64Bit(), {{s64, s16}, {s64, s32}})
186 getActionDefinitionsBuilder(G_TRUNC).
alwaysLegal();
191 if (STI.hasStdExtZbb())
192 ValidSextInRegWidth =
195 getActionDefinitionsBuilder(G_SEXT_INREG)
196 .legalIf(
all(
typeIs(0, sXLen), ValidSextInRegWidth))
197 .clampScalar(0, sXLen, sXLen)
202 for (
unsigned Op : {G_MERGE_VALUES, G_UNMERGE_VALUES}) {
203 auto &MergeUnmergeActions = getActionDefinitionsBuilder(
Op);
204 unsigned BigTyIdx =
Op == G_MERGE_VALUES ? 0 : 1;
205 unsigned LitTyIdx =
Op == G_MERGE_VALUES ? 1 : 0;
206 if (XLen == 32 && (
ST.hasStdExtD() ||
ST.hasStdExtZilsd())) {
207 MergeUnmergeActions.legalIf(
210 MergeUnmergeActions.widenScalarToNextPow2(LitTyIdx, XLen)
211 .widenScalarToNextPow2(BigTyIdx, XLen)
212 .clampScalar(LitTyIdx, sXLen, sXLen)
213 .clampScalar(BigTyIdx, sXLen, sXLen);
216 getActionDefinitionsBuilder({G_FSHL, G_FSHR}).
lower();
218 getActionDefinitionsBuilder({G_ROTR, G_ROTL})
219 .legalFor(
ST.hasStdExtZbb() ||
ST.hasStdExtZbkb(), {{sXLen, sXLen}})
220 .customFor(
ST.is64Bit() && (
ST.hasStdExtZbb() ||
ST.hasStdExtZbkb()),
224 getActionDefinitionsBuilder(G_BITREVERSE)
225 .customFor(
ST.hasStdExtZbkb(), {s8})
227 .widenScalarToNextPow2(0)
231 getActionDefinitionsBuilder(G_BITCAST)
243 auto &BSWAPActions = getActionDefinitionsBuilder(G_BSWAP);
244 if (
ST.hasStdExtZbb() ||
ST.hasStdExtZbkb())
245 BSWAPActions.legalFor({sXLen}).clampScalar(0, sXLen, sXLen);
247 BSWAPActions.maxScalar(0, sXLen).lower();
249 getActionDefinitionsBuilder(G_CLMUL)
250 .legalFor(
ST.hasStdExtZbkc(), {sXLen})
253 getActionDefinitionsBuilder(G_CLMULH)
254 .legalFor(
ST.hasStdExtZbkc(), {sXLen})
255 .customFor(
ST.is64Bit() &&
ST.hasStdExtZbkc(), {s32})
259 getActionDefinitionsBuilder(G_CLMULR)
260 .legalFor(
ST.hasStdExtZbc(), {sXLen})
261 .customFor(
ST.is64Bit() &&
ST.hasStdExtZbc(), {s32})
264 auto &CTLZPoisonActions = getActionDefinitionsBuilder(G_CTLZ_ZERO_POISON);
265 auto &CTTZPoisonActions = getActionDefinitionsBuilder(G_CTTZ_ZERO_POISON);
266 if (
ST.hasStdExtZbb()) {
267 getActionDefinitionsBuilder({G_CTLZ, G_CTTZ})
268 .legalFor({{sXLen, sXLen}})
269 .customFor({{s32, s32}})
270 .clampScalar(0, s32, sXLen)
271 .widenScalarToNextPow2(0)
272 .scalarSameSizeAs(1, 0);
274 auto &CTLZActions = getActionDefinitionsBuilder(G_CTLZ);
275 if (
ST.hasVendorXTHeadBb())
276 CTLZActions.legalFor({{sXLen, sXLen}})
277 .clampScalar(0, sXLen, sXLen)
278 .scalarSameSizeAs(1, 0);
280 CTLZActions.maxScalar(0, sXLen).scalarSameSizeAs(1, 0).lower();
282 auto &CTTZActions = getActionDefinitionsBuilder(G_CTTZ);
283 if (
ST.hasVendorXTHeadBb()) {
284 CTTZActions.clampScalar(0, sXLen, sXLen).scalarSameSizeAs(1, 0).lower();
285 CTLZPoisonActions.clampScalar(0, sXLen, sXLen).scalarSameSizeAs(1, 0);
286 CTTZPoisonActions.clampScalar(0, sXLen, sXLen).scalarSameSizeAs(1, 0);
288 CTTZActions.maxScalar(0, sXLen).scalarSameSizeAs(1, 0).lower();
289 CTLZPoisonActions.maxScalar(0, sXLen).scalarSameSizeAs(1, 0);
290 CTTZPoisonActions.maxScalar(0, sXLen).scalarSameSizeAs(1, 0);
293 CTLZPoisonActions.lower();
294 CTTZPoisonActions.lower();
296 auto &CountSignActions = getActionDefinitionsBuilder(G_CTLS);
297 if (
ST.hasStdExtP()) {
298 CountSignActions.legalFor({{sXLen, sXLen}})
299 .customFor({{s32, s32}})
300 .clampScalar(0, s32, sXLen)
301 .widenScalarToNextPow2(0)
302 .scalarSameSizeAs(1, 0);
304 CountSignActions.maxScalar(0, sXLen).scalarSameSizeAs(1, 0).lower();
307 auto &CTPOPActions = getActionDefinitionsBuilder(G_CTPOP);
308 if (
ST.hasStdExtZbb()) {
309 CTPOPActions.legalFor({{sXLen, sXLen}})
310 .clampScalar(0, sXLen, sXLen)
311 .scalarSameSizeAs(1, 0);
313 CTPOPActions.widenScalarToNextPow2(0, 8)
314 .clampScalar(0, s8, sXLen)
315 .scalarSameSizeAs(1, 0)
319 getActionDefinitionsBuilder(G_CONSTANT)
321 .legalFor(!
ST.is64Bit(), {s32})
322 .customFor(
ST.is64Bit(), {s64})
323 .widenScalarToNextPow2(0)
324 .clampScalar(0, sXLen, sXLen);
327 getActionDefinitionsBuilder(G_FREEZE)
328 .legalFor({s16, s32, p0})
329 .legalFor(
ST.is64Bit(), {s64})
332 .widenScalarToNextPow2(0)
333 .clampScalar(0, s16, sXLen);
337 getActionDefinitionsBuilder(
338 {G_IMPLICIT_DEF, G_CONSTANT_FOLD_BARRIER})
339 .legalFor({s32, sXLen, p0})
342 .widenScalarToNextPow2(0)
343 .clampScalar(0, s32, sXLen);
345 getActionDefinitionsBuilder(G_ICMP)
346 .legalFor({{sXLen, sXLen}, {sXLen, p0}})
349 .widenScalarOrEltToNextPow2OrMinSize(1, 8)
350 .clampScalar(1, sXLen, sXLen)
351 .clampScalar(0, sXLen, sXLen);
353 getActionDefinitionsBuilder(G_SELECT)
354 .legalFor({{s32, sXLen}, {p0, sXLen}})
357 .legalFor(XLen == 64 ||
ST.hasStdExtD(), {{s64, sXLen}})
358 .widenScalarToNextPow2(0)
359 .clampScalar(0, s32, (XLen == 64 ||
ST.hasStdExtD()) ? s64 : s32)
360 .clampScalar(1, sXLen, sXLen);
362 auto &LoadActions = getActionDefinitionsBuilder(G_LOAD);
363 auto &StoreActions = getActionDefinitionsBuilder(G_STORE);
364 auto &ExtLoadActions = getActionDefinitionsBuilder({G_SEXTLOAD, G_ZEXTLOAD});
369 auto getScalarMemAlign = [&
ST](
unsigned Size) {
370 return ST.enableUnalignedScalarMem() ? 8 :
Size;
373 LoadActions.legalForTypesWithMemDesc(
374 {{s16, p0, s8, getScalarMemAlign(8)},
375 {s32, p0, s8, getScalarMemAlign(8)},
376 {s16, p0, s16, getScalarMemAlign(16)},
377 {s32, p0, s16, getScalarMemAlign(16)},
378 {s32, p0, s32, getScalarMemAlign(32)},
379 {p0, p0, sXLen, getScalarMemAlign(XLen)}});
380 StoreActions.legalForTypesWithMemDesc(
381 {{s16, p0, s8, getScalarMemAlign(8)},
382 {s32, p0, s8, getScalarMemAlign(8)},
383 {s16, p0, s16, getScalarMemAlign(16)},
384 {s32, p0, s16, getScalarMemAlign(16)},
385 {s32, p0, s32, getScalarMemAlign(32)},
386 {p0, p0, sXLen, getScalarMemAlign(XLen)}});
387 ExtLoadActions.legalForTypesWithMemDesc(
388 {{sXLen, p0, s8, getScalarMemAlign(8)},
389 {sXLen, p0, s16, getScalarMemAlign(16)}});
391 LoadActions.legalForTypesWithMemDesc(
392 {{s64, p0, s8, getScalarMemAlign(8)},
393 {s64, p0, s16, getScalarMemAlign(16)},
394 {s64, p0, s32, getScalarMemAlign(32)},
395 {s64, p0, s64, getScalarMemAlign(64)}});
396 StoreActions.legalForTypesWithMemDesc(
397 {{s64, p0, s8, getScalarMemAlign(8)},
398 {s64, p0, s16, getScalarMemAlign(16)},
399 {s64, p0, s32, getScalarMemAlign(32)},
400 {s64, p0, s64, getScalarMemAlign(64)}});
401 ExtLoadActions.legalForTypesWithMemDesc(
402 {{s64, p0, s32, getScalarMemAlign(32)}});
403 }
else if (
ST.hasStdExtD() ||
ST.hasStdExtZilsd()) {
409 LoadActions.legalForTypesWithMemDesc(
410 {{s64, p0, s64, getScalarMemAlign(64)}});
411 StoreActions.legalForTypesWithMemDesc(
412 {{s64, p0, s64, getScalarMemAlign(64)}});
416 if (
ST.hasVInstructions()) {
417 LoadActions.legalForTypesWithMemDesc({{nxv2s8, p0, nxv2s8, 8},
418 {nxv4s8, p0, nxv4s8, 8},
419 {nxv8s8, p0, nxv8s8, 8},
420 {nxv16s8, p0, nxv16s8, 8},
421 {nxv32s8, p0, nxv32s8, 8},
422 {nxv64s8, p0, nxv64s8, 8},
423 {nxv2s16, p0, nxv2s16, 16},
424 {nxv4s16, p0, nxv4s16, 16},
425 {nxv8s16, p0, nxv8s16, 16},
426 {nxv16s16, p0, nxv16s16, 16},
427 {nxv32s16, p0, nxv32s16, 16},
428 {nxv2s32, p0, nxv2s32, 32},
429 {nxv4s32, p0, nxv4s32, 32},
430 {nxv8s32, p0, nxv8s32, 32},
431 {nxv16s32, p0, nxv16s32, 32}});
432 StoreActions.legalForTypesWithMemDesc({{nxv2s8, p0, nxv2s8, 8},
433 {nxv4s8, p0, nxv4s8, 8},
434 {nxv8s8, p0, nxv8s8, 8},
435 {nxv16s8, p0, nxv16s8, 8},
436 {nxv32s8, p0, nxv32s8, 8},
437 {nxv64s8, p0, nxv64s8, 8},
438 {nxv2s16, p0, nxv2s16, 16},
439 {nxv4s16, p0, nxv4s16, 16},
440 {nxv8s16, p0, nxv8s16, 16},
441 {nxv16s16, p0, nxv16s16, 16},
442 {nxv32s16, p0, nxv32s16, 16},
443 {nxv2s32, p0, nxv2s32, 32},
444 {nxv4s32, p0, nxv4s32, 32},
445 {nxv8s32, p0, nxv8s32, 32},
446 {nxv16s32, p0, nxv16s32, 32}});
448 if (
ST.getELen() == 64) {
449 LoadActions.legalForTypesWithMemDesc({{nxv1s8, p0, nxv1s8, 8},
450 {nxv1s16, p0, nxv1s16, 16},
451 {nxv1s32, p0, nxv1s32, 32}});
452 StoreActions.legalForTypesWithMemDesc({{nxv1s8, p0, nxv1s8, 8},
453 {nxv1s16, p0, nxv1s16, 16},
454 {nxv1s32, p0, nxv1s32, 32}});
457 if (
ST.hasVInstructionsI64()) {
458 LoadActions.legalForTypesWithMemDesc({{nxv1s64, p0, nxv1s64, 64},
459 {nxv2s64, p0, nxv2s64, 64},
460 {nxv4s64, p0, nxv4s64, 64},
461 {nxv8s64, p0, nxv8s64, 64}});
462 StoreActions.legalForTypesWithMemDesc({{nxv1s64, p0, nxv1s64, 64},
463 {nxv2s64, p0, nxv2s64, 64},
464 {nxv4s64, p0, nxv4s64, 64},
465 {nxv8s64, p0, nxv8s64, 64}});
474 if (XLen <=
ST.getELen()) {
480 LoadActions.widenScalarToNextPow2(0, 8)
481 .lowerIfMemSizeNotByteSizePow2()
482 .clampScalar(0, s16, sXLen)
485 .clampScalar(0, s16, sXLen)
486 .lowerIfMemSizeNotByteSizePow2()
489 ExtLoadActions.widenScalarToNextPow2(0).clampScalar(0, sXLen, sXLen).lower();
491 getActionDefinitionsBuilder({G_PTR_ADD, G_PTRMASK}).legalFor({{p0, sXLen}});
493 getActionDefinitionsBuilder(G_PTRTOINT)
494 .legalFor({{sXLen, p0}})
495 .clampScalar(0, sXLen, sXLen);
497 getActionDefinitionsBuilder(G_INTTOPTR)
498 .legalFor({{p0, sXLen}})
499 .clampScalar(1, sXLen, sXLen);
501 getActionDefinitionsBuilder(G_BR).alwaysLegal();
503 getActionDefinitionsBuilder(G_BRCOND).legalFor({sXLen}).minScalar(0, sXLen);
505 getActionDefinitionsBuilder(G_BRJT).customFor({{p0, sXLen}});
507 getActionDefinitionsBuilder(G_BRINDIRECT).legalFor({p0});
509 getActionDefinitionsBuilder(G_PHI)
510 .legalFor({p0, s32, sXLen})
511 .widenScalarToNextPow2(0)
512 .clampScalar(0, s32, sXLen);
514 getActionDefinitionsBuilder({G_GLOBAL_VALUE, G_JUMP_TABLE, G_CONSTANT_POOL})
517 if (
ST.hasStdExtZmmul()) {
518 getActionDefinitionsBuilder(G_MUL)
520 .widenScalarToNextPow2(0)
521 .clampScalar(0, sXLen, sXLen);
524 getActionDefinitionsBuilder({G_SMULH, G_UMULH})
529 getActionDefinitionsBuilder({G_SMULO, G_UMULO}).minScalar(0, sXLen).lower();
531 getActionDefinitionsBuilder(G_MUL)
532 .libcallFor({sXLen, sDoubleXLen})
533 .widenScalarToNextPow2(0)
534 .clampScalar(0, sXLen, sDoubleXLen);
536 getActionDefinitionsBuilder({G_SMULH, G_UMULH}).lowerFor({sXLen});
538 getActionDefinitionsBuilder({G_SMULO, G_UMULO})
543 .widenScalarIf(
typeIs(0, sXLen),
548 if (
ST.hasStdExtM()) {
549 getActionDefinitionsBuilder({G_SDIV, G_UDIV, G_UREM})
552 .libcallFor({sDoubleXLen})
553 .clampScalar(0, s32, sDoubleXLen)
554 .widenScalarToNextPow2(0);
555 getActionDefinitionsBuilder(G_SREM)
557 .libcallFor({sDoubleXLen})
558 .clampScalar(0, sXLen, sDoubleXLen)
559 .widenScalarToNextPow2(0);
561 getActionDefinitionsBuilder({G_UDIV, G_SDIV, G_UREM, G_SREM})
562 .libcallFor({sXLen, sDoubleXLen})
563 .clampScalar(0, sXLen, sDoubleXLen)
564 .widenScalarToNextPow2(0);
568 getActionDefinitionsBuilder({G_SDIVREM, G_UDIVREM}).
lower();
570 getActionDefinitionsBuilder(G_ABS)
571 .customFor(
ST.hasStdExtZbb(), {sXLen})
572 .minScalar(
ST.hasStdExtZbb(), 0, sXLen)
575 getActionDefinitionsBuilder({G_ABDS, G_ABDU})
576 .minScalar(
ST.hasStdExtZbb(), 0, sXLen)
579 getActionDefinitionsBuilder({G_UMAX, G_UMIN, G_SMAX, G_SMIN})
580 .legalFor(
ST.hasStdExtZbb(), {sXLen})
581 .minScalar(
ST.hasStdExtZbb(), 0, sXLen)
584 getActionDefinitionsBuilder({G_SCMP, G_UCMP}).
lower();
586 getActionDefinitionsBuilder(G_FRAME_INDEX).legalFor({p0});
588 getActionDefinitionsBuilder({G_MEMCPY, G_MEMMOVE, G_MEMSET}).
libcall();
590 getActionDefinitionsBuilder({G_MEMCPY_INLINE, G_MEMSET_INLINE}).
lower();
592 getActionDefinitionsBuilder({G_DYN_STACKALLOC, G_STACKSAVE, G_STACKRESTORE})
598 getActionDefinitionsBuilder({G_READCYCLECOUNTER, G_READSTEADYCOUNTER})
599 .legalFor(
ST.is64Bit(), {s64})
600 .customFor(!
ST.is64Bit(), {s64});
605 getActionDefinitionsBuilder({G_FADD, G_FSUB, G_FMUL, G_FDIV, G_FMA, G_FSQRT,
606 G_FMAXNUM, G_FMINNUM, G_FMAXIMUMNUM,
608 .legalFor(
ST.hasStdExtF(), {f32})
609 .legalFor(
ST.hasStdExtD(), {f64})
610 .legalFor(
ST.hasStdExtZfh(), {f16})
611 .libcallFor({f32, f64})
612 .libcallFor(
ST.is64Bit(), {f128});
614 getActionDefinitionsBuilder({G_FNEG, G_FABS})
615 .legalFor(
ST.hasStdExtF(), {f32})
616 .legalFor(
ST.hasStdExtD(), {f64})
617 .legalFor(
ST.hasStdExtZfh(), {f16})
618 .lowerFor({f32, f64, f128});
620 getActionDefinitionsBuilder(G_FREM)
621 .libcallFor({f32, f64})
622 .libcallFor(
ST.is64Bit(), {f128})
626 getActionDefinitionsBuilder(G_FCOPYSIGN)
627 .legalFor(
ST.hasStdExtF(), {{f32, f32}})
628 .legalFor(
ST.hasStdExtD(), {{f64, f64}, {f32, f64}, {f64, f32}})
629 .legalFor(
ST.hasStdExtZfh(), {{f16, f16}, {f16, f32}, {f32, f16}})
630 .legalFor(
ST.hasStdExtZfh() &&
ST.hasStdExtD(), {{f16, f64}, {f64, f16}})
633 getActionDefinitionsBuilder(G_FPTRUNC)
634 .legalFor(
ST.hasStdExtD(), {{f32, f64}})
635 .legalFor(
ST.hasStdExtZfhmin(), {{f16, f32}})
636 .legalFor(
ST.hasStdExtZfhmin() &&
ST.hasStdExtD(), {{f16, f64}})
637 .libcallFor({{f16, f32}, {f16, f64}, {f32, f64}})
638 .libcallFor(
ST.is64Bit(), {{f32, f128}, {f64, f128}});
639 getActionDefinitionsBuilder(G_FPEXT)
640 .legalFor(
ST.hasStdExtD(), {{f64, f32}})
641 .legalFor(
ST.hasStdExtZfhmin(), {{f32, f16}})
642 .legalFor(
ST.hasStdExtZfhmin() &&
ST.hasStdExtD(), {{f64, f16}})
643 .libcallFor(!
ST.hasStdExtZfhmin(), {{f32, f16}})
644 .libcallFor(!(
ST.hasStdExtZfhmin() &&
ST.hasStdExtD()), {{f64, f16}})
645 .libcallFor({{f64, f32}})
646 .libcallFor(
ST.is64Bit(), {{f128, f32}, {f128, f64}});
648 getActionDefinitionsBuilder(G_FCMP)
649 .legalFor(
ST.hasStdExtF(), {{sXLen, f32}})
650 .legalFor(
ST.hasStdExtD(), {{sXLen, f64}})
651 .legalFor(
ST.hasStdExtZfh(), {{sXLen, f16}})
652 .clampScalar(0, sXLen, sXLen)
654 .libcallFor({{sXLen, f32}, {sXLen, f64}})
655 .libcallFor(
ST.is64Bit(), {{sXLen, f128}});
658 getActionDefinitionsBuilder(G_IS_FPCLASS)
659 .customFor(
ST.hasStdExtF(), {{s1, f32}})
660 .customFor(
ST.hasStdExtD(), {{s1, f64}})
661 .customFor(
ST.hasStdExtZfh(), {{s1, f16}})
664 getActionDefinitionsBuilder(G_FCONSTANT)
665 .legalFor(
ST.hasStdExtF(), {f32})
666 .legalFor(
ST.hasStdExtD(), {f64})
667 .legalFor(
ST.hasStdExtZfhmin(), {f16})
670 getActionDefinitionsBuilder({G_FPTOSI, G_FPTOUI})
671 .legalFor(
ST.hasStdExtF(), {{sXLen, f32}})
672 .legalFor(
ST.hasStdExtD(), {{sXLen, f64}})
673 .legalFor(
ST.hasStdExtZfh(), {{sXLen, f16}})
674 .customFor(
ST.is64Bit() &&
ST.hasStdExtF(), {{s32, f32}})
675 .customFor(
ST.is64Bit() &&
ST.hasStdExtD(), {{s32, f64}})
676 .customFor(
ST.is64Bit() &&
ST.hasStdExtZfh(), {{s32, f16}})
677 .widenScalarToNextPow2(0)
686 return Query.
Types[1] == f16 && !
ST.hasStdExtZfh() &&
687 (
ST.is64Bit() || Query.
Types[0].isScalar(32));
690 .libcallFor(!
ST.hasStdExtZfhmin(), {{s64, f16}})
691 .narrowScalarFor({{s64, f16}},
changeTo(0, s32))
692 .libcallFor({{s32, f32}, {s64, f32}, {s32, f64}, {s64, f64}})
693 .libcallFor(
ST.is64Bit(), {{s32, f128}, {s64, f128}})
694 .libcallFor(
ST.is64Bit(), {{s128, f32}, {s128, f64}, {s128, f128}});
701 getActionDefinitionsBuilder({G_FPTOSI_SAT, G_FPTOUI_SAT})
702 .customFor(
ST.hasStdExtF(), {{sXLen, f32}})
703 .customFor(
ST.hasStdExtD(), {{sXLen, f64}})
704 .customFor(
ST.hasStdExtZfh(), {{sXLen, f16}})
705 .customFor(
ST.is64Bit() &&
ST.hasStdExtF(), {{s32, f32}})
706 .customFor(
ST.is64Bit() &&
ST.hasStdExtD(), {{s32, f64}})
707 .customFor(
ST.is64Bit() &&
ST.hasStdExtZfh(), {{s32, f16}})
713 getActionDefinitionsBuilder({G_LROUND, G_LLROUND})
714 .legalFor(
ST.hasStdExtF(), {{sXLen, f32}})
715 .legalFor(
ST.hasStdExtD(), {{sXLen, f64}})
716 .legalFor(
ST.hasStdExtZfh(), {{sXLen, f16}})
717 .customFor(
ST.is64Bit() &&
ST.hasStdExtF(), {{s32, f32}})
718 .customFor(
ST.is64Bit() &&
ST.hasStdExtD(), {{s32, f64}})
719 .customFor(
ST.is64Bit() &&
ST.hasStdExtZfh(), {{s32, f16}})
721 .libcallFor({{s32, f32},
728 getActionDefinitionsBuilder({G_INTRINSIC_LRINT, G_INTRINSIC_LLRINT})
729 .legalFor(
ST.hasStdExtF(), {{sXLen, f32}})
730 .legalFor(
ST.hasStdExtD(), {{sXLen, f64}})
731 .legalFor(
ST.hasStdExtZfh(), {{sXLen, f16}})
734 .libcallFor({{s32, f32},
741 getActionDefinitionsBuilder({G_SITOFP, G_UITOFP})
742 .legalFor(
ST.hasStdExtF(), {{f32, sXLen}})
743 .legalFor(
ST.hasStdExtD(), {{f64, sXLen}})
744 .legalFor(
ST.hasStdExtZfh(), {{f16, sXLen}})
745 .widenScalarToNextPow2(1)
749 return Query.
Types[0].isScalar() && Query.
Types[1].isScalar() &&
750 (Query.
Types[1].getSizeInBits() <
ST.getXLen()) &&
751 ((
ST.hasStdExtF() && Query.
Types[0].getSizeInBits() == 32) ||
752 (
ST.hasStdExtD() && Query.
Types[0].getSizeInBits() == 64) ||
753 (
ST.hasStdExtZfh() &&
754 Query.
Types[0].getSizeInBits() == 16));
759 .libcallFor({{f32, s32}, {f64, s32}, {f32, s64}, {f64, s64}})
760 .libcallFor(
ST.is64Bit(), {{f128, s32}, {f128, s64}})
761 .libcallFor(
ST.is64Bit(), {{f32, s128}, {f64, s128}, {f128, s128}});
764 getActionDefinitionsBuilder({G_FCEIL, G_FFLOOR, G_FRINT, G_FNEARBYINT,
765 G_INTRINSIC_TRUNC, G_INTRINSIC_ROUND,
766 G_INTRINSIC_ROUNDEVEN})
767 .legalFor(
ST.hasStdExtZfa(), {f32})
768 .legalFor(
ST.hasStdExtZfa() &&
ST.hasStdExtD(), {f64})
769 .legalFor(
ST.hasStdExtZfa() &&
ST.hasStdExtZfh(), {f16})
770 .libcallFor({f32, f64})
771 .libcallFor(
ST.is64Bit(), {f128});
773 getActionDefinitionsBuilder({G_FMAXIMUM, G_FMINIMUM})
774 .legalFor(
ST.hasStdExtZfa(), {f32})
775 .legalFor(
ST.hasStdExtZfa() &&
ST.hasStdExtD(), {f64})
776 .legalFor(
ST.hasStdExtZfa() &&
ST.hasStdExtZfh(), {f16});
778 getActionDefinitionsBuilder({G_FCOS, G_FSIN, G_FTAN, G_FPOW, G_FLOG, G_FLOG2,
779 G_FLOG10, G_FEXP, G_FEXP2, G_FEXP10, G_FACOS,
780 G_FASIN, G_FATAN, G_FATAN2, G_FCOSH, G_FSINH,
781 G_FTANH, G_FMODF, G_FSINCOS})
782 .libcallFor({f32, f64})
783 .libcallFor(
ST.is64Bit(), {f128});
784 getActionDefinitionsBuilder({G_FPOWI, G_FLDEXP})
785 .libcallFor({{f32, s32}, {f64, s32}})
786 .libcallFor(
ST.is64Bit(), {f128, s32});
788 getActionDefinitionsBuilder(G_FCANONICALIZE)
789 .legalFor(
ST.hasStdExtF(), {f32})
790 .legalFor(
ST.hasStdExtD(), {f64})
791 .legalFor(
ST.hasStdExtZfh(), {f16});
793 getActionDefinitionsBuilder(G_VASTART).customFor({p0});
797 getActionDefinitionsBuilder(G_VAARG)
800 .clampScalar(0, sXLen, sXLen)
801 .lowerForCartesianProduct({sXLen, p0}, {p0});
803 getActionDefinitionsBuilder(G_VSCALE)
804 .clampScalar(0, sXLen, sXLen)
808 getActionDefinitionsBuilder(G_SPLAT_VECTOR)
820 if (
ST.hasVInstructionsF64() &&
ST.hasStdExtD())
821 SplatActions.legalIf(
all(
823 else if (
ST.hasVInstructionsI64())
824 SplatActions.customIf(
all(
828 SplatActions.clampScalar(1, sXLen, sXLen);
837 getActionDefinitionsBuilder(G_EXTRACT_SUBVECTOR)
846 Query.
Types[0].getElementCount().divideCoefficientBy(8), 8);
847 return std::pair(0, CastTy);
855 getActionDefinitionsBuilder(G_INSERT_SUBVECTOR)
861 getActionDefinitionsBuilder(G_ATOMIC_CMPXCHG_WITH_SUCCESS)
864 getActionDefinitionsBuilder({G_ATOMIC_CMPXCHG, G_ATOMICRMW_ADD,
865 G_ATOMICRMW_XCHG, G_ATOMICRMW_AND,
866 G_ATOMICRMW_OR, G_ATOMICRMW_XOR})
867 .legalFor(
ST.hasStdExtA(), {{sXLen, p0}})
868 .libcallFor(!
ST.hasStdExtA(), {{s8, p0}, {s16, p0}, {s32, p0}, {s64, p0}})
869 .clampScalar(0, sXLen, sXLen);
871 getActionDefinitionsBuilder(G_ATOMICRMW_SUB)
872 .libcallFor(!
ST.hasStdExtA(), {{s8, p0}, {s16, p0}, {s32, p0}, {s64, p0}})
873 .clampScalar(0, sXLen, sXLen)
876 getActionDefinitionsBuilder(
877 {G_ATOMICRMW_MAX, G_ATOMICRMW_MIN, G_ATOMICRMW_UMAX, G_ATOMICRMW_UMIN})
878 .legalFor(
ST.hasStdExtA(), {{sXLen, p0}})
879 .clampScalar(0, sXLen, sXLen)
882 getActionDefinitionsBuilder(G_PREFETCH).legalIf(
typeIs(0, p0));
890 getActionDefinitionsBuilder(G_INSERT_VECTOR_ELT)
892 InsertVectorEltPred,
typeIs(2, sXLen)))
896 getActionDefinitionsBuilder({G_INTRINSIC, G_INTRINSIC_W_SIDE_EFFECTS})
899 getActionDefinitionsBuilder(G_FENCE).alwaysLegal();
901 getActionDefinitionsBuilder({G_TRAP, G_DEBUGTRAP, G_UBSANTRAP}).alwaysLegal();