Lines Matching refs:ISD
50 case ISD::MERGE_VALUES:Res = PromoteIntRes_MERGE_VALUES(N, ResNo); break;
51 case ISD::AssertSext: Res = PromoteIntRes_AssertSext(N); break;
52 case ISD::AssertZext: Res = PromoteIntRes_AssertZext(N); break;
53 case ISD::BITCAST: Res = PromoteIntRes_BITCAST(N); break;
54 case ISD::BSWAP: Res = PromoteIntRes_BSWAP(N); break;
55 case ISD::BUILD_PAIR: Res = PromoteIntRes_BUILD_PAIR(N); break;
56 case ISD::Constant: Res = PromoteIntRes_Constant(N); break;
57 case ISD::CONVERT_RNDSAT:
59 case ISD::CTLZ_ZERO_UNDEF:
60 case ISD::CTLZ: Res = PromoteIntRes_CTLZ(N); break;
61 case ISD::CTPOP: Res = PromoteIntRes_CTPOP(N); break;
62 case ISD::CTTZ_ZERO_UNDEF:
63 case ISD::CTTZ: Res = PromoteIntRes_CTTZ(N); break;
64 case ISD::EXTRACT_VECTOR_ELT:
66 case ISD::LOAD: Res = PromoteIntRes_LOAD(cast<LoadSDNode>(N));break;
67 case ISD::SELECT: Res = PromoteIntRes_SELECT(N); break;
68 case ISD::VSELECT: Res = PromoteIntRes_VSELECT(N); break;
69 case ISD::SELECT_CC: Res = PromoteIntRes_SELECT_CC(N); break;
70 case ISD::SETCC: Res = PromoteIntRes_SETCC(N); break;
71 case ISD::SHL: Res = PromoteIntRes_SHL(N); break;
72 case ISD::SIGN_EXTEND_INREG:
74 case ISD::SRA: Res = PromoteIntRes_SRA(N); break;
75 case ISD::SRL: Res = PromoteIntRes_SRL(N); break;
76 case ISD::TRUNCATE: Res = PromoteIntRes_TRUNCATE(N); break;
77 case ISD::UNDEF: Res = PromoteIntRes_UNDEF(N); break;
78 case ISD::VAARG: Res = PromoteIntRes_VAARG(N); break;
80 case ISD::EXTRACT_SUBVECTOR:
82 case ISD::VECTOR_SHUFFLE:
84 case ISD::INSERT_VECTOR_ELT:
86 case ISD::BUILD_VECTOR:
88 case ISD::SCALAR_TO_VECTOR:
90 case ISD::CONCAT_VECTORS:
93 case ISD::SIGN_EXTEND:
94 case ISD::ZERO_EXTEND:
95 case ISD::ANY_EXTEND: Res = PromoteIntRes_INT_EXTEND(N); break;
97 case ISD::FP_TO_SINT:
98 case ISD::FP_TO_UINT: Res = PromoteIntRes_FP_TO_XINT(N); break;
100 case ISD::FP32_TO_FP16:Res = PromoteIntRes_FP32_TO_FP16(N); break;
102 case ISD::AND:
103 case ISD::OR:
104 case ISD::XOR:
105 case ISD::ADD:
106 case ISD::SUB:
107 case ISD::MUL: Res = PromoteIntRes_SimpleIntBinOp(N); break;
109 case ISD::SDIV:
110 case ISD::SREM: Res = PromoteIntRes_SDIV(N); break;
112 case ISD::UDIV:
113 case ISD::UREM: Res = PromoteIntRes_UDIV(N); break;
115 case ISD::SADDO:
116 case ISD::SSUBO: Res = PromoteIntRes_SADDSUBO(N, ResNo); break;
117 case ISD::UADDO:
118 case ISD::USUBO: Res = PromoteIntRes_UADDSUBO(N, ResNo); break;
119 case ISD::SMULO:
120 case ISD::UMULO: Res = PromoteIntRes_XMULO(N, ResNo); break;
122 case ISD::ATOMIC_LOAD:
125 case ISD::ATOMIC_LOAD_ADD:
126 case ISD::ATOMIC_LOAD_SUB:
127 case ISD::ATOMIC_LOAD_AND:
128 case ISD::ATOMIC_LOAD_OR:
129 case ISD::ATOMIC_LOAD_XOR:
130 case ISD::ATOMIC_LOAD_NAND:
131 case ISD::ATOMIC_LOAD_MIN:
132 case ISD::ATOMIC_LOAD_MAX:
133 case ISD::ATOMIC_LOAD_UMIN:
134 case ISD::ATOMIC_LOAD_UMAX:
135 case ISD::ATOMIC_SWAP:
138 case ISD::ATOMIC_CMP_SWAP:
156 return DAG.getNode(ISD::AssertSext, N->getDebugLoc(),
163 return DAG.getNode(ISD::AssertZext, N->getDebugLoc(),
220 return DAG.getNode(ISD::BITCAST, dl, NOutVT, GetPromotedInteger(InOp));
224 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, GetSoftenedFloat(InOp));
231 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT,
245 InOp = DAG.getNode(ISD::ANY_EXTEND, dl,
249 return DAG.getNode(ISD::BITCAST, dl, NOutVT, InOp);
256 return DAG.getNode(ISD::BITCAST, dl, NOutVT, GetWidenedVector(InOp));
259 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT,
270 return DAG.getNode(ISD::SRL, dl, NVT, DAG.getNode(ISD::BSWAP, dl, NVT, Op),
277 return DAG.getNode(ISD::ANY_EXTEND, N->getDebugLoc(),
289 unsigned Opc = VT.isByteSized() ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND;
298 ISD::CvtCode CvtCode = cast<CvtRndSatSDNode>(N)->getCvtCode();
299 assert ((CvtCode == ISD::CVT_SS || CvtCode == ISD::CVT_SU ||
300 CvtCode == ISD::CVT_US || CvtCode == ISD::CVT_UU ||
301 CvtCode == ISD::CVT_SF || CvtCode == ISD::CVT_UF) &&
317 return DAG.getNode(ISD::SUB, dl, NVT, Op,
325 return DAG.getNode(ISD::CTPOP, N->getDebugLoc(), Op.getValueType(), Op);
333 if (N->getOpcode() == ISD::CTTZ) {
339 Op = DAG.getNode(ISD::OR, dl, NVT, Op, DAG.getConstant(TopBit, NVT));
347 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NVT, N->getOperand(0),
360 if (N->getOpcode() == ISD::FP_TO_UINT &&
361 !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) &&
362 TLI.isOperationLegalOrCustom(ISD::FP_TO_SINT, NVT))
363 NewOpc = ISD::FP_TO_SINT;
370 return DAG.getNode(N->getOpcode() == ISD::FP_TO_UINT ?
371 ISD::AssertZext : ISD::AssertSext, dl, NVT, Res,
381 return DAG.getNode(ISD::AssertZext, dl,
398 if (N->getOpcode() == ISD::SIGN_EXTEND)
399 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
401 if (N->getOpcode() == ISD::ZERO_EXTEND)
404 assert(N->getOpcode() == ISD::ANY_EXTEND && "Unknown integer extension!");
414 assert(ISD::isUNINDEXEDLoad(N) && "Indexed load during type legalization!");
416 ISD::LoadExtType ExtType =
417 ISD::isNON_EXTLoad(N) ? ISD::EXTLOAD : N->getExtensionType();
459 unsigned Opcode = N->getOpcode() == ISD::SADDO ? ISD::ADD : ISD::SUB;
464 SDValue Ofl = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
467 Ofl = DAG.getSetCC(dl, N->getValueType(1), Ofl, Res, ISD::SETNE);
486 return DAG.getNode(ISD::SELECT, N->getDebugLoc(),
498 return DAG.getNode(ISD::VSELECT, N->getDebugLoc(),
505 return DAG.getNode(ISD::SELECT_CC, N->getDebugLoc(),
530 return DAG.getNode(ISD::TRUNCATE, dl, NVT, SetCC);
537 return DAG.getNode(ISD::SHL, N->getDebugLoc(), Res.getValueType(), Res, Amt);
542 return DAG.getNode(ISD::SIGN_EXTEND_INREG, N->getDebugLoc(),
561 return DAG.getNode(ISD::SRA, N->getDebugLoc(), Res.getValueType(), Res, Amt);
569 return DAG.getNode(ISD::SRL, N->getDebugLoc(), Res.getValueType(), Res, Amt);
601 EOp1 = DAG.getNode(ISD::TRUNCATE, dl, HalfNVT, EOp1);
602 EOp2 = DAG.getNode(ISD::TRUNCATE, dl, HalfNVT, EOp2);
604 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, EOp1, EOp2);
608 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
624 unsigned Opcode = N->getOpcode() == ISD::UADDO ? ISD::ADD : ISD::SUB;
631 Ofl = DAG.getSetCC(dl, N->getValueType(1), Ofl, Res, ISD::SETNE);
652 if (N->getOpcode() == ISD::SMULO) {
666 if (N->getOpcode() == ISD::UMULO) {
668 SDValue Hi = DAG.getNode(ISD::SRL, DL, Mul.getValueType(), Mul,
671 DAG.getConstant(0, Hi.getValueType()), ISD::SETNE);
674 SDValue SExt = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, Mul.getValueType(),
676 Overflow = DAG.getSetCC(DL, N->getValueType(1), SExt, Mul, ISD::SETNE);
681 Overflow = DAG.getNode(ISD::OR, DL, N->getValueType(1), Overflow,
725 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
727 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
729 Part = DAG.getNode(ISD::SHL, dl, NVT, Part,
732 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
765 case ISD::ANY_EXTEND: Res = PromoteIntOp_ANY_EXTEND(N); break;
766 case ISD::ATOMIC_STORE:
769 case ISD::BITCAST: Res = PromoteIntOp_BITCAST(N); break;
770 case ISD::BR_CC: Res = PromoteIntOp_BR_CC(N, OpNo); break;
771 case ISD::BRCOND: Res = PromoteIntOp_BRCOND(N, OpNo); break;
772 case ISD::BUILD_PAIR: Res = PromoteIntOp_BUILD_PAIR(N); break;
773 case ISD::BUILD_VECTOR: Res = PromoteIntOp_BUILD_VECTOR(N); break;
774 case ISD::CONCAT_VECTORS: Res = PromoteIntOp_CONCAT_VECTORS(N); break;
775 case ISD::EXTRACT_VECTOR_ELT: Res = PromoteIntOp_EXTRACT_VECTOR_ELT(N); break;
776 case ISD::CONVERT_RNDSAT:
778 case ISD::INSERT_VECTOR_ELT:
780 case ISD::MEMBARRIER: Res = PromoteIntOp_MEMBARRIER(N); break;
781 case ISD::SCALAR_TO_VECTOR:
783 case ISD::VSELECT:
784 case ISD::SELECT: Res = PromoteIntOp_SELECT(N, OpNo); break;
785 case ISD::SELECT_CC: Res = PromoteIntOp_SELECT_CC(N, OpNo); break;
786 case ISD::SETCC: Res = PromoteIntOp_SETCC(N, OpNo); break;
787 case ISD::SIGN_EXTEND: Res = PromoteIntOp_SIGN_EXTEND(N); break;
788 case ISD::SINT_TO_FP: Res = PromoteIntOp_SINT_TO_FP(N); break;
789 case ISD::STORE: Res = PromoteIntOp_STORE(cast<StoreSDNode>(N),
791 case ISD::TRUNCATE: Res = PromoteIntOp_TRUNCATE(N); break;
792 case ISD::FP16_TO_FP32:
793 case ISD::UINT_TO_FP: Res = PromoteIntOp_UINT_TO_FP(N); break;
794 case ISD::ZERO_EXTEND: Res = PromoteIntOp_ZERO_EXTEND(N); break;
796 case ISD::SHL:
797 case ISD::SRA:
798 case ISD::SRL:
799 case ISD::ROTL:
800 case ISD::ROTR: Res = PromoteIntOp_Shift(N); break;
821 ISD::CondCode CCCode) {
827 case ISD::SETEQ:
828 case ISD::SETNE:
829 case ISD::SETUGE:
830 case ISD::SETUGT:
831 case ISD::SETULE:
832 case ISD::SETULT:
839 case ISD::SETGE:
840 case ISD::SETGT:
841 case ISD::SETLT:
842 case ISD::SETLE:
851 return DAG.getNode(ISD::ANY_EXTEND, N->getDebugLoc(), N->getValueType(0), Op);
901 Hi = DAG.getNode(ISD::SHL, dl, N->getValueType(0), Hi,
903 return DAG.getNode(ISD::OR, dl, N->getValueType(0), Lo, Hi);
929 ISD::CvtCode CvtCode = cast<CvtRndSatSDNode>(N)->getCvtCode();
930 assert ((CvtCode == ISD::CVT_SS || CvtCode == ISD::CVT_SU ||
931 CvtCode == ISD::CVT_US || CvtCode == ISD::CVT_UU ||
932 CvtCode == ISD::CVT_FS || CvtCode == ISD::CVT_FU) &&
988 EVT SVT = TLI.getSetCCResultType(N->getOpcode() == ISD::SELECT ?
1027 Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op);
1028 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(),
1038 assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!");
1055 return DAG.getNode(ISD::TRUNCATE, N->getDebugLoc(), N->getValueType(0), Op);
1066 Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op);
1097 case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, ResNo, Lo, Hi); break;
1098 case ISD::SELECT: SplitRes_SELECT(N, Lo, Hi); break;
1099 case ISD::SELECT_CC: SplitRes_SELECT_CC(N, Lo, Hi); break;
1100 case ISD::UNDEF: SplitRes_UNDEF(N, Lo, Hi); break;
1102 case ISD::BITCAST: ExpandRes_BITCAST(N, Lo, Hi); break;
1103 case ISD::BUILD_PAIR: ExpandRes_BUILD_PAIR(N, Lo, Hi); break;
1104 case ISD::EXTRACT_ELEMENT: ExpandRes_EXTRACT_ELEMENT(N, Lo, Hi); break;
1105 case ISD::EXTRACT_VECTOR_ELT: ExpandRes_EXTRACT_VECTOR_ELT(N, Lo, Hi); break;
1106 case ISD::VAARG: ExpandRes_VAARG(N, Lo, Hi); break;
1108 case ISD::ANY_EXTEND: ExpandIntRes_ANY_EXTEND(N, Lo, Hi); break;
1109 case ISD::AssertSext: ExpandIntRes_AssertSext(N, Lo, Hi); break;
1110 case ISD::AssertZext: ExpandIntRes_AssertZext(N, Lo, Hi); break;
1111 case ISD::BSWAP: ExpandIntRes_BSWAP(N, Lo, Hi); break;
1112 case ISD::Constant: ExpandIntRes_Constant(N, Lo, Hi); break;
1113 case ISD::CTLZ_ZERO_UNDEF:
1114 case ISD::CTLZ: ExpandIntRes_CTLZ(N, Lo, Hi); break;
1115 case ISD::CTPOP: ExpandIntRes_CTPOP(N, Lo, Hi); break;
1116 case ISD::CTTZ_ZERO_UNDEF:
1117 case ISD::CTTZ: ExpandIntRes_CTTZ(N, Lo, Hi); break;
1118 case ISD::FP_TO_SINT: ExpandIntRes_FP_TO_SINT(N, Lo, Hi); break;
1119 case ISD::FP_TO_UINT: ExpandIntRes_FP_TO_UINT(N, Lo, Hi); break;
1120 case ISD::LOAD: ExpandIntRes_LOAD(cast<LoadSDNode>(N), Lo, Hi); break;
1121 case ISD::MUL: ExpandIntRes_MUL(N, Lo, Hi); break;
1122 case ISD::SDIV: ExpandIntRes_SDIV(N, Lo, Hi); break;
1123 case ISD::SIGN_EXTEND: ExpandIntRes_SIGN_EXTEND(N, Lo, Hi); break;
1124 case ISD::SIGN_EXTEND_INREG: ExpandIntRes_SIGN_EXTEND_INREG(N, Lo, Hi); break;
1125 case ISD::SREM: ExpandIntRes_SREM(N, Lo, Hi); break;
1126 case ISD::TRUNCATE: ExpandIntRes_TRUNCATE(N, Lo, Hi); break;
1127 case ISD::UDIV: ExpandIntRes_UDIV(N, Lo, Hi); break;
1128 case ISD::UREM: ExpandIntRes_UREM(N, Lo, Hi); break;
1129 case ISD::ZERO_EXTEND: ExpandIntRes_ZERO_EXTEND(N, Lo, Hi); break;
1130 case ISD::ATOMIC_LOAD: ExpandIntRes_ATOMIC_LOAD(N, Lo, Hi); break;
1132 case ISD::ATOMIC_LOAD_ADD:
1133 case ISD::ATOMIC_LOAD_SUB:
1134 case ISD::ATOMIC_LOAD_AND:
1135 case ISD::ATOMIC_LOAD_OR:
1136 case ISD::ATOMIC_LOAD_XOR:
1137 case ISD::ATOMIC_LOAD_NAND:
1138 case ISD::ATOMIC_LOAD_MIN:
1139 case ISD::ATOMIC_LOAD_MAX:
1140 case ISD::ATOMIC_LOAD_UMIN:
1141 case ISD::ATOMIC_LOAD_UMAX:
1142 case ISD::ATOMIC_SWAP: {
1149 case ISD::AND:
1150 case ISD::OR:
1151 case ISD::XOR: ExpandIntRes_Logical(N, Lo, Hi); break;
1153 case ISD::ADD:
1154 case ISD::SUB: ExpandIntRes_ADDSUB(N, Lo, Hi); break;
1156 case ISD::ADDC:
1157 case ISD::SUBC: ExpandIntRes_ADDSUBC(N, Lo, Hi); break;
1159 case ISD::ADDE:
1160 case ISD::SUBE: ExpandIntRes_ADDSUBE(N, Lo, Hi); break;
1162 case ISD::SHL:
1163 case ISD::SRA:
1164 case ISD::SRL: ExpandIntRes_Shift(N, Lo, Hi); break;
1166 case ISD::SADDO:
1167 case ISD
1168 case ISD::UADDO:
1169 case ISD::USUBO: ExpandIntRes_UADDSUBO(N, Lo, Hi); break;
1170 case ISD::UMULO:
1171 case ISD::SMULO: ExpandIntRes_XMULO(N, Lo, Hi); break;
1188 case ISD::ATOMIC_SWAP:
1197 case ISD::ATOMIC_CMP_SWAP:
1206 case ISD::ATOMIC_LOAD_ADD:
1215 case ISD::ATOMIC_LOAD_SUB:
1224 case ISD::ATOMIC_LOAD_AND:
1233 case ISD::ATOMIC_LOAD_OR:
1242 case ISD::ATOMIC_LOAD_XOR:
1251 case ISD::ATOMIC_LOAD_NAND:
1279 if (N->getOpcode() == ISD::SHL) {
1284 Hi = DAG.getNode(ISD::SHL, DL,
1290 TLI.isOperationLegalOrCustom(ISD::ADDC,
1295 Lo = DAG.getNode(ISD::ADDC, DL, VTList, LoOps, 2);
1297 Hi = DAG.getNode(ISD::ADDE, DL, VTList, HiOps, 3);
1299 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, ShTy));
1300 Hi = DAG.getNode(ISD::OR, DL, NVT,
1301 DAG.getNode(ISD::SHL, DL, NVT, InH,
1303 DAG.getNode(ISD::SRL, DL, NVT, InL,
1309 if (N->getOpcode() == ISD::SRL) {
1314 Lo = DAG.getNode(ISD::SRL, DL,
1321 Lo = DAG.getNode(ISD::OR, DL, NVT,
1322 DAG.getNode(ISD::SRL, DL, NVT, InL,
1324 DAG.getNode(ISD::SHL, DL, NVT, InH,
1326 Hi = DAG.getNode(ISD::SRL, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1331 assert(N->getOpcode() == ISD::SRA && "Unknown shift!");
1333 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1336 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1338 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1342 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1345 Lo = DAG.getNode(ISD::OR, DL, NVT,
1346 DAG.getNode(ISD::SRL, DL, NVT, InL,
1348 DAG.getNode(ISD::SHL, DL, NVT, InH,
1350 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1385 Amt = DAG.getNode(ISD::AND, dl, ShTy, Amt,
1390 case ISD::SHL:
1392 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1394 case ISD::SRL:
1396 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1398 case ISD::SRA:
1399 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
1401 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1412 SDValue Amt2 = DAG.getNode(ISD::XOR, dl, ShTy, Amt,
1418 case ISD::SHL: Op1 = ISD::SHL; Op2 = ISD::SRL; break;
1419 case ISD::SRL:
1420 case ISD::SRA: Op1 = ISD::SRL; Op2 = ISD::SHL; break;
1424 if (N->getOpcode() != ISD::SHL)
1434 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
1436 if (N->getOpcode() != ISD::SHL)
1461 SDValue AmtExcess = DAG.getNode(ISD::SUB, dl, ShTy, Amt, NVBitsNode);
1462 SDValue AmtLack = DAG.getNode(ISD::SUB, dl, ShTy, NVBitsNode, Amt);
1464 Amt, NVBitsNode, ISD::SETULT);
1469 case ISD::SHL:
1471 LoS = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt);
1472 HiS = DAG.getNode(ISD::OR, dl, NVT,
1473 DAG.getNode(ISD::SHL, dl, NVT, InH, Amt),
1476 DAG.getNode(ISD::SRL, dl, NVT, InL, AmtLack));
1480 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1482 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1483 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1485 case ISD::SRL:
1487 HiS = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt);
1488 LoS = DAG.getNode(ISD::OR, dl, NVT,
1489 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1492 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1496 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1498 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1499 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1501 case ISD::SRA:
1503 HiS = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt);
1504 LoS = DAG.getNode(ISD::OR, dl, NVT,
1505 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1508 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1511 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
1513 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1515 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1516 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1539 TLI.isOperationLegalOrCustom(N->getOpcode() == ISD::ADD ?
1540 ISD::ADDC : ISD::SUBC,
1545 if (N->getOpcode() == ISD::ADD) {
1546 Lo = DAG.getNode(ISD::ADDC, dl, VTList, LoOps, 2);
1548 Hi = DAG.getNode(ISD::ADDE, dl, VTList, HiOps, 3);
1550 Lo = DAG.getNode(ISD::SUBC, dl, VTList, LoOps, 2);
1552 Hi = DAG.getNode(ISD::SUBE, dl, VTList, HiOps, 3);
1557 if (N->getOpcode() == ISD::ADD) {
1558 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps, 2);
1559 Hi = DAG.getNode(ISD::ADD, dl, NVT, HiOps, 2);
1561 ISD::SETULT);
1562 SDValue Carry1 = DAG.getNode(ISD::SELECT, dl, NVT, Cmp1,
1566 ISD::SETULT);
1567 SDValue Carry2 = DAG.getNode(ISD::SELECT, dl, NVT, Cmp2,
1569 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry2);
1571 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps, 2);
1572 Hi = DAG.getNode(ISD::SUB, dl, NVT, HiOps, 2);
1575 LoOps[0], LoOps[1], ISD::SETULT);
1576 SDValue Borrow = DAG.getNode(ISD::SELECT, dl, NVT, Cmp,
1579 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
1594 if (N->getOpcode() == ISD::ADDC) {
1595 Lo = DAG.getNode(ISD::ADDC, dl, VTList, LoOps, 2);
1597 Hi = DAG.getNode(ISD::ADDE, dl, VTList, HiOps, 3);
1599 Lo = DAG.getNode(ISD::SUBC, dl, VTList, LoOps, 2);
1601 Hi = DAG.getNode(ISD::SUBE, dl, VTList, HiOps, 3);
1642 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1668 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
1672 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1674 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1689 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
1693 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1703 Lo = DAG.getNode(ISD::BSWAP, dl, Lo.getValueType(), Lo);
1704 Hi = DAG.getNode(ISD::BSWAP, dl, Hi.getValueType(), Hi);
1724 DAG.getConstant(0, NVT), ISD::SETNE);
1727 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
1729 Lo = DAG.getNode(ISD::SELECT, dl, NVT, HiNotZero, HiLZ,
1730 DAG.getNode(ISD::ADD, dl, NVT, LoLZ,
1741 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1742 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
1754 DAG.getConstant(0, NVT), ISD::SETNE);
1756 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
1759 Lo = DAG.getNode(ISD::SELECT, dl, NVT, LoNotZero, LoLZ,
1760 DAG.getNode(ISD::ADD, dl, NVT, HiLZ,
1789 if (ISD::isNormalLoad(N)) {
1794 assert(ISD::isUNINDEXEDLoad(N) && "Indexed load during type legalization!");
1800 ISD::LoadExtType ExtType = N->getExtensionType();
1818 if (ExtType == ISD::SEXTLOAD) {
1822 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1824 } else if (ExtType == ISD::ZEXTLOAD) {
1828 assert(ExtType == ISD::EXTLOAD && "Unknown extload!");
1843 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
1852 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1869 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
1872 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
1880 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1885 Lo = DAG.getNode(ISD::OR, dl, NVT, Lo,
1886 DAG.getNode(ISD::SHL, dl, NVT, Hi,
1890 Hi = DAG.getNode(ExtType == ISD::SEXTLOAD ? ISD::SRA : ISD::SRL, dl,
1918 bool HasMULHS = TLI.isOperationLegalOrCustom(ISD::MULHS, NVT);
1919 bool HasMULHU = TLI.isOperationLegalOrCustom(ISD::MULHU, NVT);
1920 bool HasSMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::SMUL_LOHI, NVT);
1921 bool HasUMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::UMUL_LOHI, NVT);
1937 Lo = DAG.getNode(ISD::UMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1943 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1944 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1952 Lo = DAG.getNode(ISD::SMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1958 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1959 Hi = DAG.getNode(ISD::MULHS, dl, NVT, LL, RL);
1965 SDValue UMulLOHI = DAG.getNode(ISD::UMUL_LOHI, dl,
1969 RH = DAG.getNode(ISD::MUL, dl, NVT, LL, RH);
1970 LH = DAG.getNode(ISD::MUL, dl, NVT, LH, RL);
1971 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1972 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
1976 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1977 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1978 RH = DAG.getNode(ISD::MUL, dl, NVT, LL, RH);
1979 LH = DAG.getNode(ISD::MUL, dl, NVT, LH, RL);
1980 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1981 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
2011 SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::SADDO ?
2012 ISD::ADD : ISD::SUB, dl, LHS.getValueType(),
2030 SDValue LHSSign = DAG.getSetCC(dl, OType, LHS, Zero, ISD::SETGE);
2031 SDValue RHSSign = DAG.getSetCC(dl, OType, RHS, Zero, ISD::SETGE);
2033 Node->getOpcode() == ISD::SADDO ?
2034 ISD::SETEQ : ISD::SETNE);
2036 SDValue SumSign = DAG.getSetCC(dl, OType, Sum, Zero, ISD::SETGE);
2037 SDValue SumSignNE = DAG.getSetCC(dl, OType, LHSSign, SumSign, ISD::SETNE);
2039 SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE);
2082 if (N->getOpcode() == ISD::SHL) {
2083 PartsOpc = ISD::SHL_PARTS;
2084 } else if (N->getOpcode() == ISD::SRL) {
2085 PartsOpc = ISD::SRL_PARTS;
2087 assert(N->getOpcode() == ISD::SRA && "Unknown shift!");
2088 PartsOpc = ISD::SRA_PARTS;
2122 if (N->getOpcode() == ISD::SHL) {
2132 } else if (N->getOpcode() == ISD::SRL) {
2143 assert(N->getOpcode() == ISD::SRA && "Unknown shift!");
2172 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2175 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2190 Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Hi.getValueType(), Hi,
2204 Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Lo.getValueType(), Lo,
2209 Hi = DAG.getNode(ISD::SRA, dl, Hi.getValueType(), Lo,
2217 Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Hi.getValueType(), Hi,
2247 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2248 Hi = DAG.getNode(ISD::SRL, dl,
2251 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
2262 SDValue Sum = DAG.getNode(N->getOpcode() == ISD::UADDO ?
2263 ISD::ADD : ISD::SUB, dl, LHS.getValueType(),
2270 N->getOpcode () == ISD::UADDO ?
2271 ISD::SETULT : ISD::SETUGT);
2283 if (N->getOpcode() == ISD::UMULO) {
2286 SDValue MUL = DAG.getNode(ISD::MUL, dl, LHS.getValueType(), LHS, RHS);
2292 RHS, DAG.getConstant(0, VT), ISD::SETEQ);
2293 SDValue NotZero = DAG.getNode(ISD::SELECT, dl, VT, isZero,
2295 SDValue DIV = DAG.getNode(ISD::UDIV, dl, VT, MUL, NotZero);
2297 ISD::SETNE);
2298 Overflow = DAG.getNode(ISD::SELECT, dl, N->getValueType(1), isZero,
2358 ISD::SETNE);
2410 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2436 SDValue Swap = DAG.getAtomic(ISD::ATOMIC_CMP_SWAP, dl, VT,
2469 case ISD::BITCAST: Res = ExpandOp_BITCAST(N); break;
2470 case ISD::BR_CC: Res = ExpandIntOp_BR_CC(N); break;
2471 case ISD::BUILD_VECTOR: Res = ExpandOp_BUILD_VECTOR(N); break;
2472 case ISD::EXTRACT_ELEMENT: Res = ExpandOp_EXTRACT_ELEMENT(N); break;
2473 case ISD::INSERT_VECTOR_ELT: Res = ExpandOp_INSERT_VECTOR_ELT(N); break;
2474 case ISD::SCALAR_TO_VECTOR: Res = ExpandOp_SCALAR_TO_VECTOR(N); break;
2475 case ISD::SELECT_CC: Res = ExpandIntOp_SELECT_CC(N); break;
2476 case ISD::SETCC: Res = ExpandIntOp_SETCC(N); break;
2477 case ISD::SINT_TO_FP: Res = ExpandIntOp_SINT_TO_FP(N); break;
2478 case ISD::STORE: Res = ExpandIntOp_STORE(cast<StoreSDNode>(N), OpNo); break;
2479 case ISD::TRUNCATE: Res = ExpandIntOp_TRUNCATE(N); break;
2480 case ISD::UINT_TO_FP: Res = ExpandIntOp_UINT_TO_FP(N); break;
2482 case ISD::SHL:
2483 case ISD::SRA:
2484 case ISD::SRL:
2485 case ISD::ROTL:
2486 case ISD::ROTR: Res = ExpandIntOp_Shift(N); break;
2487 case ISD::RETURNADDR:
2488 case ISD::FRAMEADDR: Res = ExpandIntOp_RETURNADDR(N); break;
2490 case ISD::ATOMIC_STORE: Res = ExpandIntOp_ATOMIC_STORE(N); break;
2512 ISD::CondCode &CCCode,
2518 if (CCCode == ISD::SETEQ || CCCode == ISD::SETNE) {
2523 NewLHS = DAG.getNode(ISD::AND, dl,
2531 NewLHS = DAG.getNode(ISD::XOR, dl, LHSLo.getValueType(), LHSLo, RHSLo);
2532 NewRHS = DAG.getNode(ISD::XOR, dl, LHSLo.getValueType(), LHSHi, RHSHi);
2533 NewLHS = DAG.getNode(ISD::OR, dl, NewLHS.getValueType(), NewLHS, NewRHS);
2541 if ((CCCode == ISD::SETLT && CST->isNullValue()) || // X < 0
2542 (CCCode == ISD::SETGT && CST->isAllOnesValue())) { // X > -1
2549 ISD::CondCode LowCC;
2552 case ISD::SETLT:
2553 case ISD::SETULT: LowCC = ISD::SETULT; break;
2554 case ISD::SETGT:
2555 case ISD::SETUGT: LowCC = ISD::SETUGT; break;
2556 case ISD::SETLE:
2557 case ISD::SETULE: LowCC = ISD::SETULE; break;
2558 case ISD::SETGE:
2559 case ISD::SETUGE: LowCC = ISD::SETUGE; break;
2578 Tmp2 = DAG.getNode(ISD::SETCC, dl,
2586 (CCCode == ISD::SETLE || CCCode == ISD::SETGE ||
2587 CCCode == ISD::SETUGE || CCCode == ISD::SETULE)) ||
2589 (CCCode == ISD::SETLT || CCCode == ISD::SETGT ||
2590 CCCode == ISD::SETUGT || CCCode == ISD::SETULT))) {
2600 LHSHi, RHSHi, ISD::SETEQ, false,
2604 LHSHi, RHSHi, ISD::SETEQ);
2605 NewLHS = DAG.getNode(ISD::SELECT, dl, Tmp1.getValueType(),
2612 ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(1))->get();
2619 CCCode = ISD::SETNE;
2630 ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(4))->get();
2637 CCCode = ISD::SETNE;
2648 ISD::CondCode CCCode = cast<CondCodeSDNode>(N->getOperand(2))->get();
2691 if (ISD::isNormalStore(N))
2694 assert(ISD::isUNINDEXEDStore(N) && "Indexed store during type legalization!");
2729 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
2735 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
2751 Hi = DAG.getNode(ISD::SHL, dl, NVT, Hi,
2754 Hi = DAG.getNode(ISD::OR, dl, NVT, Hi,
2755 DAG.getNode(ISD::SRL, dl, NVT, Lo,
2765 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
2773 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
2780 return DAG.getNode(ISD::TRUNCATE, N->getDebugLoc(), N->getValueType(0), InL);
2794 TLI.getOperationAction(ISD::SINT_TO_FP, SrcVT) == TargetLowering::Custom){
2796 SDValue SignedConv = DAG.getNode(ISD::SINT_TO_FP, dl, DstVT, Op);
2823 ISD::SETLT);
2834 SDValue Offset = DAG.getNode(ISD::SELECT, dl, Zero.getValueType(), SignSet,
2837 FudgePtr = DAG.getNode(ISD::ADD, dl, TLI.getPointerTy(), FudgePtr, Offset);
2842 SDValue Fudge = DAG.getExtLoad(ISD::EXTLOAD, dl, DstVT, DAG.getEntryNode(),
2847 return DAG.getNode(ISD::FADD, dl, DstVT, SignedConv, Fudge);
2859 SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
2888 SDValue Index = DAG.getNode(ISD::ADD, dl, BaseIdx.getValueType(),
2890 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
2893 SDValue Op = DAG.getNode(ISD::ANY_EXTEND, dl, NOutVTElem, Ext);
2898 return DAG.getNode(ISD::BUILD_VECTOR, dl, NOutVT, &Ops[0], Ops.size());
2933 SDValue Op = DAG.getNode(ISD::ANY_EXTEND, dl, NOutVTElem, N->getOperand(i));
2937 return DAG.getNode(ISD::BUILD_VECTOR, dl, NOutVT, &Ops[0], Ops.size());
2952 SDValue Op = DAG.getNode(ISD::ANY_EXTEND, dl, NOutVTElem, N->getOperand(0));
2954 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NOutVT, Op);
2978 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
2980 Ops[i * NumElem + j] = DAG.getNode(ISD::ANY_EXTEND, dl, OutElemTy, Ext);
2984 return DAG.getNode(ISD::BUILD_VECTOR, dl, NOutVT, &Ops[0], Ops.size());
2997 SDValue ConvElem = DAG.getNode(ISD::ANY_EXTEND, dl,
2999 return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NOutVT,
3007 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
3033 SDValue Ex = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SclrTy,
3035 SDValue Tr = DAG.getNode(ISD::TRUNCATE, dl, RetSclrTy, Ex);
3040 return DAG.getNode(ISD::BUILD_VECTOR, dl, N->getValueType(0),
