Lines Matching refs:Lo
407 SDValue Lo, Hi;
418 case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, ResNo, Lo, Hi); break;
420 case ISD::SELECT: SplitRes_SELECT(N, Lo
421 case ISD::SELECT_CC: SplitRes_SELECT_CC(N, Lo, Hi); break;
422 case ISD::UNDEF: SplitRes_UNDEF(N, Lo, Hi); break;
423 case ISD::BITCAST: SplitVecRes_BITCAST(N, Lo, Hi); break;
424 case ISD::BUILD_VECTOR: SplitVecRes_BUILD_VECTOR(N, Lo, Hi); break;
425 case ISD::CONCAT_VECTORS: SplitVecRes_CONCAT_VECTORS(N, Lo, Hi); break;
426 case ISD::EXTRACT_SUBVECTOR: SplitVecRes_EXTRACT_SUBVECTOR(N, Lo, Hi); break;
427 case ISD::FP_ROUND_INREG: SplitVecRes_InregOp(N, Lo, Hi); break;
428 case ISD::FPOWI: SplitVecRes_FPOWI(N, Lo, Hi); break;
429 case ISD::INSERT_VECTOR_ELT: SplitVecRes_INSERT_VECTOR_ELT(N, Lo, Hi); break;
430 case ISD::SCALAR_TO_VECTOR: SplitVecRes_SCALAR_TO_VECTOR(N, Lo, Hi); break;
431 case ISD::SIGN_EXTEND_INREG: SplitVecRes_InregOp(N, Lo, Hi); break;
433 SplitVecRes_LOAD(cast<LoadSDNode>(N), Lo, Hi);
436 SplitVecRes_SETCC(N, Lo, Hi);
439 SplitVecRes_VECTOR_SHUFFLE(cast<ShuffleVectorSDNode>(N), Lo, Hi);
471 SplitVecRes_UnaryOp(N, Lo, Hi);
493 SplitVecRes_BinOp(N, Lo, Hi);
497 // If Lo/Hi is null, the sub-method took care of registering results etc.
498 if (Lo.getNode())
499 SetSplitVector(SDValue(N, ResNo), Lo, Hi);
502 void DAGTypeLegalizer::SplitVecRes_BinOp(SDNode *N, SDValue &Lo,
510 Lo = DAG.getNode(N->getOpcode(), dl, LHSLo.getValueType(), LHSLo, RHSLo);
514 void DAGTypeLegalizer::SplitVecRes_BITCAST(SDNode *N, SDValue &Lo,
539 GetExpandedOp(InOp, Lo, Hi);
541 std::swap(Lo, Hi);
542 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
550 GetSplitVector(InOp, Lo, Hi);
551 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
562 SplitInteger(BitConvertToInteger(InOp), LoIntVT, HiIntVT, Lo, Hi);
565 std::swap(Lo, Hi);
566 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
570 void DAGTypeLegalizer::SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &Lo,
577 Lo = DAG.getNode(ISD::BUILD_VECTOR, dl, LoVT, &LoOps[0], LoOps.size());
583 void DAGTypeLegalizer::SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &Lo,
589 Lo = N->getOperand(0);
598 Lo = DAG.getNode(ISD::CONCAT_VECTORS, dl, LoVT, &LoOps[0], LoOps.size());
604 void DAGTypeLegalizer::SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &Lo,
613 Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, LoVT, Vec, Idx);
619 void DAGTypeLegalizer::SplitVecRes_FPOWI(SDNode *N, SDValue &Lo,
622 GetSplitVector(N->getOperand(0), Lo, Hi);
623 Lo = DAG.getNode(ISD::FPOWI, dl, Lo.getValueType(), Lo, N->getOperand(1));
627 void DAGTypeLegalizer::SplitVecRes_InregOp(SDNode *N, SDValue &Lo,
636 Lo = DAG.getNode(N->getOpcode(), dl, LHSLo.getValueType(), LHSLo,
642 void DAGTypeLegalizer::SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &Lo,
648 GetSplitVector(Vec, Lo, Hi);
652 unsigned LoNumElts = Lo.getValueType().getVectorNumElements();
654 Lo = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
655 Lo.getValueType(), Lo, Elt, Idx);
678 // Load the Lo part from the stack slot.
679 Lo = DAG.getLoad(Lo.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
683 unsigned IncrementSize = Lo.getValueType().getSizeInBits() / 8;
692 void DAGTypeLegalizer::SplitVecRes_SCALAR_TO_VECTOR(SDNode *N, SDValue &Lo,
697 Lo = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoVT, N->getOperand(0));
701 void DAGTypeLegalizer::SplitVecRes_LOAD(LoadSDNode *LD, SDValue &Lo,
720 Lo = DAG.getLoad(ISD::UNINDEXED, ExtType, LoVT, dl, Ch, Ptr, Offset,
733 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
741 void DAGTypeLegalizer::SplitVecRes_SETCC(SDNode *N, SDValue &Lo, SDValue &Hi) {
765 Lo = DAG.getNode(N->getOpcode(), DL, LoVT, LL, RL, N->getOperand(2));
769 void DAGTypeLegalizer::SplitVecRes_UnaryOp(SDNode *N, SDValue &Lo,
783 Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InNVT, N->getOperand(0),
794 Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InNVT, InOp,
801 GetSplitVector(N->getOperand(0), Lo, Hi);
810 Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InNVT, InOp,
819 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo, N->getOperand(1));
824 SDValue STyOpLo = DAG.getValueType(Lo.getValueType());
829 Lo = DAG.getConvertRndSat(LoVT, dl, Lo, DTyOpLo, STyOpLo, RndOp, SatOp,
834 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo);
840 SDValue &Lo, SDValue &Hi) {
849 // If Lo or Hi uses elements from at most two of the four input vectors, then
851 // input elements by hand and construct the Lo/Hi output using a BUILD_VECTOR.
854 SDValue &Output = High ? Hi : Lo;
929 // Construct the Lo/Hi output using a BUILD_VECTOR.
1017 SDValue Lo, Hi;
1019 GetSplitVector(N->getOperand(0), Lo, Hi);
1020 EVT InVT = Lo.getValueType();
1025 Lo = DAG.getNode(N->getOpcode(), dl, OutVT, Lo);
1028 return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResVT, Lo, Hi);
1035 SDValue Lo, Hi;
1036 GetSplitVector(N->getOperand(0), Lo, Hi);
1037 Lo = BitConvertToInteger(Lo);
1041 std::swap(Lo, Hi);
1044 JoinIntegers(Lo, Hi));
1052 SDValue Lo, Hi;
1053 GetSplitVector(N->getOperand(0), Lo, Hi);
1055 uint64_t LoElts = Lo.getValueType().getVectorNumElements();
1061 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Lo, Idx);
1077 SDValue Lo, Hi;
1078 GetSplitVector(Vec, Lo, Hi);
1080 uint64_t LoElts = Lo.getValueType().getVectorNumElements();
1083 return SDValue(DAG.UpdateNodeOperands(N, Lo, Idx), 0);
1114 SDValue Lo, Hi;
1115 GetSplitVector(N->getOperand(1), Lo, Hi);
1123 Lo = DAG.getTruncStore(Ch, DL, Lo, Ptr, N->getPointerInfo(),
1126 Lo = DAG.getStore(Ch, DL, Lo, Ptr, N->getPointerInfo(),
1142 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
1192 SDValue Lo, Hi;
1194 GetSplitVector(N->getOperand(0), Lo, Hi);
1195 EVT InVT = Lo.getValueType();
1200 Lo = DAG.getNode(ISD::FP_ROUND, DL, OutVT, Lo, N->getOperand(1));
1203 return DAG.getNode(ISD::CONCAT_VECTORS, DL, ResVT, Lo, Hi);
