CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

479   SDValue Lo, Hi;
495   case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, ResNo, Lo, Hi); break;
497   case ISD::SELECT:       SplitRes_SELECT(N, Lo, Hi); break;
498   case ISD::SELECT_CC:    SplitRes_SELECT_CC(N, Lo, Hi); break;
499   case ISD::UNDEF:        SplitRes_UNDEF(N, Lo, Hi); break;
500   case ISD::BITCAST:           SplitVecRes_BITCAST(N, Lo, Hi); break;
501   case ISD::BUILD_VECTOR:      SplitVecRes_BUILD_VECTOR(N, Lo, Hi); break;
502   case ISD::CONCAT_VECTORS:    SplitVecRes_CONCAT_VECTORS(N, Lo, Hi); break;
503   case ISD::EXTRACT_SUBVECTOR: SplitVecRes_EXTRACT_SUBVECTOR(N, Lo, Hi); break;
504   case ISD::FP_ROUND_INREG:    SplitVecRes_InregOp(N, Lo, Hi); break;
505   case ISD::FPOWI:             SplitVecRes_FPOWI(N, Lo, Hi); break;
506   case ISD::INSERT_VECTOR_ELT: SplitVecRes_INSERT_VECTOR_ELT(N, Lo, Hi); break;
507   case ISD::SCALAR_TO_VECTOR:  SplitVecRes_SCALAR_TO_VECTOR(N, Lo, Hi); break;
508   case ISD::SIGN_EXTEND_INREG: SplitVecRes_InregOp(N, Lo, Hi); break;
510     SplitVecRes_LOAD(cast<LoadSDNode>(N), Lo, Hi);
513     SplitVecRes_SETCC(N, Lo, Hi);
516     SplitVecRes_VECTOR_SHUFFLE(cast<ShuffleVectorSDNode>(N), Lo, Hi);
550     SplitVecRes_UnaryOp(N, Lo, Hi);
572     SplitVecRes_BinOp(N, Lo, Hi);
575     SplitVecRes_TernaryOp(N, Lo, Hi);
579   // If Lo/Hi is null, the sub-method took care of registering results etc.
581     SetSplitVector(SDValue(N, ResNo), Lo, Hi);
585                                          SDValue &Hi) {
593   Hi = DAG.getNode(N->getOpcode(), dl, LHSHi.getValueType(), LHSHi, RHSHi);
597                                              SDValue &Hi) {
608   Hi = DAG.getNode(N->getOpcode(), dl, Op0Hi.getValueType(),
613                                            SDValue &Hi) {
637       GetExpandedOp(InOp, Lo, Hi);
639         std::swap(Lo, Hi);
641       Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
648     GetSplitVector(InOp, Lo, Hi);
650     Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
660   SplitInteger(BitConvertToInteger(InOp), LoIntVT, HiIntVT, Lo, Hi);
663     std::swap(Lo, Hi);
665   Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
669                                                 SDValue &Hi) {
678   Hi = DAG.getNode(ISD::BUILD_VECTOR, dl, HiVT, &HiOps[0], HiOps.size());
682                                                   SDValue &Hi) {
688     Hi = N->getOperand(1);
699   Hi = DAG.getNode(ISD::CONCAT_VECTORS, dl, HiVT, &HiOps[0], HiOps.size());
703                                                      SDValue &Hi) {
713   Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, HiVT, Vec,
718                                          SDValue &Hi) {
720   GetSplitVector(N->getOperand(0), Lo, Hi);
722   Hi = DAG.getNode(ISD::FPOWI, dl, Hi.getValueType(), Hi, N->getOperand(1));
726                                            SDValue &Hi) {
736   Hi = DAG.getNode(N->getOpcode(), dl, LHSHi.getValueType(), LHSHi,
741                                                      SDValue &Hi) {
746   GetSplitVector(Vec, Lo, Hi);
755       Hi = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, Hi.getValueType(), Hi, Elt,
785   // Load the Hi part from the stack slot.
786   Hi = DAG.getLoad(Hi.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
791                                                     SDValue &Hi) {
796   Hi = DAG.getUNDEF(HiVT);
800                                         SDValue &Hi) {
826   Hi = DAG.getLoad(ISD::UNINDEXED, ExtType, HiVT, dl, Ch, Ptr, Offset,
833                    Hi.getValue(1));
840 void DAGTypeLegalizer::SplitVecRes_SETCC(SDNode *N, SDValue &Lo, SDValue &Hi) {
865   Hi = DAG.getNode(N->getOpcode(), DL, HiVT, LH, RH, N->getOperand(2));
869                                            SDValue &Hi) {
879     GetSplitVector(N->getOperand(0), Lo, Hi);
885     Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InNVT, N->getOperand(0),
891     Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi, N->getOperand(1));
896     SDValue STyOpHi = DAG.getValueType(Hi.getValueType());
902     Hi = DAG.getConvertRndSat(HiVT, dl, Hi, DTyOpHi, STyOpHi, RndOp, SatOp,
906     Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi);
911                                                   SDValue &Lo, SDValue &Hi) {
920   // If Lo or Hi uses elements from at most two of the four input vectors, then
922   // input elements by hand and construct the Lo/Hi output using a BUILD_VECTOR.
925     SDValue &Output = High ? Hi : Lo;
1000       // Construct the Lo/Hi output using a BUILD_VECTOR.
1101   SDValue Lo, Hi;
1102   GetSplitVector(N->getOperand(0), Lo, Hi);
1103   assert(Lo.getValueType() == Hi.getValueType() &&
1104          "Lo and Hi have differing types");;
1107   unsigned HiNumElts = Hi.getValueType().getVectorNumElements();
1144   SDValue Lo, Hi;
1146   GetSplitVector(N->getOperand(0), Lo, Hi);
1153   Hi = DAG.getNode(N->getOpcode(), dl, OutVT, Hi);
1155   return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResVT, Lo, Hi);
1162   SDValue Lo, Hi;
1163   GetSplitVector(N->getOperand(0), Lo, Hi);
1165   Hi = BitConvertToInteger(Hi);
1168     std::swap(Lo, Hi);
1171                      JoinIntegers(Lo, Hi));
1179   SDValue Lo, Hi;
1180   GetSplitVector(N->getOperand(0), Lo, Hi);
1190     return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Hi,
1204     SDValue Lo, Hi;
1205     GetSplitVector(Vec, Lo, Hi);
1211     return SDValue(DAG.UpdateNodeOperands(N, Hi,
1241   SDValue Lo, Hi;
1242   GetSplitVector(N->getOperand(1), Lo, Hi);
1261     Hi = DAG.getTruncStore(Ch, DL, Hi, Ptr,
1265     Hi = DAG.getStore(Ch, DL, Hi, Ptr,
1269   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
1379   SDValue Lo, Hi;
1381   GetSplitVector(N->getOperand(0), Lo, Hi);
1388   Hi = DAG.getNode(ISD::FP_ROUND, DL, OutVT, Hi, N->getOperand(1));
1390   return DAG.getNode(ISD::CONCAT_VECTORS, DL, ResVT, Lo, Hi);