16 #ifndef LLVM_LIB_CODEGEN_SELECTIONDAG_LEGALIZETYPES_H
17 #define LLVM_LIB_CODEGEN_SELECTIONDAG_LEGALIZETYPES_H
68 bool isTypeLegal(EVT VT)
const {
73 bool isSimpleLegalType(EVT VT)
const {
74 return VT.isSimple() && TLI.isTypeLegal(VT);
81 bool isLegalInHWReg(EVT VT)
const {
82 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
83 return VT == NVT && isSimpleLegalType(VT);
86 EVT getSetCCResultType(EVT VT)
const {
87 return TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
91 bool IgnoreNodeResults(SDNode *
N)
const {
97 SmallDenseMap<SDValue, SDValue, 8> PromotedIntegers;
101 SmallDenseMap<SDValue, std::pair<SDValue, SDValue>, 8> ExpandedIntegers;
105 SmallDenseMap<SDValue, SDValue, 8> SoftenedFloats;
109 SmallDenseMap<SDValue, SDValue, 8> PromotedFloats;
113 SmallDenseMap<SDValue, std::pair<SDValue, SDValue>, 8> ExpandedFloats;
117 SmallDenseMap<SDValue, SDValue, 8> ScalarizedVectors;
121 SmallDenseMap<SDValue, std::pair<SDValue, SDValue>, 8> SplitVectors;
125 SmallDenseMap<SDValue, SDValue, 8> WidenedVectors;
129 SmallDenseMap<SDValue, SDValue, 8> ReplacedValues;
133 SmallVector<SDNode*, 128> Worklist;
137 : TLI(dag.getTargetLoweringInfo()), DAG(dag),
138 ValueTypeActions(TLI.getValueTypeActions()) {
140 "Too many value types for ValueTypeActions to hold!");
159 void AnalyzeNewValue(
SDValue &Val);
160 void ExpungeNode(
SDNode *N);
161 void PerformExpensiveChecks();
168 bool CustomLowerNode(
SDNode *N,
EVT VT,
bool LegalizeResult);
169 bool CustomWidenLowerNode(
SDNode *N,
EVT VT);
180 SDNode *Node,
bool isSigned);
181 std::pair<SDValue, SDValue> ExpandAtomic(
SDNode *Node);
208 SDValue &PromotedOp = PromotedIntegers[
Op];
209 RemapValue(PromotedOp);
213 void SetPromotedInteger(SDValue Op, SDValue Result);
216 SDValue SExtPromotedInteger(SDValue Op) {
217 EVT OldVT = Op.getValueType();
219 Op = GetPromotedInteger(Op);
221 DAG.getValueType(OldVT));
225 SDValue ZExtPromotedInteger(SDValue Op) {
226 EVT OldVT = Op.getValueType();
228 Op = GetPromotedInteger(Op);
229 return DAG.getZeroExtendInReg(Op, dl, OldVT.getScalarType());
233 void PromoteIntegerResult(SDNode *N,
unsigned ResNo);
234 SDValue PromoteIntRes_MERGE_VALUES(SDNode *N,
unsigned ResNo);
235 SDValue PromoteIntRes_AssertSext(SDNode *N);
236 SDValue PromoteIntRes_AssertZext(SDNode *N);
237 SDValue PromoteIntRes_Atomic0(AtomicSDNode *N);
238 SDValue PromoteIntRes_Atomic1(AtomicSDNode *N);
239 SDValue PromoteIntRes_AtomicCmpSwap(AtomicSDNode *N,
unsigned ResNo);
240 SDValue PromoteIntRes_EXTRACT_SUBVECTOR(SDNode *N);
241 SDValue PromoteIntRes_VECTOR_SHUFFLE(SDNode *N);
242 SDValue PromoteIntRes_BUILD_VECTOR(SDNode *N);
243 SDValue PromoteIntRes_SCALAR_TO_VECTOR(SDNode *N);
244 SDValue PromoteIntRes_EXTEND_VECTOR_INREG(SDNode *N);
245 SDValue PromoteIntRes_INSERT_VECTOR_ELT(SDNode *N);
246 SDValue PromoteIntRes_CONCAT_VECTORS(SDNode *N);
247 SDValue PromoteIntRes_BITCAST(SDNode *N);
248 SDValue PromoteIntRes_BSWAP(SDNode *N);
249 SDValue PromoteIntRes_BITREVERSE(SDNode *N);
250 SDValue PromoteIntRes_BUILD_PAIR(SDNode *N);
251 SDValue PromoteIntRes_Constant(SDNode *N);
252 SDValue PromoteIntRes_CTLZ(SDNode *N);
253 SDValue PromoteIntRes_CTPOP(SDNode *N);
254 SDValue PromoteIntRes_CTTZ(SDNode *N);
255 SDValue PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *N);
256 SDValue PromoteIntRes_FP_TO_XINT(SDNode *N);
257 SDValue PromoteIntRes_FP_TO_FP16(SDNode *N);
258 SDValue PromoteIntRes_INT_EXTEND(SDNode *N);
259 SDValue PromoteIntRes_LOAD(LoadSDNode *N);
260 SDValue PromoteIntRes_MLOAD(MaskedLoadSDNode *N);
261 SDValue PromoteIntRes_MGATHER(MaskedGatherSDNode *N);
262 SDValue PromoteIntRes_Overflow(SDNode *N);
263 SDValue PromoteIntRes_SADDSUBO(SDNode *N,
unsigned ResNo);
264 SDValue PromoteIntRes_SELECT(SDNode *N);
265 SDValue PromoteIntRes_VSELECT(SDNode *N);
266 SDValue PromoteIntRes_SELECT_CC(SDNode *N);
267 SDValue PromoteIntRes_SETCC(SDNode *N);
268 SDValue PromoteIntRes_SHL(SDNode *N);
269 SDValue PromoteIntRes_SimpleIntBinOp(SDNode *N);
270 SDValue PromoteIntRes_ZExtIntBinOp(SDNode *N);
271 SDValue PromoteIntRes_SExtIntBinOp(SDNode *N);
272 SDValue PromoteIntRes_SIGN_EXTEND_INREG(SDNode *N);
273 SDValue PromoteIntRes_SRA(SDNode *N);
274 SDValue PromoteIntRes_SRL(SDNode *N);
275 SDValue PromoteIntRes_TRUNCATE(SDNode *N);
276 SDValue PromoteIntRes_UADDSUBO(SDNode *N,
unsigned ResNo);
277 SDValue PromoteIntRes_UNDEF(SDNode *N);
278 SDValue PromoteIntRes_VAARG(SDNode *N);
279 SDValue PromoteIntRes_XMULO(SDNode *N,
unsigned ResNo);
282 bool PromoteIntegerOperand(SDNode *N,
unsigned OperandNo);
283 SDValue PromoteIntOp_ANY_EXTEND(SDNode *N);
284 SDValue PromoteIntOp_ATOMIC_STORE(AtomicSDNode *N);
285 SDValue PromoteIntOp_BITCAST(SDNode *N);
286 SDValue PromoteIntOp_BUILD_PAIR(SDNode *N);
287 SDValue PromoteIntOp_BR_CC(SDNode *N,
unsigned OpNo);
288 SDValue PromoteIntOp_BRCOND(SDNode *N,
unsigned OpNo);
289 SDValue PromoteIntOp_BUILD_VECTOR(SDNode *N);
290 SDValue PromoteIntOp_INSERT_VECTOR_ELT(SDNode *N,
unsigned OpNo);
291 SDValue PromoteIntOp_EXTRACT_VECTOR_ELT(SDNode *N);
292 SDValue PromoteIntOp_EXTRACT_SUBVECTOR(SDNode *N);
293 SDValue PromoteIntOp_CONCAT_VECTORS(SDNode *N);
294 SDValue PromoteIntOp_SCALAR_TO_VECTOR(SDNode *N);
295 SDValue PromoteIntOp_SELECT(SDNode *N,
unsigned OpNo);
296 SDValue PromoteIntOp_SELECT_CC(SDNode *N,
unsigned OpNo);
297 SDValue PromoteIntOp_SETCC(SDNode *N,
unsigned OpNo);
298 SDValue PromoteIntOp_Shift(SDNode *N);
299 SDValue PromoteIntOp_SIGN_EXTEND(SDNode *N);
300 SDValue PromoteIntOp_SINT_TO_FP(SDNode *N);
301 SDValue PromoteIntOp_STORE(StoreSDNode *N,
unsigned OpNo);
302 SDValue PromoteIntOp_TRUNCATE(SDNode *N);
303 SDValue PromoteIntOp_UINT_TO_FP(SDNode *N);
304 SDValue PromoteIntOp_ZERO_EXTEND(SDNode *N);
305 SDValue PromoteIntOp_MSTORE(MaskedStoreSDNode *N,
unsigned OpNo);
306 SDValue PromoteIntOp_MLOAD(MaskedLoadSDNode *N,
unsigned OpNo);
307 SDValue PromoteIntOp_MSCATTER(MaskedScatterSDNode *N,
unsigned OpNo);
308 SDValue PromoteIntOp_MGATHER(MaskedGatherSDNode *N,
unsigned OpNo);
310 void PromoteSetCCOperands(SDValue &LHS,SDValue &RHS,
ISD::CondCode Code);
322 void GetExpandedInteger(SDValue Op, SDValue &
Lo, SDValue &
Hi);
323 void SetExpandedInteger(SDValue Op, SDValue
Lo, SDValue
Hi);
326 void ExpandIntegerResult(SDNode *N,
unsigned ResNo);
327 void ExpandIntRes_ANY_EXTEND (SDNode *N, SDValue &
Lo, SDValue &
Hi);
328 void ExpandIntRes_AssertSext (SDNode *N, SDValue &
Lo, SDValue &
Hi);
329 void ExpandIntRes_AssertZext (SDNode *N, SDValue &
Lo, SDValue &
Hi);
330 void ExpandIntRes_Constant (SDNode *N, SDValue &
Lo, SDValue &
Hi);
331 void ExpandIntRes_CTLZ (SDNode *N, SDValue &
Lo, SDValue &
Hi);
332 void ExpandIntRes_CTPOP (SDNode *N, SDValue &
Lo, SDValue &
Hi);
333 void ExpandIntRes_CTTZ (SDNode *N, SDValue &
Lo, SDValue &
Hi);
334 void ExpandIntRes_LOAD (LoadSDNode *N, SDValue &
Lo, SDValue &
Hi);
335 void ExpandIntRes_READCYCLECOUNTER (SDNode *N, SDValue &
Lo, SDValue &
Hi);
336 void ExpandIntRes_SIGN_EXTEND (SDNode *N, SDValue &
Lo, SDValue &
Hi);
337 void ExpandIntRes_SIGN_EXTEND_INREG (SDNode *N, SDValue &
Lo, SDValue &
Hi);
338 void ExpandIntRes_TRUNCATE (SDNode *N, SDValue &
Lo, SDValue &
Hi);
339 void ExpandIntRes_ZERO_EXTEND (SDNode *N, SDValue &
Lo, SDValue &
Hi);
340 void ExpandIntRes_FLT_ROUNDS (SDNode *N, SDValue &
Lo, SDValue &
Hi);
341 void ExpandIntRes_FP_TO_SINT (SDNode *N, SDValue &
Lo, SDValue &
Hi);
342 void ExpandIntRes_FP_TO_UINT (SDNode *N, SDValue &
Lo, SDValue &
Hi);
344 void ExpandIntRes_Logical (SDNode *N, SDValue &
Lo, SDValue &
Hi);
345 void ExpandIntRes_ADDSUB (SDNode *N, SDValue &
Lo, SDValue &
Hi);
346 void ExpandIntRes_ADDSUBC (SDNode *N, SDValue &
Lo, SDValue &
Hi);
347 void ExpandIntRes_ADDSUBE (SDNode *N, SDValue &
Lo, SDValue &
Hi);
348 void ExpandIntRes_BITREVERSE (SDNode *N, SDValue &
Lo, SDValue &
Hi);
349 void ExpandIntRes_BSWAP (SDNode *N, SDValue &
Lo, SDValue &
Hi);
350 void ExpandIntRes_MUL (SDNode *N, SDValue &
Lo, SDValue &
Hi);
351 void ExpandIntRes_SDIV (SDNode *N, SDValue &
Lo, SDValue &
Hi);
352 void ExpandIntRes_SREM (SDNode *N, SDValue &
Lo, SDValue &
Hi);
353 void ExpandIntRes_UDIV (SDNode *N, SDValue &
Lo, SDValue &
Hi);
354 void ExpandIntRes_UREM (SDNode *N, SDValue &
Lo, SDValue &
Hi);
355 void ExpandIntRes_Shift (SDNode *N, SDValue &
Lo, SDValue &
Hi);
357 void ExpandIntRes_MINMAX (SDNode *N, SDValue &
Lo, SDValue &
Hi);
359 void ExpandIntRes_SADDSUBO (SDNode *N, SDValue &
Lo, SDValue &
Hi);
360 void ExpandIntRes_UADDSUBO (SDNode *N, SDValue &
Lo, SDValue &
Hi);
361 void ExpandIntRes_XMULO (SDNode *N, SDValue &
Lo, SDValue &
Hi);
363 void ExpandIntRes_ATOMIC_LOAD (SDNode *N, SDValue &
Lo, SDValue &
Hi);
365 void ExpandShiftByConstant(SDNode *N,
const APInt &Amt,
366 SDValue &
Lo, SDValue &
Hi);
367 bool ExpandShiftWithKnownAmountBit(SDNode *N, SDValue &
Lo, SDValue &
Hi);
368 bool ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &
Lo, SDValue &
Hi);
371 bool ExpandIntegerOperand(SDNode *N,
unsigned OperandNo);
372 SDValue ExpandIntOp_BR_CC(SDNode *N);
373 SDValue ExpandIntOp_SELECT_CC(SDNode *N);
374 SDValue ExpandIntOp_SETCC(SDNode *N);
375 SDValue ExpandIntOp_SETCCE(SDNode *N);
376 SDValue ExpandIntOp_Shift(SDNode *N);
377 SDValue ExpandIntOp_SINT_TO_FP(SDNode *N);
378 SDValue ExpandIntOp_STORE(StoreSDNode *N,
unsigned OpNo);
379 SDValue ExpandIntOp_TRUNCATE(SDNode *N);
380 SDValue ExpandIntOp_UINT_TO_FP(SDNode *N);
381 SDValue ExpandIntOp_RETURNADDR(SDNode *N);
382 SDValue ExpandIntOp_ATOMIC_STORE(SDNode *N);
384 void IntegerExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
399 SDValue GetSoftenedFloat(SDValue Op) {
400 SDValue &SoftenedOp = SoftenedFloats[
Op];
401 if (!SoftenedOp.getNode() &&
402 isSimpleLegalType(Op.getValueType()))
404 RemapValue(SoftenedOp);
405 assert(SoftenedOp.getNode() &&
"Operand wasn't converted to integer?");
408 void SetSoftenedFloat(SDValue Op, SDValue Result);
411 void ReplaceSoftenFloatResult(SDNode *N,
unsigned ResNo, SDValue &NewRes) {
416 if (NewRes.getNode() != N && isLegalInHWReg(N->getValueType(ResNo)))
417 ReplaceValueWith(SDValue(N, ResNo), NewRes);
421 bool SoftenFloatResult(SDNode *N,
unsigned ResNo);
422 SDValue SoftenFloatRes_MERGE_VALUES(SDNode *N,
unsigned ResNo);
423 SDValue SoftenFloatRes_BITCAST(SDNode *N,
unsigned ResNo);
424 SDValue SoftenFloatRes_BUILD_PAIR(SDNode *N);
425 SDValue SoftenFloatRes_ConstantFP(SDNode *N,
unsigned ResNo);
426 SDValue SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N);
427 SDValue SoftenFloatRes_FABS(SDNode *N,
unsigned ResNo);
428 SDValue SoftenFloatRes_FMINNUM(SDNode *N);
429 SDValue SoftenFloatRes_FMAXNUM(SDNode *N);
430 SDValue SoftenFloatRes_FADD(SDNode *N);
431 SDValue SoftenFloatRes_FCEIL(SDNode *N);
432 SDValue SoftenFloatRes_FCOPYSIGN(SDNode *N,
unsigned ResNo);
433 SDValue SoftenFloatRes_FCOS(SDNode *N);
434 SDValue SoftenFloatRes_FDIV(SDNode *N);
435 SDValue SoftenFloatRes_FEXP(SDNode *N);
436 SDValue SoftenFloatRes_FEXP2(SDNode *N);
437 SDValue SoftenFloatRes_FFLOOR(SDNode *N);
438 SDValue SoftenFloatRes_FLOG(SDNode *N);
439 SDValue SoftenFloatRes_FLOG2(SDNode *N);
440 SDValue SoftenFloatRes_FLOG10(SDNode *N);
441 SDValue SoftenFloatRes_FMA(SDNode *N);
442 SDValue SoftenFloatRes_FMUL(SDNode *N);
443 SDValue SoftenFloatRes_FNEARBYINT(SDNode *N);
444 SDValue SoftenFloatRes_FNEG(SDNode *N,
unsigned ResNo);
445 SDValue SoftenFloatRes_FP_EXTEND(SDNode *N);
446 SDValue SoftenFloatRes_FP16_TO_FP(SDNode *N);
447 SDValue SoftenFloatRes_FP_ROUND(SDNode *N);
448 SDValue SoftenFloatRes_FPOW(SDNode *N);
449 SDValue SoftenFloatRes_FPOWI(SDNode *N);
450 SDValue SoftenFloatRes_FREM(SDNode *N);
451 SDValue SoftenFloatRes_FRINT(SDNode *N);
452 SDValue SoftenFloatRes_FROUND(SDNode *N);
453 SDValue SoftenFloatRes_FSIN(SDNode *N);
454 SDValue SoftenFloatRes_FSQRT(SDNode *N);
455 SDValue SoftenFloatRes_FSUB(SDNode *N);
456 SDValue SoftenFloatRes_FTRUNC(SDNode *N);
457 SDValue SoftenFloatRes_LOAD(SDNode *N,
unsigned ResNo);
458 SDValue SoftenFloatRes_SELECT(SDNode *N,
unsigned ResNo);
459 SDValue SoftenFloatRes_SELECT_CC(SDNode *N,
unsigned ResNo);
460 SDValue SoftenFloatRes_UNDEF(SDNode *N);
461 SDValue SoftenFloatRes_VAARG(SDNode *N);
462 SDValue SoftenFloatRes_XINT_TO_FP(SDNode *N);
467 bool CanSkipSoftenFloatOperand(SDNode *N,
unsigned OpNo);
470 bool SoftenFloatOperand(SDNode *N,
unsigned OpNo);
471 SDValue SoftenFloatOp_BITCAST(SDNode *N);
472 SDValue SoftenFloatOp_BR_CC(SDNode *N);
473 SDValue SoftenFloatOp_FP_EXTEND(SDNode *N);
474 SDValue SoftenFloatOp_FP_ROUND(SDNode *N);
475 SDValue SoftenFloatOp_FP_TO_XINT(SDNode *N);
476 SDValue SoftenFloatOp_SELECT_CC(SDNode *N);
477 SDValue SoftenFloatOp_SETCC(SDNode *N);
478 SDValue SoftenFloatOp_STORE(SDNode *N,
unsigned OpNo);
490 void GetExpandedFloat(SDValue Op, SDValue &
Lo, SDValue &
Hi);
491 void SetExpandedFloat(SDValue Op, SDValue
Lo, SDValue
Hi);
494 void ExpandFloatResult(SDNode *N,
unsigned ResNo);
495 void ExpandFloatRes_ConstantFP(SDNode *N, SDValue &
Lo, SDValue &
Hi);
496 void ExpandFloatRes_FABS (SDNode *N, SDValue &
Lo, SDValue &
Hi);
497 void ExpandFloatRes_FMINNUM (SDNode *N, SDValue &
Lo, SDValue &
Hi);
498 void ExpandFloatRes_FMAXNUM (SDNode *N, SDValue &
Lo, SDValue &
Hi);
499 void ExpandFloatRes_FADD (SDNode *N, SDValue &
Lo, SDValue &
Hi);
500 void ExpandFloatRes_FCEIL (SDNode *N, SDValue &
Lo, SDValue &
Hi);
501 void ExpandFloatRes_FCOPYSIGN (SDNode *N, SDValue &
Lo, SDValue &
Hi);
502 void ExpandFloatRes_FCOS (SDNode *N, SDValue &
Lo, SDValue &
Hi);
503 void ExpandFloatRes_FDIV (SDNode *N, SDValue &
Lo, SDValue &
Hi);
504 void ExpandFloatRes_FEXP (SDNode *N, SDValue &
Lo, SDValue &
Hi);
505 void ExpandFloatRes_FEXP2 (SDNode *N, SDValue &
Lo, SDValue &
Hi);
506 void ExpandFloatRes_FFLOOR (SDNode *N, SDValue &
Lo, SDValue &
Hi);
507 void ExpandFloatRes_FLOG (SDNode *N, SDValue &
Lo, SDValue &
Hi);
508 void ExpandFloatRes_FLOG2 (SDNode *N, SDValue &
Lo, SDValue &
Hi);
509 void ExpandFloatRes_FLOG10 (SDNode *N, SDValue &
Lo, SDValue &
Hi);
510 void ExpandFloatRes_FMA (SDNode *N, SDValue &
Lo, SDValue &
Hi);
511 void ExpandFloatRes_FMUL (SDNode *N, SDValue &
Lo, SDValue &
Hi);
512 void ExpandFloatRes_FNEARBYINT(SDNode *N, SDValue &
Lo, SDValue &
Hi);
513 void ExpandFloatRes_FNEG (SDNode *N, SDValue &
Lo, SDValue &
Hi);
514 void ExpandFloatRes_FP_EXTEND (SDNode *N, SDValue &
Lo, SDValue &
Hi);
515 void ExpandFloatRes_FPOW (SDNode *N, SDValue &
Lo, SDValue &
Hi);
516 void ExpandFloatRes_FPOWI (SDNode *N, SDValue &
Lo, SDValue &
Hi);
517 void ExpandFloatRes_FREM (SDNode *N, SDValue &
Lo, SDValue &
Hi);
518 void ExpandFloatRes_FRINT (SDNode *N, SDValue &
Lo, SDValue &
Hi);
519 void ExpandFloatRes_FROUND (SDNode *N, SDValue &
Lo, SDValue &
Hi);
520 void ExpandFloatRes_FSIN (SDNode *N, SDValue &
Lo, SDValue &
Hi);
521 void ExpandFloatRes_FSQRT (SDNode *N, SDValue &
Lo, SDValue &
Hi);
522 void ExpandFloatRes_FSUB (SDNode *N, SDValue &
Lo, SDValue &
Hi);
523 void ExpandFloatRes_FTRUNC (SDNode *N, SDValue &
Lo, SDValue &
Hi);
524 void ExpandFloatRes_LOAD (SDNode *N, SDValue &
Lo, SDValue &
Hi);
525 void ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &
Lo, SDValue &
Hi);
528 bool ExpandFloatOperand(SDNode *N,
unsigned OperandNo);
529 SDValue ExpandFloatOp_BR_CC(SDNode *N);
530 SDValue ExpandFloatOp_FCOPYSIGN(SDNode *N);
531 SDValue ExpandFloatOp_FP_ROUND(SDNode *N);
532 SDValue ExpandFloatOp_FP_TO_SINT(SDNode *N);
533 SDValue ExpandFloatOp_FP_TO_UINT(SDNode *N);
534 SDValue ExpandFloatOp_SELECT_CC(SDNode *N);
535 SDValue ExpandFloatOp_SETCC(SDNode *N);
536 SDValue ExpandFloatOp_STORE(SDNode *N,
unsigned OpNo);
538 void FloatExpandSetCCOperands(SDValue &NewLHS, SDValue &NewRHS,
545 SDValue GetPromotedFloat(SDValue Op) {
546 SDValue &PromotedOp = PromotedFloats[
Op];
547 RemapValue(PromotedOp);
548 assert(PromotedOp.getNode() &&
"Operand wasn't promoted?");
551 void SetPromotedFloat(SDValue Op, SDValue Result);
553 void PromoteFloatResult(SDNode *N,
unsigned ResNo);
554 SDValue PromoteFloatRes_BITCAST(SDNode *N);
555 SDValue PromoteFloatRes_BinOp(SDNode *N);
556 SDValue PromoteFloatRes_ConstantFP(SDNode *N);
557 SDValue PromoteFloatRes_EXTRACT_VECTOR_ELT(SDNode *N);
558 SDValue PromoteFloatRes_FCOPYSIGN(SDNode *N);
559 SDValue PromoteFloatRes_FMAD(SDNode *N);
560 SDValue PromoteFloatRes_FPOWI(SDNode *N);
561 SDValue PromoteFloatRes_FP_ROUND(SDNode *N);
562 SDValue PromoteFloatRes_LOAD(SDNode *N);
563 SDValue PromoteFloatRes_SELECT(SDNode *N);
564 SDValue PromoteFloatRes_SELECT_CC(SDNode *N);
565 SDValue PromoteFloatRes_UnaryOp(SDNode *N);
566 SDValue PromoteFloatRes_UNDEF(SDNode *N);
567 SDValue PromoteFloatRes_XINT_TO_FP(SDNode *N);
569 bool PromoteFloatOperand(SDNode *N,
unsigned ResNo);
570 SDValue PromoteFloatOp_BITCAST(SDNode *N,
unsigned OpNo);
571 SDValue PromoteFloatOp_FCOPYSIGN(SDNode *N,
unsigned OpNo);
572 SDValue PromoteFloatOp_FP_EXTEND(SDNode *N,
unsigned OpNo);
573 SDValue PromoteFloatOp_FP_TO_XINT(SDNode *N,
unsigned OpNo);
574 SDValue PromoteFloatOp_STORE(SDNode *N,
unsigned OpNo);
575 SDValue PromoteFloatOp_SELECT_CC(SDNode *N,
unsigned OpNo);
576 SDValue PromoteFloatOp_SETCC(SDNode *N,
unsigned OpNo);
585 SDValue GetScalarizedVector(SDValue Op) {
586 SDValue &ScalarizedOp = ScalarizedVectors[
Op];
587 RemapValue(ScalarizedOp);
588 assert(ScalarizedOp.getNode() &&
"Operand wasn't scalarized?");
591 void SetScalarizedVector(SDValue Op, SDValue Result);
594 void ScalarizeVectorResult(SDNode *N,
unsigned OpNo);
595 SDValue ScalarizeVecRes_MERGE_VALUES(SDNode *N,
unsigned ResNo);
596 SDValue ScalarizeVecRes_BinOp(SDNode *N);
597 SDValue ScalarizeVecRes_TernaryOp(SDNode *N);
598 SDValue ScalarizeVecRes_UnaryOp(SDNode *N);
599 SDValue ScalarizeVecRes_InregOp(SDNode *N);
601 SDValue ScalarizeVecRes_BITCAST(SDNode *N);
602 SDValue ScalarizeVecRes_BUILD_VECTOR(SDNode *N);
603 SDValue ScalarizeVecRes_EXTRACT_SUBVECTOR(SDNode *N);
604 SDValue ScalarizeVecRes_FP_ROUND(SDNode *N);
605 SDValue ScalarizeVecRes_FPOWI(SDNode *N);
606 SDValue ScalarizeVecRes_INSERT_VECTOR_ELT(SDNode *N);
607 SDValue ScalarizeVecRes_LOAD(LoadSDNode *N);
608 SDValue ScalarizeVecRes_SCALAR_TO_VECTOR(SDNode *N);
609 SDValue ScalarizeVecRes_VSELECT(SDNode *N);
610 SDValue ScalarizeVecRes_SELECT(SDNode *N);
611 SDValue ScalarizeVecRes_SELECT_CC(SDNode *N);
612 SDValue ScalarizeVecRes_SETCC(SDNode *N);
613 SDValue ScalarizeVecRes_UNDEF(SDNode *N);
614 SDValue ScalarizeVecRes_VECTOR_SHUFFLE(SDNode *N);
615 SDValue ScalarizeVecRes_VSETCC(SDNode *N);
618 bool ScalarizeVectorOperand(SDNode *N,
unsigned OpNo);
619 SDValue ScalarizeVecOp_BITCAST(SDNode *N);
620 SDValue ScalarizeVecOp_UnaryOp(SDNode *N);
621 SDValue ScalarizeVecOp_CONCAT_VECTORS(SDNode *N);
622 SDValue ScalarizeVecOp_EXTRACT_VECTOR_ELT(SDNode *N);
623 SDValue ScalarizeVecOp_VSELECT(SDNode *N);
624 SDValue ScalarizeVecOp_STORE(StoreSDNode *N,
unsigned OpNo);
625 SDValue ScalarizeVecOp_FP_ROUND(SDNode *N,
unsigned OpNo);
638 void GetSplitVector(SDValue Op, SDValue &
Lo, SDValue &
Hi);
639 void SetSplitVector(SDValue Op, SDValue
Lo, SDValue
Hi);
642 void SplitVectorResult(SDNode *N,
unsigned OpNo);
643 void SplitVecRes_BinOp(SDNode *N, SDValue &
Lo, SDValue &
Hi);
644 void SplitVecRes_TernaryOp(SDNode *N, SDValue &
Lo, SDValue &
Hi);
645 void SplitVecRes_UnaryOp(SDNode *N, SDValue &
Lo, SDValue &
Hi);
646 void SplitVecRes_ExtendOp(SDNode *N, SDValue &
Lo, SDValue &
Hi);
647 void SplitVecRes_InregOp(SDNode *N, SDValue &
Lo, SDValue &
Hi);
648 void SplitVecRes_ExtVecInRegOp(SDNode *N, SDValue &
Lo, SDValue &
Hi);
650 void SplitVecRes_BITCAST(SDNode *N, SDValue &
Lo, SDValue &
Hi);
651 void SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &
Lo, SDValue &
Hi);
652 void SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &
Lo, SDValue &
Hi);
653 void SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &
Lo, SDValue &
Hi);
654 void SplitVecRes_INSERT_SUBVECTOR(SDNode *N, SDValue &
Lo, SDValue &
Hi);
655 void SplitVecRes_FPOWI(SDNode *N, SDValue &
Lo, SDValue &
Hi);
656 void SplitVecRes_FCOPYSIGN(SDNode *N, SDValue &
Lo, SDValue &
Hi);
657 void SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &
Lo, SDValue &
Hi);
658 void SplitVecRes_LOAD(LoadSDNode *N, SDValue &
Lo, SDValue &
Hi);
659 void SplitVecRes_MLOAD(MaskedLoadSDNode *N, SDValue &
Lo, SDValue &
Hi);
660 void SplitVecRes_MGATHER(MaskedGatherSDNode *N, SDValue &
Lo, SDValue &
Hi);
661 void SplitVecRes_SCALAR_TO_VECTOR(SDNode *N, SDValue &
Lo, SDValue &
Hi);
662 void SplitVecRes_SETCC(SDNode *N, SDValue &
Lo, SDValue &
Hi);
663 void SplitVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N, SDValue &
Lo,
667 bool SplitVectorOperand(SDNode *N,
unsigned OpNo);
668 SDValue SplitVecOp_VSELECT(SDNode *N,
unsigned OpNo);
669 SDValue SplitVecOp_UnaryOp(SDNode *N);
670 SDValue SplitVecOp_TruncateHelper(SDNode *N);
672 SDValue SplitVecOp_BITCAST(SDNode *N);
673 SDValue SplitVecOp_EXTRACT_SUBVECTOR(SDNode *N);
674 SDValue SplitVecOp_EXTRACT_VECTOR_ELT(SDNode *N);
675 SDValue SplitVecOp_STORE(StoreSDNode *N,
unsigned OpNo);
676 SDValue SplitVecOp_MSTORE(MaskedStoreSDNode *N,
unsigned OpNo);
677 SDValue SplitVecOp_MSCATTER(MaskedScatterSDNode *N,
unsigned OpNo);
678 SDValue SplitVecOp_MGATHER(MaskedGatherSDNode *N,
unsigned OpNo);
679 SDValue SplitVecOp_CONCAT_VECTORS(SDNode *N);
680 SDValue SplitVecOp_VSETCC(SDNode *N);
681 SDValue SplitVecOp_FP_ROUND(SDNode *N);
682 SDValue SplitVecOp_FCOPYSIGN(SDNode *N);
694 SDValue GetWidenedVector(SDValue Op) {
695 SDValue &WidenedOp = WidenedVectors[
Op];
696 RemapValue(WidenedOp);
697 assert(WidenedOp.getNode() &&
"Operand wasn't widened?");
700 void SetWidenedVector(SDValue Op, SDValue Result);
703 void WidenVectorResult(SDNode *N,
unsigned ResNo);
704 SDValue WidenVecRes_MERGE_VALUES(SDNode* N,
unsigned ResNo);
705 SDValue WidenVecRes_BITCAST(SDNode* N);
706 SDValue WidenVecRes_BUILD_VECTOR(SDNode* N);
707 SDValue WidenVecRes_CONCAT_VECTORS(SDNode* N);
708 SDValue WidenVecRes_EXTEND_VECTOR_INREG(SDNode* N);
709 SDValue WidenVecRes_EXTRACT_SUBVECTOR(SDNode* N);
710 SDValue WidenVecRes_INSERT_VECTOR_ELT(SDNode* N);
711 SDValue WidenVecRes_LOAD(SDNode* N);
712 SDValue WidenVecRes_MLOAD(MaskedLoadSDNode* N);
713 SDValue WidenVecRes_MGATHER(MaskedGatherSDNode* N);
714 SDValue WidenVecRes_SCALAR_TO_VECTOR(SDNode* N);
715 SDValue WidenVecRes_SELECT(SDNode* N);
716 SDValue WidenVecRes_SELECT_CC(SDNode* N);
717 SDValue WidenVecRes_SETCC(SDNode* N);
718 SDValue WidenVecRes_UNDEF(SDNode *N);
719 SDValue WidenVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N);
720 SDValue WidenVecRes_VSETCC(SDNode* N);
722 SDValue WidenVecRes_Ternary(SDNode *N);
723 SDValue WidenVecRes_Binary(SDNode *N);
724 SDValue WidenVecRes_BinaryCanTrap(SDNode *N);
725 SDValue WidenVecRes_Convert(SDNode *N);
726 SDValue WidenVecRes_FCOPYSIGN(SDNode *N);
727 SDValue WidenVecRes_POWI(SDNode *N);
728 SDValue WidenVecRes_Shift(SDNode *N);
729 SDValue WidenVecRes_Unary(SDNode *N);
730 SDValue WidenVecRes_InregOp(SDNode *N);
733 bool WidenVectorOperand(SDNode *N,
unsigned OpNo);
734 SDValue WidenVecOp_BITCAST(SDNode *N);
735 SDValue WidenVecOp_CONCAT_VECTORS(SDNode *N);
736 SDValue WidenVecOp_EXTEND(SDNode *N);
737 SDValue WidenVecOp_EXTRACT_VECTOR_ELT(SDNode *N);
738 SDValue WidenVecOp_EXTRACT_SUBVECTOR(SDNode *N);
739 SDValue WidenVecOp_STORE(SDNode* N);
740 SDValue WidenVecOp_MSTORE(SDNode* N,
unsigned OpNo);
741 SDValue WidenVecOp_MSCATTER(SDNode* N,
unsigned OpNo);
742 SDValue WidenVecOp_SETCC(SDNode* N);
744 SDValue WidenVecOp_Convert(SDNode *N);
745 SDValue WidenVecOp_FCOPYSIGN(SDNode *N);
755 SDValue GenWidenVectorLoads(SmallVectorImpl<SDValue> &LdChain,
763 SDValue GenWidenVectorExtLoads(SmallVectorImpl<SDValue> &LdChain,
770 void GenWidenVectorStores(SmallVectorImpl<SDValue> &StChain, StoreSDNode *
ST);
776 void GenWidenVectorTruncStores(SmallVectorImpl<SDValue> &StChain,
783 SDValue ModifyToType(SDValue InOp, EVT NVT,
bool FillWithZeroes =
false);
793 void GetSplitOp(SDValue Op, SDValue &
Lo, SDValue &
Hi) {
794 if (Op.getValueType().isVector())
795 GetSplitVector(Op, Lo, Hi);
796 else if (Op.getValueType().isInteger())
797 GetExpandedInteger(Op, Lo, Hi);
799 GetExpandedFloat(Op, Lo, Hi);
804 void GetPairElements(SDValue Pair, SDValue &Lo, SDValue &Hi);
807 void SplitRes_MERGE_VALUES(SDNode *N,
unsigned ResNo,
808 SDValue &Lo, SDValue &Hi);
809 void SplitRes_SELECT (SDNode *N, SDValue &Lo, SDValue &Hi);
810 void SplitRes_SELECT_CC (SDNode *N, SDValue &Lo, SDValue &Hi);
811 void SplitRes_UNDEF (SDNode *N, SDValue &Lo, SDValue &Hi);
822 void GetExpandedOp(SDValue Op, SDValue &Lo, SDValue &Hi) {
823 if (Op.getValueType().isInteger())
824 GetExpandedInteger(Op, Lo, Hi);
826 GetExpandedFloat(Op, Lo, Hi);
832 void IntegerToVector(SDValue Op,
unsigned NumElements,
833 SmallVectorImpl<SDValue> &Ops, EVT EltVT);
836 void ExpandRes_MERGE_VALUES (SDNode *N,
unsigned ResNo,
837 SDValue &Lo, SDValue &Hi);
838 void ExpandRes_BITCAST (SDNode *N, SDValue &Lo, SDValue &Hi);
839 void ExpandRes_BUILD_PAIR (SDNode *N, SDValue &Lo, SDValue &Hi);
840 void ExpandRes_EXTRACT_ELEMENT (SDNode *N, SDValue &Lo, SDValue &Hi);
841 void ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo, SDValue &Hi);
842 void ExpandRes_NormalLoad (SDNode *N, SDValue &Lo, SDValue &Hi);
843 void ExpandRes_VAARG (SDNode *N, SDValue &Lo, SDValue &Hi);
846 SDValue ExpandOp_BITCAST (SDNode *N);
847 SDValue ExpandOp_BUILD_VECTOR (SDNode *N);
848 SDValue ExpandOp_EXTRACT_ELEMENT (SDNode *N);
849 SDValue ExpandOp_INSERT_VECTOR_ELT(SDNode *N);
850 SDValue ExpandOp_SCALAR_TO_VECTOR (SDNode *N);
851 SDValue ExpandOp_NormalStore (SDNode *N,
unsigned OpNo);
Libcall
RTLIB::Libcall enum - This enum defines all of the runtime library calls the backend can emit...
This takes an arbitrary SelectionDAG as input and hacks on it until only value types the target machi...
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
unsigned getNumValues() const
Return the number of values defined/returned by this operator.
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out...
TargetConstant* - Like Constant*, but the DAG does not do any folding, simplification, or lowering of the constant.
SDNode * getNode() const
get the SDNode which holds the desired result
LoadExtType
LoadExtType enum - This enum defines the three variants of LOADEXT (load with extension).
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library...
EVT - Extended Value Type.
LegalizeTypeAction getTypeAction(MVT VT) const
NodeIdFlags
This pass uses the NodeId on the SDNodes to hold information about the state of the node...
SelectionDAG & getDAG() const
void NoteDeletion(SDNode *Old, SDNode *New)
This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representa...
Represents one node in the SelectionDAG.
SIGN_EXTEND_INREG - This operator atomically performs a SHL/SRA pair to sign extend a small value in ...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LegalizeTypeAction
This enum indicates whether a types are legal for a target, and if not, what action should be used to...
Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation...
This file describes how to lower LLVM code to machine code.
DAGTypeLegalizer(SelectionDAG &dag)