15#ifndef LLVM_LIB_CODEGEN_SELECTIONDAG_LEGALIZETYPES_H
16#define LLVM_LIB_CODEGEN_SELECTIONDAG_LEGALIZETYPES_H
66 bool isTypeLegal(EVT VT)
const {
67 return TLI.getTypeAction(*DAG.
getContext(), VT) == TargetLowering::TypeLegal;
71 bool isSimpleLegalType(EVT VT)
const {
72 return VT.isSimple() && TLI.isTypeLegal(VT);
75 EVT getSetCCResultType(EVT VT)
const {
80 bool IgnoreNodeResults(SDNode *
N)
const {
81 return N->getOpcode() == ISD::TargetConstant ||
82 N->getOpcode() == ISD::Register;
88 typedef unsigned TableId;
90 TableId NextValueId = 1;
92 SmallDenseMap<SDValue, TableId, 8> ValueToIdMap;
93 SmallDenseMap<TableId, SDValue, 8> IdToValueMap;
97 SmallDenseMap<TableId, TableId, 8> PromotedIntegers;
101 SmallDenseMap<TableId, std::pair<TableId, TableId>, 8> ExpandedIntegers;
105 SmallDenseMap<TableId, TableId, 8> SoftenedFloats;
109 SmallDenseMap<TableId, TableId, 8> PromotedFloats;
113 SmallDenseMap<TableId, TableId, 8> SoftPromotedHalfs;
117 SmallDenseMap<TableId, std::pair<TableId, TableId>, 8> ExpandedFloats;
121 SmallDenseMap<TableId, TableId, 8> ScalarizedVectors;
125 SmallDenseMap<TableId, std::pair<TableId, TableId>, 8> SplitVectors;
129 SmallDenseMap<TableId, TableId, 8> WidenedVectors;
133 SmallDenseMap<TableId, TableId, 8> ReplacedValues;
137 SmallVector<SDNode*, 128> Worklist;
139 TableId getTableId(SDValue V) {
140 assert(
V.getNode() &&
"Getting TableId on SDValue()");
142 auto I = ValueToIdMap.find(V);
143 if (
I != ValueToIdMap.end()) {
146 assert(
I->second &&
"All Ids should be nonzero");
150 ValueToIdMap.insert(std::make_pair(V, NextValueId));
151 IdToValueMap.insert(std::make_pair(NextValueId, V));
153 assert(NextValueId != 0 &&
154 "Ran out of Ids. Increase id type size or add compactification");
155 return NextValueId - 1;
158 const SDValue &getSDValue(TableId &Id) {
160 assert(Id &&
"TableId should be non-zero");
161 auto I = IdToValueMap.find(Id);
162 assert(
I != IdToValueMap.end() &&
"cannot find Id in map");
168 : TLI(dag.getTargetLoweringInfo()), DAG(dag),
169 ValueTypeActions(TLI.getValueTypeActions()) {
170 static_assert(MVT::LAST_VALUETYPE <= MVT::MAX_ALLOWED_VALUETYPE,
171 "Too many value types for ValueTypeActions to hold!");
180 assert(Old != New &&
"node replaced with self");
181 for (
unsigned i = 0, e = Old->
getNumValues(); i != e; ++i) {
185 if (OldId != NewId) {
186 ReplacedValues[OldId] = NewId;
191 IdToValueMap.erase(OldId);
192 PromotedIntegers.erase(OldId);
193 ExpandedIntegers.erase(OldId);
194 SoftenedFloats.erase(OldId);
195 PromotedFloats.erase(OldId);
196 SoftPromotedHalfs.erase(OldId);
197 ExpandedFloats.erase(OldId);
198 ScalarizedVectors.erase(OldId);
199 SplitVectors.erase(OldId);
200 WidenedVectors.erase(OldId);
203 ValueToIdMap.erase(
SDValue(Old, i));
211 void AnalyzeNewValue(
SDValue &Val);
212 void PerformExpensiveChecks();
213 void RemapId(TableId &Id);
220 bool CustomLowerNode(
SDNode *
N,
EVT VT,
bool LegalizeResult);
230 std::pair<SDValue, SDValue> ExpandAtomic(
SDNode *
Node);
253 TableId &PromotedId = PromotedIntegers[getTableId(
Op)];
254 SDValue PromotedOp = getSDValue(PromotedId);
258 void SetPromotedInteger(SDValue Op, SDValue Result);
261 SDValue SExtPromotedInteger(SDValue Op) {
262 EVT OldVT = Op.getValueType();
264 Op = GetPromotedInteger(Op);
265 return DAG.
getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(), Op,
270 SDValue ZExtPromotedInteger(SDValue Op) {
271 EVT OldVT =
Op.getValueType();
273 Op = GetPromotedInteger(Op);
281 SDValue SExtOrZExtPromotedInteger(SDValue Op) {
282 EVT OldVT =
Op.getValueType();
284 Op = GetPromotedInteger(Op);
285 if (TLI.isSExtCheaperThanZExt(OldVT,
Op.getValueType()))
286 return DAG.
getNode(ISD::SIGN_EXTEND_INREG,
DL,
Op.getValueType(), Op,
295 SDValue PromoteIntOpVectorReduction(SDNode *
N, SDValue V);
298 void PromoteIntegerResult(SDNode *
N,
unsigned ResNo);
299 SDValue PromoteIntRes_MERGE_VALUES(SDNode *
N,
unsigned ResNo);
300 SDValue PromoteIntRes_AssertSext(SDNode *
N);
301 SDValue PromoteIntRes_AssertZext(SDNode *
N);
302 SDValue PromoteIntRes_Atomic0(AtomicSDNode *
N);
303 SDValue PromoteIntRes_Atomic1(AtomicSDNode *
N);
304 SDValue PromoteIntRes_AtomicCmpSwap(AtomicSDNode *
N,
unsigned ResNo);
305 SDValue PromoteIntRes_EXTRACT_SUBVECTOR(SDNode *
N);
306 SDValue PromoteIntRes_INSERT_SUBVECTOR(SDNode *
N);
307 SDValue PromoteIntRes_VECTOR_REVERSE(SDNode *
N);
308 SDValue PromoteIntRes_VECTOR_SHUFFLE(SDNode *
N);
309 SDValue PromoteIntRes_VECTOR_SPLICE(SDNode *
N);
310 SDValue PromoteIntRes_VECTOR_INTERLEAVE_DEINTERLEAVE(SDNode *
N);
311 SDValue PromoteIntRes_BUILD_VECTOR(SDNode *
N);
312 SDValue PromoteIntRes_ScalarOp(SDNode *
N);
313 SDValue PromoteIntRes_STEP_VECTOR(SDNode *
N);
314 SDValue PromoteIntRes_EXTEND_VECTOR_INREG(SDNode *
N);
315 SDValue PromoteIntRes_INSERT_VECTOR_ELT(SDNode *
N);
316 SDValue PromoteIntRes_CONCAT_VECTORS(SDNode *
N);
317 SDValue PromoteIntRes_BITCAST(SDNode *
N);
318 SDValue PromoteIntRes_BSWAP(SDNode *
N);
319 SDValue PromoteIntRes_BITREVERSE(SDNode *
N);
320 SDValue PromoteIntRes_BUILD_PAIR(SDNode *
N);
321 SDValue PromoteIntRes_Constant(SDNode *
N);
322 SDValue PromoteIntRes_CTLZ(SDNode *
N);
323 SDValue PromoteIntRes_CTPOP_PARITY(SDNode *
N);
324 SDValue PromoteIntRes_CTTZ(SDNode *
N);
325 SDValue PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *
N);
326 SDValue PromoteIntRes_FP_TO_XINT(SDNode *
N);
327 SDValue PromoteIntRes_FP_TO_XINT_SAT(SDNode *
N);
328 SDValue PromoteIntRes_FP_TO_FP16_BF16(SDNode *
N);
329 SDValue PromoteIntRes_FREEZE(SDNode *
N);
330 SDValue PromoteIntRes_INT_EXTEND(SDNode *
N);
331 SDValue PromoteIntRes_LOAD(LoadSDNode *
N);
332 SDValue PromoteIntRes_MLOAD(MaskedLoadSDNode *
N);
333 SDValue PromoteIntRes_MGATHER(MaskedGatherSDNode *
N);
334 SDValue PromoteIntRes_Overflow(SDNode *
N);
335 SDValue PromoteIntRes_FFREXP(SDNode *
N);
336 SDValue PromoteIntRes_SADDSUBO(SDNode *
N,
unsigned ResNo);
337 SDValue PromoteIntRes_Select(SDNode *
N);
338 SDValue PromoteIntRes_SELECT_CC(SDNode *
N);
339 SDValue PromoteIntRes_SETCC(SDNode *
N);
340 SDValue PromoteIntRes_SHL(SDNode *
N);
341 SDValue PromoteIntRes_SimpleIntBinOp(SDNode *
N);
342 SDValue PromoteIntRes_ZExtIntBinOp(SDNode *
N);
343 SDValue PromoteIntRes_SExtIntBinOp(SDNode *
N);
344 SDValue PromoteIntRes_UMINUMAX(SDNode *
N);
345 SDValue PromoteIntRes_SIGN_EXTEND_INREG(SDNode *
N);
346 SDValue PromoteIntRes_SRA(SDNode *
N);
347 SDValue PromoteIntRes_SRL(SDNode *
N);
348 SDValue PromoteIntRes_TRUNCATE(SDNode *
N);
349 SDValue PromoteIntRes_UADDSUBO(SDNode *
N,
unsigned ResNo);
350 SDValue PromoteIntRes_UADDSUBO_CARRY(SDNode *
N,
unsigned ResNo);
351 SDValue PromoteIntRes_SADDSUBO_CARRY(SDNode *
N,
unsigned ResNo);
352 SDValue PromoteIntRes_UNDEF(SDNode *
N);
353 SDValue PromoteIntRes_VAARG(SDNode *
N);
354 SDValue PromoteIntRes_VSCALE(SDNode *
N);
355 SDValue PromoteIntRes_XMULO(SDNode *
N,
unsigned ResNo);
356 SDValue PromoteIntRes_ADDSUBSHLSAT(SDNode *
N);
357 SDValue PromoteIntRes_MULFIX(SDNode *
N);
358 SDValue PromoteIntRes_DIVFIX(SDNode *
N);
359 SDValue PromoteIntRes_GET_ROUNDING(SDNode *
N);
360 SDValue PromoteIntRes_VECREDUCE(SDNode *
N);
361 SDValue PromoteIntRes_VP_REDUCE(SDNode *
N);
362 SDValue PromoteIntRes_ABS(SDNode *
N);
363 SDValue PromoteIntRes_Rotate(SDNode *
N);
364 SDValue PromoteIntRes_FunnelShift(SDNode *
N);
365 SDValue PromoteIntRes_VPFunnelShift(SDNode *
N);
366 SDValue PromoteIntRes_IS_FPCLASS(SDNode *
N);
369 bool PromoteIntegerOperand(SDNode *
N,
unsigned OpNo);
370 SDValue PromoteIntOp_ANY_EXTEND(SDNode *
N);
371 SDValue PromoteIntOp_ATOMIC_STORE(AtomicSDNode *
N);
372 SDValue PromoteIntOp_BITCAST(SDNode *
N);
373 SDValue PromoteIntOp_BUILD_PAIR(SDNode *
N);
374 SDValue PromoteIntOp_BR_CC(SDNode *
N,
unsigned OpNo);
375 SDValue PromoteIntOp_BRCOND(SDNode *
N,
unsigned OpNo);
376 SDValue PromoteIntOp_BUILD_VECTOR(SDNode *
N);
377 SDValue PromoteIntOp_INSERT_VECTOR_ELT(SDNode *
N,
unsigned OpNo);
378 SDValue PromoteIntOp_EXTRACT_VECTOR_ELT(SDNode *
N);
379 SDValue PromoteIntOp_EXTRACT_SUBVECTOR(SDNode *
N);
380 SDValue PromoteIntOp_INSERT_SUBVECTOR(SDNode *
N);
381 SDValue PromoteIntOp_CONCAT_VECTORS(SDNode *
N);
382 SDValue PromoteIntOp_ScalarOp(SDNode *
N);
383 SDValue PromoteIntOp_SELECT(SDNode *
N,
unsigned OpNo);
384 SDValue PromoteIntOp_SELECT_CC(SDNode *
N,
unsigned OpNo);
385 SDValue PromoteIntOp_SETCC(SDNode *
N,
unsigned OpNo);
386 SDValue PromoteIntOp_Shift(SDNode *
N);
387 SDValue PromoteIntOp_FunnelShift(SDNode *
N);
388 SDValue PromoteIntOp_SIGN_EXTEND(SDNode *
N);
389 SDValue PromoteIntOp_VP_SIGN_EXTEND(SDNode *
N);
390 SDValue PromoteIntOp_SINT_TO_FP(SDNode *
N);
391 SDValue PromoteIntOp_STRICT_SINT_TO_FP(SDNode *
N);
392 SDValue PromoteIntOp_STORE(StoreSDNode *
N,
unsigned OpNo);
393 SDValue PromoteIntOp_TRUNCATE(SDNode *
N);
394 SDValue PromoteIntOp_UINT_TO_FP(SDNode *
N);
395 SDValue PromoteIntOp_STRICT_UINT_TO_FP(SDNode *
N);
396 SDValue PromoteIntOp_ZERO_EXTEND(SDNode *
N);
397 SDValue PromoteIntOp_VP_ZERO_EXTEND(SDNode *
N);
398 SDValue PromoteIntOp_MSTORE(MaskedStoreSDNode *
N,
unsigned OpNo);
399 SDValue PromoteIntOp_MLOAD(MaskedLoadSDNode *
N,
unsigned OpNo);
400 SDValue PromoteIntOp_MSCATTER(MaskedScatterSDNode *
N,
unsigned OpNo);
401 SDValue PromoteIntOp_MGATHER(MaskedGatherSDNode *
N,
unsigned OpNo);
402 SDValue PromoteIntOp_ADDSUBO_CARRY(SDNode *
N,
unsigned OpNo);
403 SDValue PromoteIntOp_FRAMERETURNADDR(SDNode *
N);
404 SDValue PromoteIntOp_FIX(SDNode *
N);
405 SDValue PromoteIntOp_ExpOp(SDNode *
N);
406 SDValue PromoteIntOp_VECREDUCE(SDNode *
N);
407 SDValue PromoteIntOp_VP_REDUCE(SDNode *
N,
unsigned OpNo);
408 SDValue PromoteIntOp_SET_ROUNDING(SDNode *
N);
409 SDValue PromoteIntOp_STACKMAP(SDNode *
N,
unsigned OpNo);
410 SDValue PromoteIntOp_PATCHPOINT(SDNode *
N,
unsigned OpNo);
411 SDValue PromoteIntOp_VP_STRIDED(SDNode *
N,
unsigned OpNo);
413 void PromoteSetCCOperands(SDValue &
LHS,SDValue &
RHS, ISD::CondCode Code);
425 void GetExpandedInteger(SDValue Op, SDValue &Lo, SDValue &Hi);
426 void SetExpandedInteger(SDValue Op, SDValue Lo, SDValue Hi);
429 void ExpandIntegerResult(SDNode *
N,
unsigned ResNo);
430 void ExpandIntRes_ANY_EXTEND (SDNode *
N, SDValue &Lo, SDValue &Hi);
431 void ExpandIntRes_AssertSext (SDNode *
N, SDValue &Lo, SDValue &Hi);
432 void ExpandIntRes_AssertZext (SDNode *
N, SDValue &Lo, SDValue &Hi);
433 void ExpandIntRes_Constant (SDNode *
N, SDValue &Lo, SDValue &Hi);
434 void ExpandIntRes_ABS (SDNode *
N, SDValue &Lo, SDValue &Hi);
435 void ExpandIntRes_CTLZ (SDNode *
N, SDValue &Lo, SDValue &Hi);
436 void ExpandIntRes_CTPOP (SDNode *
N, SDValue &Lo, SDValue &Hi);
437 void ExpandIntRes_CTTZ (SDNode *
N, SDValue &Lo, SDValue &Hi);
438 void ExpandIntRes_LOAD (LoadSDNode *
N, SDValue &Lo, SDValue &Hi);
439 void ExpandIntRes_READCYCLECOUNTER (SDNode *
N, SDValue &Lo, SDValue &Hi);
440 void ExpandIntRes_SIGN_EXTEND (SDNode *
N, SDValue &Lo, SDValue &Hi);
441 void ExpandIntRes_SIGN_EXTEND_INREG (SDNode *
N, SDValue &Lo, SDValue &Hi);
442 void ExpandIntRes_TRUNCATE (SDNode *
N, SDValue &Lo, SDValue &Hi);
443 void ExpandIntRes_ZERO_EXTEND (SDNode *
N, SDValue &Lo, SDValue &Hi);
444 void ExpandIntRes_GET_ROUNDING (SDNode *
N, SDValue &Lo, SDValue &Hi);
445 void ExpandIntRes_FP_TO_XINT (SDNode *
N, SDValue &Lo, SDValue &Hi);
446 void ExpandIntRes_FP_TO_XINT_SAT (SDNode *
N, SDValue &Lo, SDValue &Hi);
447 void ExpandIntRes_XROUND_XRINT (SDNode *
N, SDValue &Lo, SDValue &Hi);
449 void ExpandIntRes_Logical (SDNode *
N, SDValue &Lo, SDValue &Hi);
450 void ExpandIntRes_ADDSUB (SDNode *
N, SDValue &Lo, SDValue &Hi);
451 void ExpandIntRes_ADDSUBC (SDNode *
N, SDValue &Lo, SDValue &Hi);
452 void ExpandIntRes_ADDSUBE (SDNode *
N, SDValue &Lo, SDValue &Hi);
453 void ExpandIntRes_UADDSUBO_CARRY (SDNode *
N, SDValue &Lo, SDValue &Hi);
454 void ExpandIntRes_SADDSUBO_CARRY (SDNode *
N, SDValue &Lo, SDValue &Hi);
455 void ExpandIntRes_BITREVERSE (SDNode *
N, SDValue &Lo, SDValue &Hi);
456 void ExpandIntRes_BSWAP (SDNode *
N, SDValue &Lo, SDValue &Hi);
457 void ExpandIntRes_PARITY (SDNode *
N, SDValue &Lo, SDValue &Hi);
458 void ExpandIntRes_MUL (SDNode *
N, SDValue &Lo, SDValue &Hi);
459 void ExpandIntRes_SDIV (SDNode *
N, SDValue &Lo, SDValue &Hi);
460 void ExpandIntRes_SREM (SDNode *
N, SDValue &Lo, SDValue &Hi);
461 void ExpandIntRes_UDIV (SDNode *
N, SDValue &Lo, SDValue &Hi);
462 void ExpandIntRes_UREM (SDNode *
N, SDValue &Lo, SDValue &Hi);
463 void ExpandIntRes_ShiftThroughStack (SDNode *
N, SDValue &Lo, SDValue &Hi);
464 void ExpandIntRes_Shift (SDNode *
N, SDValue &Lo, SDValue &Hi);
466 void ExpandIntRes_MINMAX (SDNode *
N, SDValue &Lo, SDValue &Hi);
468 void ExpandIntRes_SADDSUBO (SDNode *
N, SDValue &Lo, SDValue &Hi);
469 void ExpandIntRes_UADDSUBO (SDNode *
N, SDValue &Lo, SDValue &Hi);
470 void ExpandIntRes_XMULO (SDNode *
N, SDValue &Lo, SDValue &Hi);
471 void ExpandIntRes_ADDSUBSAT (SDNode *
N, SDValue &Lo, SDValue &Hi);
472 void ExpandIntRes_SHLSAT (SDNode *
N, SDValue &Lo, SDValue &Hi);
473 void ExpandIntRes_MULFIX (SDNode *
N, SDValue &Lo, SDValue &Hi);
474 void ExpandIntRes_DIVFIX (SDNode *
N, SDValue &Lo, SDValue &Hi);
476 void ExpandIntRes_ATOMIC_LOAD (SDNode *
N, SDValue &Lo, SDValue &Hi);
477 void ExpandIntRes_VECREDUCE (SDNode *
N, SDValue &Lo, SDValue &Hi);
479 void ExpandIntRes_Rotate (SDNode *
N, SDValue &Lo, SDValue &Hi);
480 void ExpandIntRes_FunnelShift (SDNode *
N, SDValue &Lo, SDValue &Hi);
482 void ExpandIntRes_VSCALE (SDNode *
N, SDValue &Lo, SDValue &Hi);
484 void ExpandShiftByConstant(SDNode *
N,
const APInt &Amt,
485 SDValue &Lo, SDValue &Hi);
486 bool ExpandShiftWithKnownAmountBit(SDNode *
N, SDValue &Lo, SDValue &Hi);
487 bool ExpandShiftWithUnknownAmountBit(SDNode *
N, SDValue &Lo, SDValue &Hi);
490 bool ExpandIntegerOperand(SDNode *
N,
unsigned OpNo);
491 SDValue ExpandIntOp_BR_CC(SDNode *
N);
492 SDValue ExpandIntOp_SELECT_CC(SDNode *
N);
493 SDValue ExpandIntOp_SETCC(SDNode *
N);
494 SDValue ExpandIntOp_SETCCCARRY(SDNode *
N);
495 SDValue ExpandIntOp_Shift(SDNode *
N);
496 SDValue ExpandIntOp_STORE(StoreSDNode *
N,
unsigned OpNo);
497 SDValue ExpandIntOp_TRUNCATE(SDNode *
N);
498 SDValue ExpandIntOp_XINT_TO_FP(SDNode *
N);
499 SDValue ExpandIntOp_RETURNADDR(SDNode *
N);
500 SDValue ExpandIntOp_ATOMIC_STORE(SDNode *
N);
501 SDValue ExpandIntOp_SPLAT_VECTOR(SDNode *
N);
502 SDValue ExpandIntOp_STACKMAP(SDNode *
N,
unsigned OpNo);
503 SDValue ExpandIntOp_PATCHPOINT(SDNode *
N,
unsigned OpNo);
504 SDValue ExpandIntOp_VP_STRIDED(SDNode *
N,
unsigned OpNo);
506 void IntegerExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
507 ISD::CondCode &CCCode,
const SDLoc &dl);
518 SDValue GetSoftenedFloat(SDValue Op) {
519 TableId
Id = getTableId(Op);
520 auto Iter = SoftenedFloats.find(Id);
521 if (Iter == SoftenedFloats.end()) {
522 assert(isSimpleLegalType(
Op.getValueType()) &&
523 "Operand wasn't converted to integer?");
526 SDValue SoftenedOp = getSDValue(Iter->second);
527 assert(SoftenedOp.getNode() &&
"Unconverted op in SoftenedFloats?");
530 void SetSoftenedFloat(SDValue Op, SDValue Result);
533 void SoftenFloatResult(SDNode *
N,
unsigned ResNo);
534 SDValue SoftenFloatRes_Unary(SDNode *
N, RTLIB::Libcall LC);
535 SDValue SoftenFloatRes_Binary(SDNode *
N, RTLIB::Libcall LC);
536 SDValue SoftenFloatRes_MERGE_VALUES(SDNode *
N,
unsigned ResNo);
537 SDValue SoftenFloatRes_ARITH_FENCE(SDNode *
N);
538 SDValue SoftenFloatRes_BITCAST(SDNode *
N);
539 SDValue SoftenFloatRes_BUILD_PAIR(SDNode *
N);
540 SDValue SoftenFloatRes_ConstantFP(SDNode *
N);
541 SDValue SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *
N,
unsigned ResNo);
542 SDValue SoftenFloatRes_FABS(SDNode *
N);
543 SDValue SoftenFloatRes_FMINNUM(SDNode *
N);
544 SDValue SoftenFloatRes_FMAXNUM(SDNode *
N);
545 SDValue SoftenFloatRes_FADD(SDNode *
N);
546 SDValue SoftenFloatRes_FCBRT(SDNode *
N);
547 SDValue SoftenFloatRes_FCEIL(SDNode *
N);
548 SDValue SoftenFloatRes_FCOPYSIGN(SDNode *
N);
549 SDValue SoftenFloatRes_FCOS(SDNode *
N);
550 SDValue SoftenFloatRes_FDIV(SDNode *
N);
551 SDValue SoftenFloatRes_FEXP(SDNode *
N);
552 SDValue SoftenFloatRes_FEXP2(SDNode *
N);
553 SDValue SoftenFloatRes_FEXP10(SDNode *
N);
554 SDValue SoftenFloatRes_FFLOOR(SDNode *
N);
555 SDValue SoftenFloatRes_FLOG(SDNode *
N);
556 SDValue SoftenFloatRes_FLOG2(SDNode *
N);
557 SDValue SoftenFloatRes_FLOG10(SDNode *
N);
558 SDValue SoftenFloatRes_FMA(SDNode *
N);
559 SDValue SoftenFloatRes_FMUL(SDNode *
N);
560 SDValue SoftenFloatRes_FNEARBYINT(SDNode *
N);
561 SDValue SoftenFloatRes_FNEG(SDNode *
N);
562 SDValue SoftenFloatRes_FP_EXTEND(SDNode *
N);
563 SDValue SoftenFloatRes_FP16_TO_FP(SDNode *
N);
564 SDValue SoftenFloatRes_BF16_TO_FP(SDNode *
N);
565 SDValue SoftenFloatRes_FP_ROUND(SDNode *
N);
566 SDValue SoftenFloatRes_FPOW(SDNode *
N);
567 SDValue SoftenFloatRes_ExpOp(SDNode *
N);
568 SDValue SoftenFloatRes_FFREXP(SDNode *
N);
569 SDValue SoftenFloatRes_FREEZE(SDNode *
N);
570 SDValue SoftenFloatRes_FREM(SDNode *
N);
571 SDValue SoftenFloatRes_FRINT(SDNode *
N);
572 SDValue SoftenFloatRes_FROUND(SDNode *
N);
573 SDValue SoftenFloatRes_FROUNDEVEN(SDNode *
N);
574 SDValue SoftenFloatRes_FSIN(SDNode *
N);
575 SDValue SoftenFloatRes_FSQRT(SDNode *
N);
576 SDValue SoftenFloatRes_FSUB(SDNode *
N);
577 SDValue SoftenFloatRes_FTRUNC(SDNode *
N);
578 SDValue SoftenFloatRes_LOAD(SDNode *
N);
579 SDValue SoftenFloatRes_SELECT(SDNode *
N);
580 SDValue SoftenFloatRes_SELECT_CC(SDNode *
N);
581 SDValue SoftenFloatRes_UNDEF(SDNode *
N);
582 SDValue SoftenFloatRes_VAARG(SDNode *
N);
583 SDValue SoftenFloatRes_XINT_TO_FP(SDNode *
N);
584 SDValue SoftenFloatRes_VECREDUCE(SDNode *
N);
585 SDValue SoftenFloatRes_VECREDUCE_SEQ(SDNode *
N);
588 bool SoftenFloatOperand(SDNode *
N,
unsigned OpNo);
589 SDValue SoftenFloatOp_Unary(SDNode *
N, RTLIB::Libcall LC);
590 SDValue SoftenFloatOp_BITCAST(SDNode *
N);
591 SDValue SoftenFloatOp_BR_CC(SDNode *
N);
592 SDValue SoftenFloatOp_FP_ROUND(SDNode *
N);
593 SDValue SoftenFloatOp_FP_TO_XINT(SDNode *
N);
594 SDValue SoftenFloatOp_FP_TO_XINT_SAT(SDNode *
N);
595 SDValue SoftenFloatOp_LROUND(SDNode *
N);
596 SDValue SoftenFloatOp_LLROUND(SDNode *
N);
597 SDValue SoftenFloatOp_LRINT(SDNode *
N);
598 SDValue SoftenFloatOp_LLRINT(SDNode *
N);
599 SDValue SoftenFloatOp_SELECT_CC(SDNode *
N);
600 SDValue SoftenFloatOp_SETCC(SDNode *
N);
601 SDValue SoftenFloatOp_STORE(SDNode *
N,
unsigned OpNo);
602 SDValue SoftenFloatOp_FCOPYSIGN(SDNode *
N);
614 void GetExpandedFloat(SDValue Op, SDValue &Lo, SDValue &Hi);
615 void SetExpandedFloat(SDValue Op, SDValue Lo, SDValue Hi);
618 void ExpandFloatResult(SDNode *
N,
unsigned ResNo);
619 void ExpandFloatRes_ConstantFP(SDNode *
N, SDValue &Lo, SDValue &Hi);
620 void ExpandFloatRes_Unary(SDNode *
N, RTLIB::Libcall LC,
621 SDValue &Lo, SDValue &Hi);
622 void ExpandFloatRes_Binary(SDNode *
N, RTLIB::Libcall LC,
623 SDValue &Lo, SDValue &Hi);
624 void ExpandFloatRes_FABS (SDNode *
N, SDValue &Lo, SDValue &Hi);
625 void ExpandFloatRes_FMINNUM (SDNode *
N, SDValue &Lo, SDValue &Hi);
626 void ExpandFloatRes_FMAXNUM (SDNode *
N, SDValue &Lo, SDValue &Hi);
627 void ExpandFloatRes_FADD (SDNode *
N, SDValue &Lo, SDValue &Hi);
628 void ExpandFloatRes_FCBRT (SDNode *
N, SDValue &Lo, SDValue &Hi);
629 void ExpandFloatRes_FCEIL (SDNode *
N, SDValue &Lo, SDValue &Hi);
630 void ExpandFloatRes_FCOPYSIGN (SDNode *
N, SDValue &Lo, SDValue &Hi);
631 void ExpandFloatRes_FCOS (SDNode *
N, SDValue &Lo, SDValue &Hi);
632 void ExpandFloatRes_FDIV (SDNode *
N, SDValue &Lo, SDValue &Hi);
633 void ExpandFloatRes_FEXP (SDNode *
N, SDValue &Lo, SDValue &Hi);
634 void ExpandFloatRes_FEXP2 (SDNode *
N, SDValue &Lo, SDValue &Hi);
635 void ExpandFloatRes_FEXP10 (SDNode *
N, SDValue &Lo, SDValue &Hi);
636 void ExpandFloatRes_FFLOOR (SDNode *
N, SDValue &Lo, SDValue &Hi);
637 void ExpandFloatRes_FLOG (SDNode *
N, SDValue &Lo, SDValue &Hi);
638 void ExpandFloatRes_FLOG2 (SDNode *
N, SDValue &Lo, SDValue &Hi);
639 void ExpandFloatRes_FLOG10 (SDNode *
N, SDValue &Lo, SDValue &Hi);
640 void ExpandFloatRes_FMA (SDNode *
N, SDValue &Lo, SDValue &Hi);
641 void ExpandFloatRes_FMUL (SDNode *
N, SDValue &Lo, SDValue &Hi);
642 void ExpandFloatRes_FNEARBYINT(SDNode *
N, SDValue &Lo, SDValue &Hi);
643 void ExpandFloatRes_FNEG (SDNode *
N, SDValue &Lo, SDValue &Hi);
644 void ExpandFloatRes_FP_EXTEND (SDNode *
N, SDValue &Lo, SDValue &Hi);
645 void ExpandFloatRes_FPOW (SDNode *
N, SDValue &Lo, SDValue &Hi);
646 void ExpandFloatRes_FPOWI (SDNode *
N, SDValue &Lo, SDValue &Hi);
647 void ExpandFloatRes_FLDEXP (SDNode *
N, SDValue &Lo, SDValue &Hi);
648 void ExpandFloatRes_FREEZE (SDNode *
N, SDValue &Lo, SDValue &Hi);
649 void ExpandFloatRes_FREM (SDNode *
N, SDValue &Lo, SDValue &Hi);
650 void ExpandFloatRes_FRINT (SDNode *
N, SDValue &Lo, SDValue &Hi);
651 void ExpandFloatRes_FROUND (SDNode *
N, SDValue &Lo, SDValue &Hi);
652 void ExpandFloatRes_FROUNDEVEN(SDNode *
N, SDValue &Lo, SDValue &Hi);
653 void ExpandFloatRes_FSIN (SDNode *
N, SDValue &Lo, SDValue &Hi);
654 void ExpandFloatRes_FSQRT (SDNode *
N, SDValue &Lo, SDValue &Hi);
655 void ExpandFloatRes_FSUB (SDNode *
N, SDValue &Lo, SDValue &Hi);
656 void ExpandFloatRes_FTRUNC (SDNode *
N, SDValue &Lo, SDValue &Hi);
657 void ExpandFloatRes_LOAD (SDNode *
N, SDValue &Lo, SDValue &Hi);
658 void ExpandFloatRes_XINT_TO_FP(SDNode *
N, SDValue &Lo, SDValue &Hi);
661 bool ExpandFloatOperand(SDNode *
N,
unsigned OpNo);
662 SDValue ExpandFloatOp_BR_CC(SDNode *
N);
663 SDValue ExpandFloatOp_FCOPYSIGN(SDNode *
N);
664 SDValue ExpandFloatOp_FP_ROUND(SDNode *
N);
665 SDValue ExpandFloatOp_FP_TO_XINT(SDNode *
N);
666 SDValue ExpandFloatOp_LROUND(SDNode *
N);
667 SDValue ExpandFloatOp_LLROUND(SDNode *
N);
668 SDValue ExpandFloatOp_LRINT(SDNode *
N);
669 SDValue ExpandFloatOp_LLRINT(SDNode *
N);
670 SDValue ExpandFloatOp_SELECT_CC(SDNode *
N);
671 SDValue ExpandFloatOp_SETCC(SDNode *
N);
672 SDValue ExpandFloatOp_STORE(SDNode *
N,
unsigned OpNo);
674 void FloatExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
675 ISD::CondCode &CCCode,
const SDLoc &dl,
676 SDValue &Chain,
bool IsSignaling =
false);
682 SDValue GetPromotedFloat(SDValue Op) {
683 TableId &PromotedId = PromotedFloats[getTableId(Op)];
684 SDValue PromotedOp = getSDValue(PromotedId);
685 assert(PromotedOp.getNode() &&
"Operand wasn't promoted?");
688 void SetPromotedFloat(SDValue Op, SDValue Result);
690 void PromoteFloatResult(SDNode *
N,
unsigned ResNo);
691 SDValue PromoteFloatRes_BITCAST(SDNode *
N);
692 SDValue PromoteFloatRes_BinOp(SDNode *
N);
693 SDValue PromoteFloatRes_ConstantFP(SDNode *
N);
694 SDValue PromoteFloatRes_EXTRACT_VECTOR_ELT(SDNode *
N);
695 SDValue PromoteFloatRes_FCOPYSIGN(SDNode *
N);
696 SDValue PromoteFloatRes_FMAD(SDNode *
N);
697 SDValue PromoteFloatRes_ExpOp(SDNode *
N);
698 SDValue PromoteFloatRes_FFREXP(SDNode *
N);
699 SDValue PromoteFloatRes_FP_ROUND(SDNode *
N);
700 SDValue PromoteFloatRes_LOAD(SDNode *
N);
701 SDValue PromoteFloatRes_SELECT(SDNode *
N);
702 SDValue PromoteFloatRes_SELECT_CC(SDNode *
N);
703 SDValue PromoteFloatRes_UnaryOp(SDNode *
N);
704 SDValue PromoteFloatRes_UNDEF(SDNode *
N);
705 SDValue BitcastToInt_ATOMIC_SWAP(SDNode *
N);
706 SDValue PromoteFloatRes_XINT_TO_FP(SDNode *
N);
707 SDValue PromoteFloatRes_VECREDUCE(SDNode *
N);
708 SDValue PromoteFloatRes_VECREDUCE_SEQ(SDNode *
N);
710 bool PromoteFloatOperand(SDNode *
N,
unsigned OpNo);
711 SDValue PromoteFloatOp_BITCAST(SDNode *
N,
unsigned OpNo);
712 SDValue PromoteFloatOp_FCOPYSIGN(SDNode *
N,
unsigned OpNo);
713 SDValue PromoteFloatOp_FP_EXTEND(SDNode *
N,
unsigned OpNo);
714 SDValue PromoteFloatOp_FP_TO_XINT(SDNode *
N,
unsigned OpNo);
715 SDValue PromoteFloatOp_FP_TO_XINT_SAT(SDNode *
N,
unsigned OpNo);
716 SDValue PromoteFloatOp_STORE(SDNode *
N,
unsigned OpNo);
717 SDValue PromoteFloatOp_SELECT_CC(SDNode *
N,
unsigned OpNo);
718 SDValue PromoteFloatOp_SETCC(SDNode *
N,
unsigned OpNo);
724 SDValue GetSoftPromotedHalf(SDValue Op) {
725 TableId &PromotedId = SoftPromotedHalfs[getTableId(Op)];
726 SDValue PromotedOp = getSDValue(PromotedId);
727 assert(PromotedOp.getNode() &&
"Operand wasn't promoted?");
730 void SetSoftPromotedHalf(SDValue Op, SDValue Result);
732 void SoftPromoteHalfResult(SDNode *
N,
unsigned ResNo);
733 SDValue SoftPromoteHalfRes_BinOp(SDNode *
N);
734 SDValue SoftPromoteHalfRes_BITCAST(SDNode *
N);
735 SDValue SoftPromoteHalfRes_ConstantFP(SDNode *
N);
736 SDValue SoftPromoteHalfRes_EXTRACT_VECTOR_ELT(SDNode *
N);
737 SDValue SoftPromoteHalfRes_FCOPYSIGN(SDNode *
N);
738 SDValue SoftPromoteHalfRes_FMAD(SDNode *
N);
739 SDValue SoftPromoteHalfRes_ExpOp(SDNode *
N);
740 SDValue SoftPromoteHalfRes_FP_ROUND(SDNode *
N);
741 SDValue SoftPromoteHalfRes_LOAD(SDNode *
N);
742 SDValue SoftPromoteHalfRes_SELECT(SDNode *
N);
743 SDValue SoftPromoteHalfRes_SELECT_CC(SDNode *
N);
744 SDValue SoftPromoteHalfRes_UnaryOp(SDNode *
N);
745 SDValue SoftPromoteHalfRes_XINT_TO_FP(SDNode *
N);
746 SDValue SoftPromoteHalfRes_UNDEF(SDNode *
N);
747 SDValue SoftPromoteHalfRes_VECREDUCE(SDNode *
N);
748 SDValue SoftPromoteHalfRes_VECREDUCE_SEQ(SDNode *
N);
750 bool SoftPromoteHalfOperand(SDNode *
N,
unsigned OpNo);
751 SDValue SoftPromoteHalfOp_BITCAST(SDNode *
N);
752 SDValue SoftPromoteHalfOp_FCOPYSIGN(SDNode *
N,
unsigned OpNo);
753 SDValue SoftPromoteHalfOp_FP_EXTEND(SDNode *
N);
754 SDValue SoftPromoteHalfOp_FP_TO_XINT(SDNode *
N);
755 SDValue SoftPromoteHalfOp_FP_TO_XINT_SAT(SDNode *
N);
756 SDValue SoftPromoteHalfOp_SETCC(SDNode *
N);
757 SDValue SoftPromoteHalfOp_SELECT_CC(SDNode *
N,
unsigned OpNo);
758 SDValue SoftPromoteHalfOp_STORE(SDNode *
N,
unsigned OpNo);
759 SDValue SoftPromoteHalfOp_STACKMAP(SDNode *
N,
unsigned OpNo);
760 SDValue SoftPromoteHalfOp_PATCHPOINT(SDNode *
N,
unsigned OpNo);
769 SDValue GetScalarizedVector(SDValue Op) {
770 TableId &ScalarizedId = ScalarizedVectors[getTableId(Op)];
771 SDValue ScalarizedOp = getSDValue(ScalarizedId);
772 assert(ScalarizedOp.getNode() &&
"Operand wasn't scalarized?");
775 void SetScalarizedVector(SDValue Op, SDValue Result);
778 void ScalarizeVectorResult(SDNode *
N,
unsigned ResNo);
779 SDValue ScalarizeVecRes_MERGE_VALUES(SDNode *
N,
unsigned ResNo);
780 SDValue ScalarizeVecRes_BinOp(SDNode *
N);
781 SDValue ScalarizeVecRes_TernaryOp(SDNode *
N);
782 SDValue ScalarizeVecRes_UnaryOp(SDNode *
N);
783 SDValue ScalarizeVecRes_StrictFPOp(SDNode *
N);
784 SDValue ScalarizeVecRes_OverflowOp(SDNode *
N,
unsigned ResNo);
785 SDValue ScalarizeVecRes_InregOp(SDNode *
N);
786 SDValue ScalarizeVecRes_VecInregOp(SDNode *
N);
788 SDValue ScalarizeVecRes_BITCAST(SDNode *
N);
789 SDValue ScalarizeVecRes_BUILD_VECTOR(SDNode *
N);
790 SDValue ScalarizeVecRes_EXTRACT_SUBVECTOR(SDNode *
N);
791 SDValue ScalarizeVecRes_FP_ROUND(SDNode *
N);
792 SDValue ScalarizeVecRes_ExpOp(SDNode *
N);
793 SDValue ScalarizeVecRes_INSERT_VECTOR_ELT(SDNode *
N);
794 SDValue ScalarizeVecRes_LOAD(LoadSDNode *
N);
795 SDValue ScalarizeVecRes_SCALAR_TO_VECTOR(SDNode *
N);
796 SDValue ScalarizeVecRes_VSELECT(SDNode *
N);
797 SDValue ScalarizeVecRes_SELECT(SDNode *
N);
798 SDValue ScalarizeVecRes_SELECT_CC(SDNode *
N);
799 SDValue ScalarizeVecRes_SETCC(SDNode *
N);
800 SDValue ScalarizeVecRes_UNDEF(SDNode *
N);
801 SDValue ScalarizeVecRes_VECTOR_SHUFFLE(SDNode *
N);
802 SDValue ScalarizeVecRes_FP_TO_XINT_SAT(SDNode *
N);
803 SDValue ScalarizeVecRes_IS_FPCLASS(SDNode *
N);
805 SDValue ScalarizeVecRes_FIX(SDNode *
N);
806 SDValue ScalarizeVecRes_FFREXP(SDNode *
N,
unsigned ResNo);
809 bool ScalarizeVectorOperand(SDNode *
N,
unsigned OpNo);
810 SDValue ScalarizeVecOp_BITCAST(SDNode *
N);
811 SDValue ScalarizeVecOp_UnaryOp(SDNode *
N);
812 SDValue ScalarizeVecOp_UnaryOp_StrictFP(SDNode *
N);
813 SDValue ScalarizeVecOp_CONCAT_VECTORS(SDNode *
N);
814 SDValue ScalarizeVecOp_EXTRACT_VECTOR_ELT(SDNode *
N);
815 SDValue ScalarizeVecOp_VSELECT(SDNode *
N);
816 SDValue ScalarizeVecOp_VSETCC(SDNode *
N);
817 SDValue ScalarizeVecOp_STORE(StoreSDNode *
N,
unsigned OpNo);
818 SDValue ScalarizeVecOp_FP_ROUND(SDNode *
N,
unsigned OpNo);
819 SDValue ScalarizeVecOp_STRICT_FP_ROUND(SDNode *
N,
unsigned OpNo);
820 SDValue ScalarizeVecOp_FP_EXTEND(SDNode *
N);
821 SDValue ScalarizeVecOp_STRICT_FP_EXTEND(SDNode *
N);
822 SDValue ScalarizeVecOp_VECREDUCE(SDNode *
N);
823 SDValue ScalarizeVecOp_VECREDUCE_SEQ(SDNode *
N);
836 void GetSplitVector(SDValue Op, SDValue &Lo, SDValue &Hi);
837 void SetSplitVector(SDValue Op, SDValue Lo, SDValue Hi);
840 std::pair<SDValue, SDValue> SplitMask(SDValue Mask);
843 std::pair<SDValue, SDValue> SplitMask(SDValue Mask,
const SDLoc &
DL);
847 void IncrementPointer(MemSDNode *
N, EVT MemVT, MachinePointerInfo &MPI,
851 void SplitVectorResult(SDNode *
N,
unsigned ResNo);
852 void SplitVecRes_BinOp(SDNode *
N, SDValue &Lo, SDValue &Hi);
853 void SplitVecRes_TernaryOp(SDNode *
N, SDValue &Lo, SDValue &Hi);
854 void SplitVecRes_UnaryOp(SDNode *
N, SDValue &Lo, SDValue &Hi);
855 void SplitVecRes_FFREXP(SDNode *
N,
unsigned ResNo, SDValue &Lo, SDValue &Hi);
856 void SplitVecRes_ExtendOp(SDNode *
N, SDValue &Lo, SDValue &Hi);
857 void SplitVecRes_InregOp(SDNode *
N, SDValue &Lo, SDValue &Hi);
858 void SplitVecRes_ExtVecInRegOp(SDNode *
N, SDValue &Lo, SDValue &Hi);
859 void SplitVecRes_StrictFPOp(SDNode *
N, SDValue &Lo, SDValue &Hi);
860 void SplitVecRes_OverflowOp(SDNode *
N,
unsigned ResNo,
861 SDValue &Lo, SDValue &Hi);
863 void SplitVecRes_FIX(SDNode *
N, SDValue &Lo, SDValue &Hi);
865 void SplitVecRes_BITCAST(SDNode *
N, SDValue &Lo, SDValue &Hi);
866 void SplitVecRes_BUILD_VECTOR(SDNode *
N, SDValue &Lo, SDValue &Hi);
867 void SplitVecRes_CONCAT_VECTORS(SDNode *
N, SDValue &Lo, SDValue &Hi);
868 void SplitVecRes_EXTRACT_SUBVECTOR(SDNode *
N, SDValue &Lo, SDValue &Hi);
869 void SplitVecRes_INSERT_SUBVECTOR(SDNode *
N, SDValue &Lo, SDValue &Hi);
870 void SplitVecRes_FPOp_MultiType(SDNode *
N, SDValue &Lo, SDValue &Hi);
871 void SplitVecRes_IS_FPCLASS(SDNode *
N, SDValue &Lo, SDValue &Hi);
872 void SplitVecRes_INSERT_VECTOR_ELT(SDNode *
N, SDValue &Lo, SDValue &Hi);
873 void SplitVecRes_LOAD(LoadSDNode *LD, SDValue &Lo, SDValue &Hi);
874 void SplitVecRes_VP_LOAD(VPLoadSDNode *LD, SDValue &Lo, SDValue &Hi);
875 void SplitVecRes_VP_STRIDED_LOAD(VPStridedLoadSDNode *SLD, SDValue &Lo,
877 void SplitVecRes_MLOAD(MaskedLoadSDNode *MLD, SDValue &Lo, SDValue &Hi);
878 void SplitVecRes_Gather(MemSDNode *VPGT, SDValue &Lo, SDValue &Hi,
879 bool SplitSETCC =
false);
880 void SplitVecRes_ScalarOp(SDNode *
N, SDValue &Lo, SDValue &Hi);
881 void SplitVecRes_STEP_VECTOR(SDNode *
N, SDValue &Lo, SDValue &Hi);
882 void SplitVecRes_SETCC(SDNode *
N, SDValue &Lo, SDValue &Hi);
883 void SplitVecRes_VECTOR_REVERSE(SDNode *
N, SDValue &Lo, SDValue &Hi);
884 void SplitVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *
N, SDValue &Lo,
886 void SplitVecRes_VECTOR_SPLICE(SDNode *
N, SDValue &Lo, SDValue &Hi);
887 void SplitVecRes_VECTOR_DEINTERLEAVE(SDNode *
N);
888 void SplitVecRes_VECTOR_INTERLEAVE(SDNode *
N);
889 void SplitVecRes_VAARG(SDNode *
N, SDValue &Lo, SDValue &Hi);
890 void SplitVecRes_FP_TO_XINT_SAT(SDNode *
N, SDValue &Lo, SDValue &Hi);
893 bool SplitVectorOperand(SDNode *
N,
unsigned OpNo);
894 SDValue SplitVecOp_VSELECT(SDNode *
N,
unsigned OpNo);
895 SDValue SplitVecOp_VECREDUCE(SDNode *
N,
unsigned OpNo);
896 SDValue SplitVecOp_VECREDUCE_SEQ(SDNode *
N);
897 SDValue SplitVecOp_VP_REDUCE(SDNode *
N,
unsigned OpNo);
898 SDValue SplitVecOp_UnaryOp(SDNode *
N);
899 SDValue SplitVecOp_TruncateHelper(SDNode *
N);
901 SDValue SplitVecOp_BITCAST(SDNode *
N);
902 SDValue SplitVecOp_INSERT_SUBVECTOR(SDNode *
N,
unsigned OpNo);
903 SDValue SplitVecOp_EXTRACT_SUBVECTOR(SDNode *
N);
904 SDValue SplitVecOp_EXTRACT_VECTOR_ELT(SDNode *
N);
905 SDValue SplitVecOp_ExtVecInRegOp(SDNode *
N);
906 SDValue SplitVecOp_STORE(StoreSDNode *
N,
unsigned OpNo);
907 SDValue SplitVecOp_VP_STORE(VPStoreSDNode *
N,
unsigned OpNo);
908 SDValue SplitVecOp_VP_STRIDED_STORE(VPStridedStoreSDNode *
N,
unsigned OpNo);
909 SDValue SplitVecOp_MSTORE(MaskedStoreSDNode *
N,
unsigned OpNo);
910 SDValue SplitVecOp_Scatter(MemSDNode *
N,
unsigned OpNo);
911 SDValue SplitVecOp_Gather(MemSDNode *MGT,
unsigned OpNo);
912 SDValue SplitVecOp_CONCAT_VECTORS(SDNode *
N);
913 SDValue SplitVecOp_VSETCC(SDNode *
N);
914 SDValue SplitVecOp_FP_ROUND(SDNode *
N);
915 SDValue SplitVecOp_FPOpDifferentTypes(SDNode *
N);
916 SDValue SplitVecOp_FP_TO_XINT_SAT(SDNode *
N);
928 SDValue GetWidenedVector(SDValue Op) {
929 TableId &WidenedId = WidenedVectors[getTableId(Op)];
930 SDValue WidenedOp = getSDValue(WidenedId);
931 assert(WidenedOp.getNode() &&
"Operand wasn't widened?");
934 void SetWidenedVector(SDValue Op, SDValue Result);
937 SDValue GetWidenedMask(SDValue Mask, ElementCount EC) {
945 TargetLowering::TypeWidenVector &&
946 "Unable to widen binary VP op");
947 Mask = GetWidenedVector(Mask);
948 assert(
Mask.getValueType().getVectorElementCount() == EC &&
949 "Unable to widen binary VP op");
954 void WidenVectorResult(SDNode *
N,
unsigned ResNo);
955 SDValue WidenVecRes_MERGE_VALUES(SDNode*
N,
unsigned ResNo);
956 SDValue WidenVecRes_AssertZext(SDNode*
N);
957 SDValue WidenVecRes_BITCAST(SDNode*
N);
958 SDValue WidenVecRes_BUILD_VECTOR(SDNode*
N);
959 SDValue WidenVecRes_CONCAT_VECTORS(SDNode*
N);
960 SDValue WidenVecRes_EXTEND_VECTOR_INREG(SDNode*
N);
961 SDValue WidenVecRes_EXTRACT_SUBVECTOR(SDNode*
N);
962 SDValue WidenVecRes_INSERT_SUBVECTOR(SDNode *
N);
963 SDValue WidenVecRes_INSERT_VECTOR_ELT(SDNode*
N);
964 SDValue WidenVecRes_LOAD(SDNode*
N);
965 SDValue WidenVecRes_VP_LOAD(VPLoadSDNode *
N);
966 SDValue WidenVecRes_VP_STRIDED_LOAD(VPStridedLoadSDNode *
N);
967 SDValue WidenVecRes_MLOAD(MaskedLoadSDNode*
N);
968 SDValue WidenVecRes_MGATHER(MaskedGatherSDNode*
N);
969 SDValue WidenVecRes_VP_GATHER(VPGatherSDNode*
N);
970 SDValue WidenVecRes_ScalarOp(SDNode*
N);
971 SDValue WidenVecRes_Select(SDNode *
N);
972 SDValue WidenVSELECTMask(SDNode *
N);
973 SDValue WidenVecRes_SELECT_CC(SDNode*
N);
974 SDValue WidenVecRes_SETCC(SDNode*
N);
975 SDValue WidenVecRes_STRICT_FSETCC(SDNode*
N);
976 SDValue WidenVecRes_UNDEF(SDNode *
N);
977 SDValue WidenVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *
N);
978 SDValue WidenVecRes_VECTOR_REVERSE(SDNode *
N);
980 SDValue WidenVecRes_Ternary(SDNode *
N);
981 SDValue WidenVecRes_Binary(SDNode *
N);
982 SDValue WidenVecRes_BinaryCanTrap(SDNode *
N);
983 SDValue WidenVecRes_BinaryWithExtraScalarOp(SDNode *
N);
984 SDValue WidenVecRes_StrictFP(SDNode *
N);
985 SDValue WidenVecRes_OverflowOp(SDNode *
N,
unsigned ResNo);
986 SDValue WidenVecRes_Convert(SDNode *
N);
987 SDValue WidenVecRes_Convert_StrictFP(SDNode *
N);
988 SDValue WidenVecRes_FP_TO_XINT_SAT(SDNode *
N);
989 SDValue WidenVecRes_FCOPYSIGN(SDNode *
N);
990 SDValue WidenVecRes_IS_FPCLASS(SDNode *
N);
991 SDValue WidenVecRes_ExpOp(SDNode *
N);
992 SDValue WidenVecRes_Unary(SDNode *
N);
993 SDValue WidenVecRes_InregOp(SDNode *
N);
996 bool WidenVectorOperand(SDNode *
N,
unsigned OpNo);
997 SDValue WidenVecOp_BITCAST(SDNode *
N);
998 SDValue WidenVecOp_CONCAT_VECTORS(SDNode *
N);
999 SDValue WidenVecOp_EXTEND(SDNode *
N);
1000 SDValue WidenVecOp_EXTRACT_VECTOR_ELT(SDNode *
N);
1001 SDValue WidenVecOp_INSERT_SUBVECTOR(SDNode *
N);
1002 SDValue WidenVecOp_EXTRACT_SUBVECTOR(SDNode *
N);
1003 SDValue WidenVecOp_STORE(SDNode*
N);
1004 SDValue WidenVecOp_VP_STORE(SDNode *
N,
unsigned OpNo);
1005 SDValue WidenVecOp_VP_STRIDED_STORE(SDNode *
N,
unsigned OpNo);
1006 SDValue WidenVecOp_MSTORE(SDNode*
N,
unsigned OpNo);
1007 SDValue WidenVecOp_MGATHER(SDNode*
N,
unsigned OpNo);
1008 SDValue WidenVecOp_MSCATTER(SDNode*
N,
unsigned OpNo);
1009 SDValue WidenVecOp_VP_SCATTER(SDNode*
N,
unsigned OpNo);
1010 SDValue WidenVecOp_SETCC(SDNode*
N);
1011 SDValue WidenVecOp_STRICT_FSETCC(SDNode*
N);
1012 SDValue WidenVecOp_VSELECT(SDNode *
N);
1014 SDValue WidenVecOp_Convert(SDNode *
N);
1015 SDValue WidenVecOp_FP_TO_XINT_SAT(SDNode *
N);
1016 SDValue WidenVecOp_UnrollVectorOp(SDNode *
N);
1017 SDValue WidenVecOp_IS_FPCLASS(SDNode *
N);
1018 SDValue WidenVecOp_VECREDUCE(SDNode *
N);
1019 SDValue WidenVecOp_VECREDUCE_SEQ(SDNode *
N);
1020 SDValue WidenVecOp_VP_REDUCE(SDNode *
N);
1021 SDValue WidenVecOp_ExpOp(SDNode *
N);
1026 SDValue UnrollVectorOp_StrictFP(SDNode *
N,
unsigned ResNE);
1036 SDValue GenWidenVectorLoads(SmallVectorImpl<SDValue> &LdChain,
1044 SDValue GenWidenVectorExtLoads(SmallVectorImpl<SDValue> &LdChain,
1045 LoadSDNode *LD, ISD::LoadExtType ExtType);
1051 bool GenWidenVectorStores(SmallVectorImpl<SDValue> &StChain, StoreSDNode *ST);
1057 SDValue ModifyToType(SDValue InOp, EVT NVT,
bool FillWithZeroes =
false);
1061 SDValue convertMask(SDValue InMask, EVT MaskVT, EVT ToMaskVT);
1071 void GetSplitOp(SDValue Op, SDValue &Lo, SDValue &Hi) {
1072 if (
Op.getValueType().isVector())
1073 GetSplitVector(Op, Lo, Hi);
1074 else if (
Op.getValueType().isInteger())
1075 GetExpandedInteger(Op, Lo, Hi);
1077 GetExpandedFloat(Op, Lo, Hi);
1082 void GetPairElements(SDValue Pair, SDValue &Lo, SDValue &Hi);
1085 void SplitRes_MERGE_VALUES(SDNode *
N,
unsigned ResNo,
1086 SDValue &Lo, SDValue &Hi);
1087 void SplitVecRes_AssertZext (SDNode *
N, SDValue &Lo, SDValue &Hi);
1088 void SplitRes_ARITH_FENCE (SDNode *
N, SDValue &Lo, SDValue &Hi);
1089 void SplitRes_Select (SDNode *
N, SDValue &Lo, SDValue &Hi);
1090 void SplitRes_SELECT_CC (SDNode *
N, SDValue &Lo, SDValue &Hi);
1091 void SplitRes_UNDEF (SDNode *
N, SDValue &Lo, SDValue &Hi);
1092 void SplitRes_FREEZE (SDNode *
N, SDValue &Lo, SDValue &Hi);
1103 void GetExpandedOp(SDValue Op, SDValue &Lo, SDValue &Hi) {
1104 if (
Op.getValueType().isInteger())
1105 GetExpandedInteger(Op, Lo, Hi);
1107 GetExpandedFloat(Op, Lo, Hi);
1113 void IntegerToVector(SDValue Op,
unsigned NumElements,
1114 SmallVectorImpl<SDValue> &Ops, EVT EltVT);
1117 void ExpandRes_MERGE_VALUES (SDNode *
N,
unsigned ResNo,
1118 SDValue &Lo, SDValue &Hi);
1119 void ExpandRes_BITCAST (SDNode *
N, SDValue &Lo, SDValue &Hi);
1120 void ExpandRes_BUILD_PAIR (SDNode *
N, SDValue &Lo, SDValue &Hi);
1121 void ExpandRes_EXTRACT_ELEMENT (SDNode *
N, SDValue &Lo, SDValue &Hi);
1122 void ExpandRes_EXTRACT_VECTOR_ELT(SDNode *
N, SDValue &Lo, SDValue &Hi);
1123 void ExpandRes_NormalLoad (SDNode *
N, SDValue &Lo, SDValue &Hi);
1124 void ExpandRes_VAARG (SDNode *
N, SDValue &Lo, SDValue &Hi);
1127 SDValue ExpandOp_BITCAST (SDNode *
N);
1128 SDValue ExpandOp_BUILD_VECTOR (SDNode *
N);
1129 SDValue ExpandOp_EXTRACT_ELEMENT (SDNode *
N);
1130 SDValue ExpandOp_INSERT_VECTOR_ELT(SDNode *
N);
1131 SDValue ExpandOp_SCALAR_TO_VECTOR (SDNode *
N);
1132 SDValue ExpandOp_NormalStore (SDNode *
N,
unsigned OpNo);
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
BlockVerifier::State From
#define LLVM_LIBRARY_VISIBILITY
This file defines the DenseMap class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file describes how to lower LLVM code to machine code.
This takes an arbitrary SelectionDAG as input and hacks on it until only value types the target machi...
DAGTypeLegalizer(SelectionDAG &dag)
void NoteDeletion(SDNode *Old, SDNode *New)
SelectionDAG & getDAG() const
NodeIdFlags
This pass uses the NodeId on the SDNodes to hold information about the state of the node.
This class represents an Operation in the Expression.
Represents one node in the SelectionDAG.
unsigned getNumValues() const
Return the number of values defined/returned by this operator.
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation.
SDNode * getNode() const
get the SDNode which holds the desired result
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
SDValue getZeroExtendInReg(SDValue Op, const SDLoc &DL, EVT VT)
Return the expression required to zero extend the Op value assuming it was the smaller SrcTy value.
const DataLayout & getDataLayout() const
SDValue getValueType(EVT)
SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, ArrayRef< SDUse > Ops)
Gets or creates the specified node.
LLVMContext * getContext() const
LegalizeTypeAction getTypeAction(MVT VT) const
LegalizeTypeAction
This enum indicates whether a types are legal for a target, and if not, what action should be used to...
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
This is an optimization pass for GlobalISel generic memory operations.