Cross Reference: /external/llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

Lines Matching refs:Lo
573   SDValue Lo, Hi;
589   case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, ResNo, Lo, Hi); break;
591   case ISD::SELECT:       SplitRes_SELECT(N, Lo, Hi); break;
592   case ISD::SELECT_CC:    SplitRes_SELECT_CC(N, Lo, Hi); break;
593   case ISD::UNDEF:        SplitRes_UNDEF(N, Lo, Hi); break;
594   case ISD::BITCAST:           SplitVecRes_BITCAST(N, Lo, Hi); break;
595   case ISD::BUILD_VECTOR:      SplitVecRes_BUILD_VECTOR(N, Lo, Hi); break;
596   case ISD::CONCAT_VECTORS:    SplitVecRes_CONCAT_VECTORS(N, Lo, Hi); break;
597   case ISD::EXTRACT_SUBVECTOR: SplitVecRes_EXTRACT_SUBVECTOR(N, Lo, Hi); break;
598   case ISD::INSERT_SUBVECTOR:  SplitVecRes_INSERT_SUBVECTOR(N, Lo, Hi); break;
599   case ISD::FP_ROUND_INREG:    SplitVecRes_InregOp(N, Lo, Hi); break;
600   case ISD::FPOWI:             SplitVecRes_FPOWI(N, Lo, Hi); break;
601   case ISD::FCOPYSIGN:         SplitVecRes_FCOPYSIGN(N, Lo, Hi); break;
602   case ISD::INSERT_VECTOR_ELT: SplitVecRes_INSERT_VECTOR_ELT(N, Lo, Hi); break;
603   case ISD::SCALAR_TO_VECTOR:  SplitVecRes_SCALAR_TO_VECTOR(N, Lo, Hi); break;
604   case ISD::SIGN_EXTEND_INREG: SplitVecRes_InregOp(N, Lo, Hi); break;
606     SplitVecRes_LOAD(cast<LoadSDNode>(N), Lo, Hi);
609     SplitVecRes_MLOAD(cast<MaskedLoadSDNode>(N), Lo, Hi);
612     SplitVecRes_MGATHER(cast<MaskedGatherSDNode>(N), Lo, Hi);
615     SplitVecRes_SETCC(N, Lo, Hi);
618     SplitVecRes_VECTOR_SHUFFLE(cast<ShuffleVectorSDNode>(N), Lo, Hi);
624     SplitVecRes_ExtVecInRegOp(N, Lo, Hi);
658     SplitVecRes_UnaryOp(N, Lo, Hi);
664     SplitVecRes_ExtendOp(N, Lo, Hi);
696     SplitVecRes_BinOp(N, Lo, Hi);
699     SplitVecRes_TernaryOp(N, Lo, Hi);
703   // If Lo/Hi is null, the sub-method took care of registering results etc.
704   if (Lo.getNode())
705     SetSplitVector(SDValue(N, ResNo), Lo, Hi);
708 void DAGTypeLegalizer::SplitVecRes_BinOp(SDNode *N, SDValue &Lo,
718   Lo = DAG.getNode(Opcode, dl, LHSLo.getValueType(), LHSLo, RHSLo, Flags);
722 void DAGTypeLegalizer::SplitVecRes_TernaryOp(SDNode *N, SDValue &Lo,
732   Lo = DAG.getNode(N->getOpcode(), dl, Op0Lo.getValueType(),
738 void DAGTypeLegalizer::SplitVecRes_BITCAST(SDNode *N, SDValue &Lo,
764       GetExpandedOp(InOp, Lo, Hi);
766         std::swap(Lo, Hi);
767       Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
775     GetSplitVector(InOp, Lo, Hi);
776     Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
787   SplitInteger(BitConvertToInteger(InOp), LoIntVT, HiIntVT, Lo, Hi);
790     std::swap(Lo, Hi);
791   Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
795 void DAGTypeLegalizer::SplitVecRes_BUILD_VECTOR(SDNode *N, SDValue &Lo,
802   Lo = DAG.getNode(ISD::BUILD_VECTOR, dl, LoVT, LoOps);
808 void DAGTypeLegalizer::SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &Lo,
814     Lo = N->getOperand(0);
823   Lo = DAG.getNode(ISD::CONCAT_VECTORS, dl, LoVT, LoOps);
829 void DAGTypeLegalizer::SplitVecRes_EXTRACT_SUBVECTOR(SDNode *N, SDValue &Lo,
838   Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, LoVT, Vec, Idx);
845 void DAGTypeLegalizer::SplitVecRes_INSERT_SUBVECTOR(SDNode *N, SDValue &Lo,
851   GetSplitVector(Vec, Lo, Hi);
869       Lo = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, LoVT, Lo, SubVec, Idx);
886   // Load the Lo part from the stack slot.
887   Lo = DAG.getLoad(Lo.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
891   unsigned IncrementSize = Lo.getValueType().getSizeInBits() / 8;
901 void DAGTypeLegalizer::SplitVecRes_FPOWI(SDNode *N, SDValue &Lo,
904   GetSplitVector(N->getOperand(0), Lo, Hi);
905   Lo = DAG.getNode(ISD::FPOWI, dl, Lo.getValueType(), Lo, N->getOperand(1));
909 void DAGTypeLegalizer::SplitVecRes_FCOPYSIGN(SDNode *N, SDValue &Lo,
924   Lo = DAG.getNode(ISD::FCOPYSIGN, DL, LHSLo.getValueType(), LHSLo, RHSLo);
928 void DAGTypeLegalizer::SplitVecRes_InregOp(SDNode *N, SDValue &Lo,
938   Lo = DAG.getNode(N->getOpcode(), dl, LHSLo.getValueType(), LHSLo,
944 void DAGTypeLegalizer::SplitVecRes_ExtVecInRegOp(SDNode *N, SDValue &Lo,
973   Lo = DAG.getNode(Opcode, dl, OutLoVT, InLo);
977 void DAGTypeLegalizer::SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &Lo,
983   GetSplitVector(Vec, Lo, Hi);
987     unsigned LoNumElts = Lo.getValueType().getVectorNumElements();
989       Lo = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
990                        Lo.getValueType(), Lo, Elt, Idx);
1018   // Load the Lo part from the stack slot.
1019   Lo = DAG.getLoad(Lo.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
1023   unsigned IncrementSize = Lo.getValueType().getSizeInBits() / 8;
1033 void DAGTypeLegalizer::SplitVecRes_SCALAR_TO_VECTOR(SDNode *N, SDValue &Lo,
1038   Lo = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoVT, N->getOperand(0));
1042 void DAGTypeLegalizer::SplitVecRes_LOAD(LoadSDNode *LD, SDValue &Lo,
1063   Lo = DAG.getLoad(ISD::UNINDEXED, ExtType, LoVT, dl, Ch, Ptr, Offset,
1077   Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1086                                          SDValue &Lo, SDValue &Hi) {
1126   Lo = DAG.getMaskedLoad(LoVT, dl, Ch, Ptr, MaskLo, Src0Lo, LoMemVT, MMO,
1144   Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1154                                          SDValue &Lo, SDValue &Hi) {
1196   Lo = DAG.getMaskedGather(DAG.getVTList(LoVT, MVT::Other), LoVT, dl, OpsLo,
1205   Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1214 void DAGTypeLegalizer::SplitVecRes_SETCC(SDNode *N, SDValue &Lo, SDValue &Hi) {
1228   Lo = DAG.getNode(N->getOpcode(), DL, LoVT, LL, RL, N->getOperand(2));
1232 void DAGTypeLegalizer::SplitVecRes_UnaryOp(SDNode *N, SDValue &Lo,
1243     GetSplitVector(N->getOperand(0), Lo, Hi);
1245     std::tie(Lo, Hi) = DAG.SplitVectorOperand(N, 0);
1248     Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo, N->getOperand(1));
1253     SDValue STyOpLo = DAG.getValueType(Lo.getValueType());
1258     Lo = DAG.getConvertRndSat(LoVT, dl, Lo, DTyOpLo, STyOpLo, RndOp, SatOp,
1263     Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo);
1268 void DAGTypeLegalizer::SplitVecRes_ExtendOp(SDNode *N, SDValue &Lo,
1309       std::tie(Lo, Hi) = DAG.SplitVector(NewSrc, dl);
1311       Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo);
1317   SplitVecRes_UnaryOp(N, Lo, Hi);
1321                                                   SDValue &Lo, SDValue &Hi) {
1330   // If Lo or Hi uses elements from at most two of the four input vectors, then
1332   // input elements by hand and construct the Lo/Hi output using a BUILD_VECTOR.
1335     SDValue &Output = High ? Hi : Lo;
1411       // Construct the Lo/Hi output using a BUILD_VECTOR.
1538   SDValue Lo, Hi;
1539   GetSplitVector(N->getOperand(0), Lo, Hi);
1540   assert(Lo.getValueType() == Hi.getValueType() &&
1541          "Lo and Hi have differing types");
1563   SDValue Lo, Hi;
1565   GetSplitVector(N->getOperand(0), Lo, Hi);
1566   EVT InVT = Lo.getValueType();
1571   Lo = DAG.getNode(N->getOpcode(), dl, OutVT, Lo);
1574   return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResVT, Lo, Hi);
1581   SDValue Lo, Hi;
1582   GetSplitVector(N->getOperand(0), Lo, Hi);
1583   Lo = BitConvertToInteger(Lo);
1587     std::swap(Lo, Hi);
1590                      JoinIntegers(Lo, Hi));
1598   SDValue Lo, Hi;
1599   GetSplitVector(N->getOperand(0), Lo, Hi);
1601   uint64_t LoElts = Lo.getValueType().getVectorNumElements();
1607     return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Lo, Idx);
1624     SDValue Lo, Hi;
1625     GetSplitVector(Vec, Lo, Hi);
1627     uint64_t LoElts = Lo.getValueType().getVectorNumElements();
1630       return SDValue(DAG.UpdateNodeOperands(N, Lo, Idx), 0);
1711   SDValue Lo = DAG.getMaskedGather(DAG.getVTList(LoVT, MVT::Other), LoVT, dl,
1726   Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1733   SDValue Res = DAG.getNode(ISD::CONCAT_VECTORS, dl, MGT->getValueType(0), Lo,
1775   SDValue Lo, Hi;
1781   Lo = DAG.getMaskedStore(Ch, DL, DataLo, Ptr, MaskLo, LoMemVT, MMO,
1798   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
1836   SDValue Lo, Hi;
1843   Lo = DAG.getMaskedScatter(DAG.getVTList(MVT::Other), DataLo.getValueType(),
1857   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
1873   SDValue Lo, Hi;
1874   GetSplitVector(N->getOperand(1), Lo, Hi);
1882     Lo = DAG.getTruncStore(Ch, DL, Lo, Ptr, N->getPointerInfo(),
1885     Lo = DAG.getStore(Ch, DL, Lo, Ptr, N->getPointerInfo(),
1901   return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
2013   SDValue Lo, Hi;
2015   GetSplitVector(N->getOperand(0), Lo, Hi);
2016   EVT InVT = Lo.getValueType();
2021   Lo = DAG.getNode(ISD::FP_ROUND, DL, OutVT, Lo, N->getOperand(1));
2024   return DAG.getNode(ISD::CONCAT_VECTORS, DL, ResVT, Lo, Hi);