15#ifndef LLVM_LIB_CODEGEN_SELECTIONDAG_LEGALIZETYPES_H
16#define LLVM_LIB_CODEGEN_SELECTIONDAG_LEGALIZETYPES_H
66 bool isTypeLegal(EVT VT)
const {
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 {
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()) {
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);
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()))
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_DEINTERLEAVE(SDNode *
N);
311 SDValue PromoteIntRes_VECTOR_INTERLEAVE(SDNode *
N);
312 SDValue PromoteIntRes_BUILD_VECTOR(SDNode *
N);
313 SDValue PromoteIntRes_ScalarOp(SDNode *
N);
314 SDValue PromoteIntRes_STEP_VECTOR(SDNode *
N);
315 SDValue PromoteIntRes_EXTEND_VECTOR_INREG(SDNode *
N);
316 SDValue PromoteIntRes_INSERT_VECTOR_ELT(SDNode *
N);
317 SDValue PromoteIntRes_CONCAT_VECTORS(SDNode *
N);
318 SDValue PromoteIntRes_BITCAST(SDNode *
N);
319 SDValue PromoteIntRes_BSWAP(SDNode *
N);
320 SDValue PromoteIntRes_BITREVERSE(SDNode *
N);
321 SDValue PromoteIntRes_BUILD_PAIR(SDNode *
N);
322 SDValue PromoteIntRes_Constant(SDNode *
N);
323 SDValue PromoteIntRes_CTLZ(SDNode *
N);
324 SDValue PromoteIntRes_CTPOP_PARITY(SDNode *
N);
325 SDValue PromoteIntRes_CTTZ(SDNode *
N);
326 SDValue PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *
N);
327 SDValue PromoteIntRes_FP_TO_XINT(SDNode *
N);
328 SDValue PromoteIntRes_FP_TO_XINT_SAT(SDNode *
N);
329 SDValue PromoteIntRes_FP_TO_FP16_BF16(SDNode *
N);
330 SDValue PromoteIntRes_FREEZE(SDNode *
N);
331 SDValue PromoteIntRes_INT_EXTEND(SDNode *
N);
332 SDValue PromoteIntRes_LOAD(LoadSDNode *
N);
333 SDValue PromoteIntRes_MLOAD(MaskedLoadSDNode *
N);
334 SDValue PromoteIntRes_MGATHER(MaskedGatherSDNode *
N);
335 SDValue PromoteIntRes_Overflow(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_ADDSUBCARRY(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_IS_FPCLASS(SDNode *
N);
368 bool PromoteIntegerOperand(SDNode *
N,
unsigned OpNo);
369 SDValue PromoteIntOp_ANY_EXTEND(SDNode *
N);
370 SDValue PromoteIntOp_ATOMIC_STORE(AtomicSDNode *
N);
371 SDValue PromoteIntOp_BITCAST(SDNode *
N);
372 SDValue PromoteIntOp_BUILD_PAIR(SDNode *
N);
373 SDValue PromoteIntOp_BR_CC(SDNode *
N,
unsigned OpNo);
374 SDValue PromoteIntOp_BRCOND(SDNode *
N,
unsigned OpNo);
375 SDValue PromoteIntOp_BUILD_VECTOR(SDNode *
N);
376 SDValue PromoteIntOp_INSERT_VECTOR_ELT(SDNode *
N,
unsigned OpNo);
377 SDValue PromoteIntOp_EXTRACT_VECTOR_ELT(SDNode *
N);
378 SDValue PromoteIntOp_EXTRACT_SUBVECTOR(SDNode *
N);
379 SDValue PromoteIntOp_INSERT_SUBVECTOR(SDNode *
N);
380 SDValue PromoteIntOp_CONCAT_VECTORS(SDNode *
N);
381 SDValue PromoteIntOp_ScalarOp(SDNode *
N);
382 SDValue PromoteIntOp_SELECT(SDNode *
N,
unsigned OpNo);
383 SDValue PromoteIntOp_SELECT_CC(SDNode *
N,
unsigned OpNo);
384 SDValue PromoteIntOp_SETCC(SDNode *
N,
unsigned OpNo);
385 SDValue PromoteIntOp_Shift(SDNode *
N);
386 SDValue PromoteIntOp_FunnelShift(SDNode *
N);
387 SDValue PromoteIntOp_SIGN_EXTEND(SDNode *
N);
388 SDValue PromoteIntOp_SINT_TO_FP(SDNode *
N);
389 SDValue PromoteIntOp_STRICT_SINT_TO_FP(SDNode *
N);
390 SDValue PromoteIntOp_STORE(StoreSDNode *
N,
unsigned OpNo);
391 SDValue PromoteIntOp_TRUNCATE(SDNode *
N);
392 SDValue PromoteIntOp_UINT_TO_FP(SDNode *
N);
393 SDValue PromoteIntOp_STRICT_UINT_TO_FP(SDNode *
N);
394 SDValue PromoteIntOp_ZERO_EXTEND(SDNode *
N);
395 SDValue PromoteIntOp_MSTORE(MaskedStoreSDNode *
N,
unsigned OpNo);
396 SDValue PromoteIntOp_MLOAD(MaskedLoadSDNode *
N,
unsigned OpNo);
397 SDValue PromoteIntOp_MSCATTER(MaskedScatterSDNode *
N,
unsigned OpNo);
398 SDValue PromoteIntOp_MGATHER(MaskedGatherSDNode *
N,
unsigned OpNo);
399 SDValue PromoteIntOp_ADDSUBCARRY(SDNode *
N,
unsigned OpNo);
400 SDValue PromoteIntOp_FRAMERETURNADDR(SDNode *
N);
401 SDValue PromoteIntOp_PREFETCH(SDNode *
N,
unsigned OpNo);
402 SDValue PromoteIntOp_FIX(SDNode *
N);
403 SDValue PromoteIntOp_FPOWI(SDNode *
N);
404 SDValue PromoteIntOp_VECREDUCE(SDNode *
N);
405 SDValue PromoteIntOp_VP_REDUCE(SDNode *
N,
unsigned OpNo);
406 SDValue PromoteIntOp_SET_ROUNDING(SDNode *
N);
407 SDValue PromoteIntOp_STACKMAP(SDNode *
N,
unsigned OpNo);
408 SDValue PromoteIntOp_PATCHPOINT(SDNode *
N,
unsigned OpNo);
409 SDValue PromoteIntOp_VP_STRIDED(SDNode *
N,
unsigned OpNo);
423 void GetExpandedInteger(SDValue Op, SDValue &
Lo, SDValue &
Hi);
424 void SetExpandedInteger(SDValue Op, SDValue
Lo, SDValue
Hi);
427 void ExpandIntegerResult(SDNode *
N,
unsigned ResNo);
428 void ExpandIntRes_ANY_EXTEND (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
429 void ExpandIntRes_AssertSext (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
430 void ExpandIntRes_AssertZext (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
431 void ExpandIntRes_Constant (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
432 void ExpandIntRes_ABS (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
433 void ExpandIntRes_CTLZ (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
434 void ExpandIntRes_CTPOP (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
435 void ExpandIntRes_CTTZ (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
436 void ExpandIntRes_LOAD (LoadSDNode *
N, SDValue &
Lo, SDValue &
Hi);
437 void ExpandIntRes_READCYCLECOUNTER (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
438 void ExpandIntRes_SIGN_EXTEND (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
439 void ExpandIntRes_SIGN_EXTEND_INREG (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
440 void ExpandIntRes_TRUNCATE (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
441 void ExpandIntRes_ZERO_EXTEND (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
442 void ExpandIntRes_GET_ROUNDING (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
443 void ExpandIntRes_FP_TO_SINT (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
444 void ExpandIntRes_FP_TO_UINT (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
445 void ExpandIntRes_FP_TO_XINT_SAT (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
446 void ExpandIntRes_XROUND_XRINT (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
448 void ExpandIntRes_Logical (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
449 void ExpandIntRes_ADDSUB (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
450 void ExpandIntRes_ADDSUBC (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
451 void ExpandIntRes_ADDSUBE (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
452 void ExpandIntRes_ADDSUBCARRY (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
453 void ExpandIntRes_SADDSUBO_CARRY (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
454 void ExpandIntRes_BITREVERSE (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
455 void ExpandIntRes_BSWAP (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
456 void ExpandIntRes_PARITY (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
457 void ExpandIntRes_MUL (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
458 void ExpandIntRes_SDIV (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
459 void ExpandIntRes_SREM (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
460 void ExpandIntRes_UDIV (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
461 void ExpandIntRes_UREM (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
462 void ExpandIntRes_ShiftThroughStack (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
463 void ExpandIntRes_Shift (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
465 void ExpandIntRes_MINMAX (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
467 void ExpandIntRes_SADDSUBO (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
468 void ExpandIntRes_UADDSUBO (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
469 void ExpandIntRes_XMULO (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
470 void ExpandIntRes_ADDSUBSAT (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
471 void ExpandIntRes_SHLSAT (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
472 void ExpandIntRes_MULFIX (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
473 void ExpandIntRes_DIVFIX (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
475 void ExpandIntRes_ATOMIC_LOAD (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
476 void ExpandIntRes_VECREDUCE (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
478 void ExpandIntRes_Rotate (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
479 void ExpandIntRes_FunnelShift (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
481 void ExpandIntRes_VSCALE (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
483 void ExpandShiftByConstant(SDNode *
N,
const APInt &Amt,
484 SDValue &
Lo, SDValue &
Hi);
485 bool ExpandShiftWithKnownAmountBit(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
486 bool ExpandShiftWithUnknownAmountBit(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
489 bool ExpandIntegerOperand(SDNode *
N,
unsigned OpNo);
490 SDValue ExpandIntOp_BR_CC(SDNode *
N);
491 SDValue ExpandIntOp_SELECT_CC(SDNode *
N);
492 SDValue ExpandIntOp_SETCC(SDNode *
N);
493 SDValue ExpandIntOp_SETCCCARRY(SDNode *
N);
494 SDValue ExpandIntOp_Shift(SDNode *
N);
495 SDValue ExpandIntOp_SINT_TO_FP(SDNode *
N);
496 SDValue ExpandIntOp_STORE(StoreSDNode *
N,
unsigned OpNo);
497 SDValue ExpandIntOp_TRUNCATE(SDNode *
N);
498 SDValue ExpandIntOp_UINT_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,
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);
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_FFLOOR(SDNode *
N);
554 SDValue SoftenFloatRes_FLOG(SDNode *
N);
555 SDValue SoftenFloatRes_FLOG2(SDNode *
N);
556 SDValue SoftenFloatRes_FLOG10(SDNode *
N);
557 SDValue SoftenFloatRes_FMA(SDNode *
N);
558 SDValue SoftenFloatRes_FMUL(SDNode *
N);
559 SDValue SoftenFloatRes_FNEARBYINT(SDNode *
N);
560 SDValue SoftenFloatRes_FNEG(SDNode *
N);
561 SDValue SoftenFloatRes_FP_EXTEND(SDNode *
N);
562 SDValue SoftenFloatRes_FP16_TO_FP(SDNode *
N);
563 SDValue SoftenFloatRes_FP_ROUND(SDNode *
N);
564 SDValue SoftenFloatRes_FPOW(SDNode *
N);
565 SDValue SoftenFloatRes_FPOWI(SDNode *
N);
566 SDValue SoftenFloatRes_FREEZE(SDNode *
N);
567 SDValue SoftenFloatRes_FREM(SDNode *
N);
568 SDValue SoftenFloatRes_FRINT(SDNode *
N);
569 SDValue SoftenFloatRes_FROUND(SDNode *
N);
570 SDValue SoftenFloatRes_FROUNDEVEN(SDNode *
N);
571 SDValue SoftenFloatRes_FSIN(SDNode *
N);
572 SDValue SoftenFloatRes_FSQRT(SDNode *
N);
573 SDValue SoftenFloatRes_FSUB(SDNode *
N);
574 SDValue SoftenFloatRes_FTRUNC(SDNode *
N);
575 SDValue SoftenFloatRes_LOAD(SDNode *
N);
576 SDValue SoftenFloatRes_SELECT(SDNode *
N);
577 SDValue SoftenFloatRes_SELECT_CC(SDNode *
N);
578 SDValue SoftenFloatRes_UNDEF(SDNode *
N);
579 SDValue SoftenFloatRes_VAARG(SDNode *
N);
580 SDValue SoftenFloatRes_XINT_TO_FP(SDNode *
N);
581 SDValue SoftenFloatRes_VECREDUCE(SDNode *
N);
582 SDValue SoftenFloatRes_VECREDUCE_SEQ(SDNode *
N);
585 bool SoftenFloatOperand(SDNode *
N,
unsigned OpNo);
587 SDValue SoftenFloatOp_BITCAST(SDNode *
N);
588 SDValue SoftenFloatOp_BR_CC(SDNode *
N);
589 SDValue SoftenFloatOp_FP_ROUND(SDNode *
N);
590 SDValue SoftenFloatOp_FP_TO_XINT(SDNode *
N);
591 SDValue SoftenFloatOp_FP_TO_XINT_SAT(SDNode *
N);
592 SDValue SoftenFloatOp_LROUND(SDNode *
N);
593 SDValue SoftenFloatOp_LLROUND(SDNode *
N);
594 SDValue SoftenFloatOp_LRINT(SDNode *
N);
595 SDValue SoftenFloatOp_LLRINT(SDNode *
N);
596 SDValue SoftenFloatOp_SELECT_CC(SDNode *
N);
597 SDValue SoftenFloatOp_SETCC(SDNode *
N);
598 SDValue SoftenFloatOp_STORE(SDNode *
N,
unsigned OpNo);
599 SDValue SoftenFloatOp_FCOPYSIGN(SDNode *
N);
611 void GetExpandedFloat(SDValue Op, SDValue &
Lo, SDValue &
Hi);
612 void SetExpandedFloat(SDValue Op, SDValue
Lo, SDValue
Hi);
615 void ExpandFloatResult(SDNode *
N,
unsigned ResNo);
616 void ExpandFloatRes_ConstantFP(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
618 SDValue &
Lo, SDValue &
Hi);
620 SDValue &
Lo, SDValue &
Hi);
621 void ExpandFloatRes_FABS (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
622 void ExpandFloatRes_FMINNUM (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
623 void ExpandFloatRes_FMAXNUM (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
624 void ExpandFloatRes_FADD (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
625 void ExpandFloatRes_FCBRT (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
626 void ExpandFloatRes_FCEIL (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
627 void ExpandFloatRes_FCOPYSIGN (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
628 void ExpandFloatRes_FCOS (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
629 void ExpandFloatRes_FDIV (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
630 void ExpandFloatRes_FEXP (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
631 void ExpandFloatRes_FEXP2 (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
632 void ExpandFloatRes_FFLOOR (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
633 void ExpandFloatRes_FLOG (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
634 void ExpandFloatRes_FLOG2 (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
635 void ExpandFloatRes_FLOG10 (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
636 void ExpandFloatRes_FMA (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
637 void ExpandFloatRes_FMUL (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
638 void ExpandFloatRes_FNEARBYINT(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
639 void ExpandFloatRes_FNEG (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
640 void ExpandFloatRes_FP_EXTEND (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
641 void ExpandFloatRes_FPOW (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
642 void ExpandFloatRes_FPOWI (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
643 void ExpandFloatRes_FREEZE (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
644 void ExpandFloatRes_FREM (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
645 void ExpandFloatRes_FRINT (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
646 void ExpandFloatRes_FROUND (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
647 void ExpandFloatRes_FROUNDEVEN(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
648 void ExpandFloatRes_FSIN (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
649 void ExpandFloatRes_FSQRT (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
650 void ExpandFloatRes_FSUB (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
651 void ExpandFloatRes_FTRUNC (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
652 void ExpandFloatRes_LOAD (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
653 void ExpandFloatRes_XINT_TO_FP(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
656 bool ExpandFloatOperand(SDNode *
N,
unsigned OpNo);
657 SDValue ExpandFloatOp_BR_CC(SDNode *
N);
658 SDValue ExpandFloatOp_FCOPYSIGN(SDNode *
N);
659 SDValue ExpandFloatOp_FP_ROUND(SDNode *
N);
660 SDValue ExpandFloatOp_FP_TO_XINT(SDNode *
N);
661 SDValue ExpandFloatOp_LROUND(SDNode *
N);
662 SDValue ExpandFloatOp_LLROUND(SDNode *
N);
663 SDValue ExpandFloatOp_LRINT(SDNode *
N);
664 SDValue ExpandFloatOp_LLRINT(SDNode *
N);
665 SDValue ExpandFloatOp_SELECT_CC(SDNode *
N);
666 SDValue ExpandFloatOp_SETCC(SDNode *
N);
667 SDValue ExpandFloatOp_STORE(SDNode *
N,
unsigned OpNo);
669 void FloatExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
671 SDValue &Chain,
bool IsSignaling =
false);
677 SDValue GetPromotedFloat(SDValue Op) {
678 TableId &PromotedId = PromotedFloats[getTableId(Op)];
679 SDValue PromotedOp = getSDValue(PromotedId);
680 assert(PromotedOp.getNode() &&
"Operand wasn't promoted?");
683 void SetPromotedFloat(SDValue Op, SDValue Result);
685 void PromoteFloatResult(SDNode *
N,
unsigned ResNo);
686 SDValue PromoteFloatRes_BITCAST(SDNode *
N);
687 SDValue PromoteFloatRes_BinOp(SDNode *
N);
688 SDValue PromoteFloatRes_ConstantFP(SDNode *
N);
689 SDValue PromoteFloatRes_EXTRACT_VECTOR_ELT(SDNode *
N);
690 SDValue PromoteFloatRes_FCOPYSIGN(SDNode *
N);
691 SDValue PromoteFloatRes_FMAD(SDNode *
N);
692 SDValue PromoteFloatRes_FPOWI(SDNode *
N);
693 SDValue PromoteFloatRes_FP_ROUND(SDNode *
N);
694 SDValue PromoteFloatRes_LOAD(SDNode *
N);
695 SDValue PromoteFloatRes_SELECT(SDNode *
N);
696 SDValue PromoteFloatRes_SELECT_CC(SDNode *
N);
697 SDValue PromoteFloatRes_UnaryOp(SDNode *
N);
698 SDValue PromoteFloatRes_UNDEF(SDNode *
N);
699 SDValue BitcastToInt_ATOMIC_SWAP(SDNode *
N);
700 SDValue PromoteFloatRes_XINT_TO_FP(SDNode *
N);
701 SDValue PromoteFloatRes_VECREDUCE(SDNode *
N);
702 SDValue PromoteFloatRes_VECREDUCE_SEQ(SDNode *
N);
704 bool PromoteFloatOperand(SDNode *
N,
unsigned OpNo);
705 SDValue PromoteFloatOp_BITCAST(SDNode *
N,
unsigned OpNo);
706 SDValue PromoteFloatOp_FCOPYSIGN(SDNode *
N,
unsigned OpNo);
707 SDValue PromoteFloatOp_FP_EXTEND(SDNode *
N,
unsigned OpNo);
708 SDValue PromoteFloatOp_FP_TO_XINT(SDNode *
N,
unsigned OpNo);
709 SDValue PromoteFloatOp_FP_TO_XINT_SAT(SDNode *
N,
unsigned OpNo);
710 SDValue PromoteFloatOp_STORE(SDNode *
N,
unsigned OpNo);
711 SDValue PromoteFloatOp_SELECT_CC(SDNode *
N,
unsigned OpNo);
712 SDValue PromoteFloatOp_SETCC(SDNode *
N,
unsigned OpNo);
718 SDValue GetSoftPromotedHalf(SDValue Op) {
719 TableId &PromotedId = SoftPromotedHalfs[getTableId(Op)];
720 SDValue PromotedOp = getSDValue(PromotedId);
721 assert(PromotedOp.getNode() &&
"Operand wasn't promoted?");
724 void SetSoftPromotedHalf(SDValue Op, SDValue Result);
726 void SoftPromoteHalfResult(SDNode *
N,
unsigned ResNo);
727 SDValue SoftPromoteHalfRes_BinOp(SDNode *
N);
728 SDValue SoftPromoteHalfRes_BITCAST(SDNode *
N);
729 SDValue SoftPromoteHalfRes_ConstantFP(SDNode *
N);
730 SDValue SoftPromoteHalfRes_EXTRACT_VECTOR_ELT(SDNode *
N);
731 SDValue SoftPromoteHalfRes_FCOPYSIGN(SDNode *
N);
732 SDValue SoftPromoteHalfRes_FMAD(SDNode *
N);
733 SDValue SoftPromoteHalfRes_FPOWI(SDNode *
N);
734 SDValue SoftPromoteHalfRes_FP_ROUND(SDNode *
N);
735 SDValue SoftPromoteHalfRes_LOAD(SDNode *
N);
736 SDValue SoftPromoteHalfRes_SELECT(SDNode *
N);
737 SDValue SoftPromoteHalfRes_SELECT_CC(SDNode *
N);
738 SDValue SoftPromoteHalfRes_UnaryOp(SDNode *
N);
739 SDValue SoftPromoteHalfRes_XINT_TO_FP(SDNode *
N);
740 SDValue SoftPromoteHalfRes_UNDEF(SDNode *
N);
741 SDValue SoftPromoteHalfRes_VECREDUCE(SDNode *
N);
742 SDValue SoftPromoteHalfRes_VECREDUCE_SEQ(SDNode *
N);
744 bool SoftPromoteHalfOperand(SDNode *
N,
unsigned OpNo);
745 SDValue SoftPromoteHalfOp_BITCAST(SDNode *
N);
746 SDValue SoftPromoteHalfOp_FCOPYSIGN(SDNode *
N,
unsigned OpNo);
747 SDValue SoftPromoteHalfOp_FP_EXTEND(SDNode *
N);
748 SDValue SoftPromoteHalfOp_FP_TO_XINT(SDNode *
N);
749 SDValue SoftPromoteHalfOp_FP_TO_XINT_SAT(SDNode *
N);
750 SDValue SoftPromoteHalfOp_SETCC(SDNode *
N);
751 SDValue SoftPromoteHalfOp_SELECT_CC(SDNode *
N,
unsigned OpNo);
752 SDValue SoftPromoteHalfOp_STORE(SDNode *
N,
unsigned OpNo);
753 SDValue SoftPromoteHalfOp_STACKMAP(SDNode *
N,
unsigned OpNo);
754 SDValue SoftPromoteHalfOp_PATCHPOINT(SDNode *
N,
unsigned OpNo);
763 SDValue GetScalarizedVector(SDValue Op) {
764 TableId &ScalarizedId = ScalarizedVectors[getTableId(Op)];
765 SDValue ScalarizedOp = getSDValue(ScalarizedId);
766 assert(ScalarizedOp.getNode() &&
"Operand wasn't scalarized?");
769 void SetScalarizedVector(SDValue Op, SDValue Result);
772 void ScalarizeVectorResult(SDNode *
N,
unsigned ResNo);
773 SDValue ScalarizeVecRes_MERGE_VALUES(SDNode *
N,
unsigned ResNo);
774 SDValue ScalarizeVecRes_BinOp(SDNode *
N);
775 SDValue ScalarizeVecRes_TernaryOp(SDNode *
N);
776 SDValue ScalarizeVecRes_UnaryOp(SDNode *
N);
777 SDValue ScalarizeVecRes_StrictFPOp(SDNode *
N);
778 SDValue ScalarizeVecRes_OverflowOp(SDNode *
N,
unsigned ResNo);
779 SDValue ScalarizeVecRes_InregOp(SDNode *
N);
780 SDValue ScalarizeVecRes_VecInregOp(SDNode *
N);
782 SDValue ScalarizeVecRes_BITCAST(SDNode *
N);
783 SDValue ScalarizeVecRes_BUILD_VECTOR(SDNode *
N);
784 SDValue ScalarizeVecRes_EXTRACT_SUBVECTOR(SDNode *
N);
785 SDValue ScalarizeVecRes_FP_ROUND(SDNode *
N);
786 SDValue ScalarizeVecRes_FPOWI(SDNode *
N);
787 SDValue ScalarizeVecRes_INSERT_VECTOR_ELT(SDNode *
N);
788 SDValue ScalarizeVecRes_LOAD(LoadSDNode *
N);
789 SDValue ScalarizeVecRes_SCALAR_TO_VECTOR(SDNode *
N);
790 SDValue ScalarizeVecRes_VSELECT(SDNode *
N);
791 SDValue ScalarizeVecRes_SELECT(SDNode *
N);
792 SDValue ScalarizeVecRes_SELECT_CC(SDNode *
N);
793 SDValue ScalarizeVecRes_SETCC(SDNode *
N);
794 SDValue ScalarizeVecRes_UNDEF(SDNode *
N);
795 SDValue ScalarizeVecRes_VECTOR_SHUFFLE(SDNode *
N);
796 SDValue ScalarizeVecRes_FP_TO_XINT_SAT(SDNode *
N);
797 SDValue ScalarizeVecRes_IS_FPCLASS(SDNode *
N);
799 SDValue ScalarizeVecRes_FIX(SDNode *
N);
802 bool ScalarizeVectorOperand(SDNode *
N,
unsigned OpNo);
803 SDValue ScalarizeVecOp_BITCAST(SDNode *
N);
804 SDValue ScalarizeVecOp_UnaryOp(SDNode *
N);
805 SDValue ScalarizeVecOp_UnaryOp_StrictFP(SDNode *
N);
806 SDValue ScalarizeVecOp_CONCAT_VECTORS(SDNode *
N);
807 SDValue ScalarizeVecOp_EXTRACT_VECTOR_ELT(SDNode *
N);
808 SDValue ScalarizeVecOp_VSELECT(SDNode *
N);
809 SDValue ScalarizeVecOp_VSETCC(SDNode *
N);
810 SDValue ScalarizeVecOp_STORE(StoreSDNode *
N,
unsigned OpNo);
811 SDValue ScalarizeVecOp_FP_ROUND(SDNode *
N,
unsigned OpNo);
812 SDValue ScalarizeVecOp_STRICT_FP_ROUND(SDNode *
N,
unsigned OpNo);
813 SDValue ScalarizeVecOp_FP_EXTEND(SDNode *
N);
814 SDValue ScalarizeVecOp_STRICT_FP_EXTEND(SDNode *
N);
815 SDValue ScalarizeVecOp_VECREDUCE(SDNode *
N);
816 SDValue ScalarizeVecOp_VECREDUCE_SEQ(SDNode *
N);
829 void GetSplitVector(SDValue Op, SDValue &
Lo, SDValue &
Hi);
830 void SetSplitVector(SDValue Op, SDValue
Lo, SDValue
Hi);
833 std::pair<SDValue, SDValue> SplitMask(SDValue Mask);
836 std::pair<SDValue, SDValue> SplitMask(SDValue Mask,
const SDLoc &
DL);
840 void IncrementPointer(MemSDNode *
N, EVT MemVT, MachinePointerInfo &MPI,
844 void SplitVectorResult(SDNode *
N,
unsigned ResNo);
845 void SplitVecRes_BinOp(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
846 void SplitVecRes_TernaryOp(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
847 void SplitVecRes_UnaryOp(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
848 void SplitVecRes_ExtendOp(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
849 void SplitVecRes_InregOp(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
850 void SplitVecRes_ExtVecInRegOp(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
851 void SplitVecRes_StrictFPOp(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
852 void SplitVecRes_OverflowOp(SDNode *
N,
unsigned ResNo,
853 SDValue &
Lo, SDValue &
Hi);
855 void SplitVecRes_FIX(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
857 void SplitVecRes_BITCAST(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
858 void SplitVecRes_BUILD_VECTOR(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
859 void SplitVecRes_CONCAT_VECTORS(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
860 void SplitVecRes_EXTRACT_SUBVECTOR(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
861 void SplitVecRes_INSERT_SUBVECTOR(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
862 void SplitVecRes_FPOWI(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
863 void SplitVecRes_FCOPYSIGN(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
864 void SplitVecRes_IS_FPCLASS(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
865 void SplitVecRes_INSERT_VECTOR_ELT(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
866 void SplitVecRes_LOAD(LoadSDNode *LD, SDValue &
Lo, SDValue &
Hi);
867 void SplitVecRes_VP_LOAD(VPLoadSDNode *LD, SDValue &
Lo, SDValue &
Hi);
868 void SplitVecRes_VP_STRIDED_LOAD(VPStridedLoadSDNode *SLD, SDValue &
Lo,
870 void SplitVecRes_MLOAD(MaskedLoadSDNode *MLD, SDValue &
Lo, SDValue &
Hi);
871 void SplitVecRes_Gather(MemSDNode *VPGT, SDValue &
Lo, SDValue &
Hi,
872 bool SplitSETCC =
false);
873 void SplitVecRes_ScalarOp(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
874 void SplitVecRes_STEP_VECTOR(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
875 void SplitVecRes_SETCC(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
876 void SplitVecRes_VECTOR_REVERSE(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
877 void SplitVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *
N, SDValue &
Lo,
879 void SplitVecRes_VECTOR_SPLICE(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
880 void SplitVecRes_VECTOR_DEINTERLEAVE(SDNode *
N);
881 void SplitVecRes_VECTOR_INTERLEAVE(SDNode *
N);
882 void SplitVecRes_VAARG(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
883 void SplitVecRes_FP_TO_XINT_SAT(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
886 bool SplitVectorOperand(SDNode *
N,
unsigned OpNo);
887 SDValue SplitVecOp_VSELECT(SDNode *
N,
unsigned OpNo);
888 SDValue SplitVecOp_VECREDUCE(SDNode *
N,
unsigned OpNo);
889 SDValue SplitVecOp_VECREDUCE_SEQ(SDNode *
N);
890 SDValue SplitVecOp_VP_REDUCE(SDNode *
N,
unsigned OpNo);
891 SDValue SplitVecOp_UnaryOp(SDNode *
N);
892 SDValue SplitVecOp_TruncateHelper(SDNode *
N);
894 SDValue SplitVecOp_BITCAST(SDNode *
N);
895 SDValue SplitVecOp_INSERT_SUBVECTOR(SDNode *
N,
unsigned OpNo);
896 SDValue SplitVecOp_EXTRACT_SUBVECTOR(SDNode *
N);
897 SDValue SplitVecOp_EXTRACT_VECTOR_ELT(SDNode *
N);
898 SDValue SplitVecOp_ExtVecInRegOp(SDNode *
N);
899 SDValue SplitVecOp_STORE(StoreSDNode *
N,
unsigned OpNo);
900 SDValue SplitVecOp_VP_STORE(VPStoreSDNode *
N,
unsigned OpNo);
901 SDValue SplitVecOp_VP_STRIDED_STORE(VPStridedStoreSDNode *
N,
unsigned OpNo);
902 SDValue SplitVecOp_MSTORE(MaskedStoreSDNode *
N,
unsigned OpNo);
903 SDValue SplitVecOp_Scatter(MemSDNode *
N,
unsigned OpNo);
904 SDValue SplitVecOp_Gather(MemSDNode *MGT,
unsigned OpNo);
905 SDValue SplitVecOp_CONCAT_VECTORS(SDNode *
N);
906 SDValue SplitVecOp_VSETCC(SDNode *
N);
907 SDValue SplitVecOp_FP_ROUND(SDNode *
N);
908 SDValue SplitVecOp_FCOPYSIGN(SDNode *
N);
909 SDValue SplitVecOp_FP_TO_XINT_SAT(SDNode *
N);
921 SDValue GetWidenedVector(SDValue Op) {
922 TableId &WidenedId = WidenedVectors[getTableId(Op)];
923 SDValue WidenedOp = getSDValue(WidenedId);
924 assert(WidenedOp.getNode() &&
"Operand wasn't widened?");
927 void SetWidenedVector(SDValue Op, SDValue Result);
930 SDValue GetWidenedMask(SDValue Mask, ElementCount EC) {
939 "Unable to widen binary VP op");
940 Mask = GetWidenedVector(Mask);
941 assert(
Mask.getValueType().getVectorElementCount() == EC &&
942 "Unable to widen binary VP op");
947 void WidenVectorResult(SDNode *
N,
unsigned ResNo);
948 SDValue WidenVecRes_MERGE_VALUES(SDNode*
N,
unsigned ResNo);
949 SDValue WidenVecRes_BITCAST(SDNode*
N);
950 SDValue WidenVecRes_BUILD_VECTOR(SDNode*
N);
951 SDValue WidenVecRes_CONCAT_VECTORS(SDNode*
N);
952 SDValue WidenVecRes_EXTEND_VECTOR_INREG(SDNode*
N);
953 SDValue WidenVecRes_EXTRACT_SUBVECTOR(SDNode*
N);
954 SDValue WidenVecRes_INSERT_SUBVECTOR(SDNode *
N);
955 SDValue WidenVecRes_INSERT_VECTOR_ELT(SDNode*
N);
956 SDValue WidenVecRes_LOAD(SDNode*
N);
957 SDValue WidenVecRes_VP_LOAD(VPLoadSDNode *
N);
958 SDValue WidenVecRes_VP_STRIDED_LOAD(VPStridedLoadSDNode *
N);
959 SDValue WidenVecRes_MLOAD(MaskedLoadSDNode*
N);
960 SDValue WidenVecRes_MGATHER(MaskedGatherSDNode*
N);
961 SDValue WidenVecRes_VP_GATHER(VPGatherSDNode*
N);
962 SDValue WidenVecRes_ScalarOp(SDNode*
N);
963 SDValue WidenVecRes_Select(SDNode *
N);
964 SDValue WidenVSELECTMask(SDNode *
N);
965 SDValue WidenVecRes_SELECT_CC(SDNode*
N);
966 SDValue WidenVecRes_SETCC(SDNode*
N);
967 SDValue WidenVecRes_STRICT_FSETCC(SDNode*
N);
968 SDValue WidenVecRes_UNDEF(SDNode *
N);
969 SDValue WidenVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *
N);
970 SDValue WidenVecRes_VECTOR_REVERSE(SDNode *
N);
972 SDValue WidenVecRes_Ternary(SDNode *
N);
973 SDValue WidenVecRes_Binary(SDNode *
N);
974 SDValue WidenVecRes_BinaryCanTrap(SDNode *
N);
975 SDValue WidenVecRes_BinaryWithExtraScalarOp(SDNode *
N);
976 SDValue WidenVecRes_StrictFP(SDNode *
N);
977 SDValue WidenVecRes_OverflowOp(SDNode *
N,
unsigned ResNo);
978 SDValue WidenVecRes_Convert(SDNode *
N);
979 SDValue WidenVecRes_Convert_StrictFP(SDNode *
N);
980 SDValue WidenVecRes_FP_TO_XINT_SAT(SDNode *
N);
981 SDValue WidenVecRes_FCOPYSIGN(SDNode *
N);
982 SDValue WidenVecRes_IS_FPCLASS(SDNode *
N);
983 SDValue WidenVecRes_POWI(SDNode *
N);
984 SDValue WidenVecRes_Unary(SDNode *
N);
985 SDValue WidenVecRes_InregOp(SDNode *
N);
988 bool WidenVectorOperand(SDNode *
N,
unsigned OpNo);
989 SDValue WidenVecOp_BITCAST(SDNode *
N);
990 SDValue WidenVecOp_CONCAT_VECTORS(SDNode *
N);
991 SDValue WidenVecOp_EXTEND(SDNode *
N);
992 SDValue WidenVecOp_EXTRACT_VECTOR_ELT(SDNode *
N);
993 SDValue WidenVecOp_INSERT_SUBVECTOR(SDNode *
N);
994 SDValue WidenVecOp_EXTRACT_SUBVECTOR(SDNode *
N);
995 SDValue WidenVecOp_STORE(SDNode*
N);
996 SDValue WidenVecOp_VP_STORE(SDNode *
N,
unsigned OpNo);
997 SDValue WidenVecOp_VP_STRIDED_STORE(SDNode *
N,
unsigned OpNo);
998 SDValue WidenVecOp_MSTORE(SDNode*
N,
unsigned OpNo);
999 SDValue WidenVecOp_MGATHER(SDNode*
N,
unsigned OpNo);
1000 SDValue WidenVecOp_MSCATTER(SDNode*
N,
unsigned OpNo);
1001 SDValue WidenVecOp_VP_SCATTER(SDNode*
N,
unsigned OpNo);
1002 SDValue WidenVecOp_SETCC(SDNode*
N);
1003 SDValue WidenVecOp_STRICT_FSETCC(SDNode*
N);
1004 SDValue WidenVecOp_VSELECT(SDNode *
N);
1006 SDValue WidenVecOp_Convert(SDNode *
N);
1007 SDValue WidenVecOp_FP_TO_XINT_SAT(SDNode *
N);
1008 SDValue WidenVecOp_FCOPYSIGN(SDNode *
N);
1009 SDValue WidenVecOp_IS_FPCLASS(SDNode *
N);
1010 SDValue WidenVecOp_VECREDUCE(SDNode *
N);
1011 SDValue WidenVecOp_VECREDUCE_SEQ(SDNode *
N);
1012 SDValue WidenVecOp_VP_REDUCE(SDNode *
N);
1017 SDValue UnrollVectorOp_StrictFP(SDNode *
N,
unsigned ResNE);
1027 SDValue GenWidenVectorLoads(SmallVectorImpl<SDValue> &LdChain,
1035 SDValue GenWidenVectorExtLoads(SmallVectorImpl<SDValue> &LdChain,
1042 bool GenWidenVectorStores(SmallVectorImpl<SDValue> &StChain, StoreSDNode *ST);
1048 SDValue ModifyToType(SDValue InOp, EVT NVT,
bool FillWithZeroes =
false);
1052 SDValue convertMask(SDValue InMask, EVT MaskVT, EVT ToMaskVT);
1062 void GetSplitOp(SDValue Op, SDValue &
Lo, SDValue &
Hi) {
1063 if (
Op.getValueType().isVector())
1064 GetSplitVector(Op,
Lo,
Hi);
1065 else if (
Op.getValueType().isInteger())
1066 GetExpandedInteger(Op,
Lo,
Hi);
1068 GetExpandedFloat(Op,
Lo,
Hi);
1073 void GetPairElements(SDValue Pair, SDValue &
Lo, SDValue &
Hi);
1076 void SplitRes_MERGE_VALUES(SDNode *
N,
unsigned ResNo,
1077 SDValue &
Lo, SDValue &
Hi);
1078 void SplitRes_ARITH_FENCE (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1079 void SplitRes_Select (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1080 void SplitRes_SELECT_CC (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1081 void SplitRes_UNDEF (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1082 void SplitRes_FREEZE (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1093 void GetExpandedOp(SDValue Op, SDValue &
Lo, SDValue &
Hi) {
1094 if (
Op.getValueType().isInteger())
1095 GetExpandedInteger(Op,
Lo,
Hi);
1097 GetExpandedFloat(Op,
Lo,
Hi);
1103 void IntegerToVector(SDValue Op,
unsigned NumElements,
1104 SmallVectorImpl<SDValue> &Ops, EVT EltVT);
1107 void ExpandRes_MERGE_VALUES (SDNode *
N,
unsigned ResNo,
1108 SDValue &
Lo, SDValue &
Hi);
1109 void ExpandRes_BITCAST (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1110 void ExpandRes_BUILD_PAIR (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1111 void ExpandRes_EXTRACT_ELEMENT (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1112 void ExpandRes_EXTRACT_VECTOR_ELT(SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1113 void ExpandRes_NormalLoad (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1114 void ExpandRes_VAARG (SDNode *
N, SDValue &
Lo, SDValue &
Hi);
1117 SDValue ExpandOp_BITCAST (SDNode *
N);
1118 SDValue ExpandOp_BUILD_VECTOR (SDNode *
N);
1119 SDValue ExpandOp_EXTRACT_ELEMENT (SDNode *
N);
1120 SDValue ExpandOp_INSERT_VECTOR_ELT(SDNode *
N);
1121 SDValue ExpandOp_SCALAR_TO_VECTOR (SDNode *
N);
1122 SDValue ExpandOp_NormalStore (SDNode *
N,
unsigned OpNo);
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
BlockVerifier::State From
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library,...
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.
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.
@ SIGN_EXTEND_INREG
SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to sign extend a small value in ...
@ TargetConstant
TargetConstant* - Like Constant*, but the DAG does not do any folding, simplification,...
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out,...
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
Libcall
RTLIB::Libcall enum - This enum defines all of the runtime library calls the backend can emit.
This is an optimization pass for GlobalISel generic memory operations.