Lines Matching refs:SDValue
217 SDValue
218 HexagonTargetLowering::getInt(unsigned IntId, MVT ResTy, ArrayRef<SDValue> Ops,
220 SmallVector<SDValue,4> IntOps;
222 for (const SDValue &Op : Ops)
259 SDValue
260 HexagonTargetLowering::opCastElem(SDValue Vec, MVT ElemTy,
268 SDValue
276 HexagonTargetLowering::opSplit(SDValue Vec, const SDLoc &dl,
327 SDValue
328 HexagonTargetLowering::convertToByteIndex(SDValue ElemIdx, MVT ElemTy,
343 SDValue
344 HexagonTargetLowering::getIndexInWord32(SDValue Idx, MVT ElemTy,
354 SDValue Mask = DAG.getConstant(32/ElemWidth - 1, dl, MVT::i32);
355 SDValue SubIdx = DAG.getNode(ISD::AND, dl, MVT::i32, {Idx, Mask});
359 SDValue
360 HexagonTargetLowering::getByteShuffle(const SDLoc &dl, SDValue Op0,
361 SDValue Op1, ArrayRef<int> Mask,
390 SDValue
391 HexagonTargetLowering::buildHvxVectorReg(ArrayRef<SDValue> Values,
402 SmallVector<SDValue,32> Words;
409 SDValue W = buildVector32(Values.slice(i, OpsPerWord), dl, PartVT, DAG);
418 SDValue SplatV;
447 SDValue CP =
460 auto IsBuildFromExtracts = [this,&Values] (SDValue &SrcVec,
462 SDValue Vec;
463 for (SDValue V : Values) {
471 SDValue T = V.getOperand(0);
487 SDValue ExtVec;
515 SDValue S = DAG.getVectorShuffle(ExtTy, dl, ExtVec,
525 SDValue HalfV0 = getInstr(Hexagon::V6_vd0, dl, VecTy, {}, DAG);
526 SDValue HalfV1 = getInstr(Hexagon::V6_vd0, dl, VecTy, {}, DAG);
527 SDValue S = DAG.getConstant(4, dl, MVT::i32);
529 SDValue N = DAG.getNode(HexagonISD::VINSERTW0, dl, VecTy,
531 SDValue M = DAG.getNode(HexagonISD::VINSERTW0, dl, VecTy,
539 SDValue DstV = DAG.getNode(ISD::OR, dl, VecTy, {HalfV0, HalfV1});
543 SDValue
544 HexagonTargetLowering::createHvxPrefixPred(SDValue PredV, const SDLoc &dl,
559 SDValue T = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, PredV);
570 SDValue S = DAG.getVectorShuffle(ByteTy, dl, T, DAG.getUNDEF(ByteTy), Mask);
575 SDValue Q = getInstr(Hexagon::V6_pred_scalar2, dl, BoolTy,
577 SDValue M = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, Q);
585 SmallVector<SDValue,4> Words[2];
588 auto Lo32 = [&DAG, &dl] (SDValue P) {
591 auto Hi32 = [&DAG, &dl] (SDValue P) {
595 SDValue W0 = isUndef(PredV)
606 for (const SDValue &W : Words[IdxW ^ 1]) {
607 SDValue T = expandPredicate(W, dl, DAG);
612 for (const SDValue &W : Words[IdxW ^ 1]) {
622 SDValue Vec = ZeroFill ? getZero(dl, ByteTy, DAG) : DAG.getUNDEF(ByteTy);
623 SDValue S4 = DAG.getConstant(HwLen-4, dl, MVT::i32);
624 for (const SDValue &W : Words[IdxW]) {
632 SDValue
633 HexagonTargetLowering::buildHvxVectorPred(ArrayRef<SDValue> Values,
641 SmallVector<SDValue,128> Bytes;
644 auto IsTrue = [] (SDValue V) {
649 auto IsFalse = [] (SDValue V) {
661 for (SDValue V : Values) {
665 SDValue Ext = !V.isUndef() ? DAG.getZExtOrTrunc(V, dl, MVT::i8)
681 SDValue F = Values[I+B];
685 SDValue Ext = (B < 8) ? DAG.getZExtOrTrunc(F, dl, MVT::i8)
701 SDValue ByteVec = buildHvxVectorReg(Bytes, dl, ByteTy, DAG);
705 SDValue
706 HexagonTargetLowering::extractHvxElementReg(SDValue VecV, SDValue IdxV,
714 SDValue ByteIdx = convertToByteIndex(IdxV, ElemTy, DAG);
715 SDValue ExWord = DAG.getNode(HexagonISD::VEXTRACTW, dl, MVT::i32,
723 SDValue SubIdx = getIndexInWord32(IdxV, ElemTy, DAG);
725 SDValue ExVec = DAG.getBitcast(tyVector(ty(ExWord), ElemTy), ExWord);
729 SDValue
730 HexagonTargetLowering::extractHvxElementPred(SDValue VecV, SDValue IdxV,
737 SDValue ByteVec = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, VecV);
740 SDValue ScV = DAG.getConstant(Scale, dl, MVT::i32);
743 SDValue ExtB = extractHvxElementReg(ByteVec, IdxV, dl, MVT::i32, DAG);
744 SDValue Zero = DAG.getTargetConstant(0, dl, MVT::i32);
748 SDValue
749 HexagonTargetLowering::insertHvxElementReg(SDValue VecV, SDValue IdxV,
750 SDValue ValV, const SDLoc &dl, SelectionDAG &DAG) const {
757 auto InsertWord = [&DAG,&dl,this] (SDValue VecV, SDValue ValV,
758 SDValue ByteIdxV) {
761 SDValue MaskV = DAG.getNode(ISD::AND, dl, MVT::i32,
763 SDValue RotV = DAG.getNode(HexagonISD::VROR, dl, VecTy, {VecV, MaskV});
764 SDValue InsV = DAG.getNode(HexagonISD::VINSERTW0, dl, VecTy, {RotV, ValV});
765 SDValue SubV = DAG.getNode(ISD::SUB, dl, MVT::i32,
767 SDValue TorV = DAG.getNode(HexagonISD::VROR, dl, VecTy, {InsV, SubV});
771 SDValue ByteIdx = convertToByteIndex(IdxV, ElemTy, DAG);
777 SDValue WordIdx = DAG.getNode(ISD::SRL, dl, MVT::i32,
779 SDValue Ext = extractHvxElementReg(opCastElem(VecV, MVT::i32, DAG), WordIdx,
784 SDValue SubIdx = getIndexInWord32(IdxV, ElemTy, DAG);
786 SDValue Ins = insertVector(DAG.getBitcast(SubVecTy, Ext),
793 SDValue
794 HexagonTargetLowering::insertHvxElementPred(SDValue VecV, SDValue IdxV,
795 SDValue ValV, const SDLoc &dl, SelectionDAG &DAG) const {
798 SDValue ByteVec = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, VecV);
801 SDValue ScV = DAG.getConstant(Scale, dl, MVT::i32);
805 SDValue InsV = insertHvxElementReg(ByteVec, IdxV, ValV, dl, DAG);
809 SDValue
810 HexagonTargetLowering::extractHvxSubvectorReg(SDValue VecV, SDValue IdxV,
840 SDValue WordVec = DAG.getBitcast(WordTy, VecV);
843 SDValue W0Idx = DAG.getConstant(WordIdx, dl, MVT::i32);
844 SDValue W0 = extractHvxElementReg(WordVec, W0Idx, dl, MVT::i32, DAG);
848 SDValue W1Idx = DAG.getConstant(WordIdx+1, dl, MVT::i32);
849 SDValue W1 = extractHvxElementReg(WordVec, W1Idx, dl, MVT::i32, DAG);
850 SDValue WW = DAG.getNode(HexagonISD::COMBINE, dl, MVT::i64, {W1, W0});
854 SDValue
855 HexagonTargetLowering::extractHvxSubvectorPred(SDValue VecV, SDValue IdxV,
860 SDValue ByteVec = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, VecV);
867 SDValue Undef = DAG.getUNDEF(ByteTy);
881 SDValue ShuffV = DAG.getVectorShuffle(ByteTy, dl, ByteVec, Undef, Mask);
906 SDValue Zero = getZero(dl, MVT::i32, DAG);
907 SDValue ShuffV = DAG.getVectorShuffle(ByteTy, dl, ByteVec, Undef, Mask);
910 SDValue W0 = DAG.getNode(HexagonISD::VEXTRACTW, dl, MVT::i32, {ShuffV, Zero});
911 SDValue W1 = DAG.getNode(HexagonISD::VEXTRACTW, dl, MVT::i32,
913 SDValue Vec64 = DAG.getNode(HexagonISD::COMBINE, dl, MVT::v8i8, {W1, W0});
918 SDValue
919 HexagonTargetLowering::insertHvxSubvectorReg(SDValue VecV, SDValue SubV,
920 SDValue IdxV, const SDLoc &dl, SelectionDAG &DAG) const {
930 SDValue V0, V1;
931 SDValue SingleV = VecV;
932 SDValue PickHi;
938 SDValue HalfV = DAG.getConstant(SingleTy.getVectorNumElements(),
951 SDValue InLo = DAG.getNode(ISD::CONCAT_VECTORS, dl, VecTy, {SubV, V1});
952 SDValue InHi = DAG.getNode(ISD::CONCAT_VECTORS, dl, VecTy, {V0, SubV});
958 SDValue S = DAG.getNode(ISD::SUB, dl, MVT::i32, IdxV, HalfV);
978 SDValue V = DAG.getBitcast(MVT::i32, SubV);
981 SDValue V = DAG.getBitcast(MVT::i64, SubV);
982 SDValue R0 = DAG.getTargetExtractSubreg(Hexagon::isub_lo, dl, MVT::i32, V);
983 SDValue R1 = DAG.getTargetExtractSubreg(Hexagon::isub_hi, dl, MVT::i32, V);
992 SDValue RolV = DAG.getNode(ISD::SUB, dl, MVT::i32,
998 SDValue InLo = DAG.getNode(ISD::CONCAT_VECTORS, dl, VecTy, {SingleV, V1});
999 SDValue InHi = DAG.getNode(ISD::CONCAT_VECTORS, dl, VecTy, {V0, SingleV});
1005 SDValue
1006 HexagonTargetLowering::insertHvxSubvectorPred(SDValue VecV, SDValue SubV,
1007 SDValue IdxV, const SDLoc &dl, SelectionDAG &DAG) const {
1023 SDValue ByteVec = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, VecV);
1024 SDValue ByteSub = createHvxPrefixPred(SubV, dl, BitBytes, false, DAG);
1025 SDValue ByteIdx;
1038 SDValue Q = getInstr(Hexagon::V6_pred_scalar2, dl, BoolTy,
1043 SDValue HwLenV = DAG.getConstant(HwLen, dl, MVT::i32);
1044 SDValue ByteXdi = DAG.getNode(ISD::SUB, dl, MVT::i32, HwLenV, ByteIdx);
1050 SDValue
1051 HexagonTargetLowering::extendHvxVectorPred(SDValue VecV, const SDLoc &dl,
1061 SDValue True = DAG.getNode(HexagonISD::VSPLAT, dl, ResTy,
1063 SDValue False = getZero(dl, ResTy, DAG);
1067 SDValue
1068 HexagonTargetLowering::compressHvxPred(SDValue VecQ, const SDLoc &dl,
1093 SDValue CP =
1095 SDValue Bytes =
1100 SDValue Sel = DAG.getSelect(dl, VecTy, VecQ, DAG.getBitcast(VecTy, Bytes),
1105 SDValue All1 =
1107 SDValue Vrmpy = getInstr(Hexagon::V6_vrmpyub, dl, ByteTy, {Sel, All1}, DAG);
1109 SDValue Rot = getInstr(Hexagon::V6_valignbi, dl, ByteTy,
1111 SDValue Vor = DAG.getNode(ISD::OR, dl, ByteTy, {Vrmpy, Rot});
1119 SDValue Collect =
1124 SDValue
1125 HexagonTargetLowering::LowerHvxBuildVector(SDValue Op, SelectionDAG &DAG)
1131 SmallVector<SDValue,128> Ops;
1139 ArrayRef<SDValue> A(Ops);
1141 SDValue V0 = buildHvxVectorReg(A.take_front(Size/2), dl, SingleTy, DAG);
1142 SDValue V1 = buildHvxVectorReg(A.drop_front(Size/2), dl, SingleTy, DAG);
1149 SDValue
1150 HexagonTargetLowering::LowerHvxConcatVectors(SDValue Op, SelectionDAG &DAG)
1162 SmallVector<SDValue,8> Elems;
1163 for (SDValue V : Op.getNode()->ops())
1171 SDValue V = Elems[i];
1198 SDValue Op0 = Op.getOperand(0);
1207 SmallVector<SDValue,4> SV(U.begin(), U.end());
1208 ArrayRef<SDValue> Ops(SV);
1211 SDValue V0 = DAG.getNode(ISD::CONCAT_VECTORS, dl, HalfTy,
1213 SDValue V1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, HalfTy,
1222 SmallVector<SDValue,8> Prefixes;
1223 for (SDValue V : Op.getNode()->op_values()) {
1224 SDValue P = createHvxPrefixPred(V, dl, BitBytes, true, DAG);
1230 SDValue S = DAG.getConstant(InpLen*BitBytes, dl, MVT::i32);
1231 SDValue Res = getZero(dl, ByteTy, DAG);
1239 SDValue
1240 HexagonTargetLowering::LowerHvxExtractElement(SDValue Op, SelectionDAG &DAG)
1243 SDValue VecV = Op.getOperand(0);
1246 SDValue IdxV = Op.getOperand(1);
1253 SDValue
1254 HexagonTargetLowering::LowerHvxInsertElement(SDValue Op, SelectionDAG &DAG)
1257 SDValue VecV = Op.getOperand(0);
1258 SDValue ValV = Op.getOperand(1);
1259 SDValue IdxV = Op.getOperand(2);
1267 SDValue
1268 HexagonTargetLowering::LowerHvxExtractSubvector(SDValue Op, SelectionDAG &DAG)
1270 SDValue SrcV = Op.getOperand(0);
1273 SDValue IdxV = Op.getOperand(1);
1286 SDValue
1287 HexagonTargetLowering::LowerHvxInsertSubvector(SDValue Op, SelectionDAG &DAG)
1290 SDValue VecV = Op.getOperand(0);
1291 SDValue ValV = Op.getOperand(1);
1292 SDValue IdxV = Op.getOperand(2);
1303 SDValue
1304 HexagonTargetLowering::LowerHvxAnyExt(SDValue Op, SelectionDAG &DAG) const {
1310 SDValue InpV = Op.getOperand(0);
1317 SDValue
1318 HexagonTargetLowering::LowerHvxSignExt(SDValue Op, SelectionDAG &DAG) const {
1320 SDValue InpV = Op.getOperand(0);
1327 SDValue
1328 HexagonTargetLowering::LowerHvxZeroExt(SDValue Op, SelectionDAG &DAG) const {
1330 SDValue InpV = Op.getOperand(0);
1337 SDValue
1338 HexagonTargetLowering::LowerHvxCttz(SDValue Op, SelectionDAG &DAG) const {
1343 SDValue InpV = Op.getOperand(0);
1356 SDValue Vec1 = DAG.getNode(HexagonISD::VSPLATW, dl, ResTy,
1358 SDValue VecW = DAG.getNode(HexagonISD::VSPLATW, dl, ResTy,
1360 SDValue VecN1 = DAG.getNode(HexagonISD::VSPLATW, dl, ResTy,
1365 SDValue A = DAG.getNode(ISD::AND, dl, ResTy,
1372 SDValue
1373 HexagonTargetLowering::LowerHvxMul(SDValue Op, SelectionDAG &DAG) const {
1381 SDValue Vs = Op.getOperand(0);
1382 SDValue Vt = Op.getOperand(1);
1392 SDValue M = getInstr(MpyOpc, dl, ExtTy, {Vs, Vt}, DAG);
1400 SDValue BS = getByteShuffle(dl, P.first, P.second, ShuffMask, DAG);
1413 SDValue S16 = DAG.getConstant(16, dl, MVT::i32);
1414 SDValue T0 = getInstr(Hexagon::V6_vmpyiowh, dl, ResTy, {Vs, Vt}, DAG);
1415 SDValue T1 = getInstr(Hexagon::V6_vaslw, dl, ResTy, {T0, S16}, DAG);
1416 SDValue T2 = getInstr(Hexagon::V6_vmpyiewuh_acc, dl, ResTy,
1423 return SDValue();
1426 SDValue
1427 HexagonTargetLowering::LowerHvxMulh(SDValue Op, SelectionDAG &DAG) const {
1435 SDValue Vs = Op.getOperand(0);
1436 SDValue Vt = Op.getOperand(1);
1450 SDValue M = getInstr(MpyOpc, dl, ExtTy, {Vs, Vt}, DAG);
1458 SDValue BS = getByteShuffle(dl, P.first, P.second, ShuffMask, DAG);
1463 SDValue S16 = DAG.getConstant(16, dl, MVT::i32);
1480 SDValue T0 = getInstr(Hexagon::V6_vmpyewuh, dl, ResTy, {Vt, Vs}, DAG);
1482 SDValue S0 = getInstr(Hexagon::V6_vasrw, dl, ResTy, {Vs, S16}, DAG);
1483 SDValue T1 = getInstr(Hexagon::V6_vmpyiewuh_acc, dl, ResTy,
1486 SDValue S2 = getInstr(Hexagon::V6_vasrw, dl, ResTy, {T1, S16}, DAG);
1488 SDValue T2 = getInstr(Hexagon::V6_vmpyiowh, dl, ResTy, {S0, Vt}, DAG);
1490 SDValue T3 = DAG.getNode(ISD::ADD, dl, ResTy, {S2, T2});
1496 auto LoVec = [&DAG,ResTy,dl] (SDValue Pair) {
1499 auto HiVec = [&DAG,ResTy,dl] (SDValue Pair) {
1504 SDValue P = getInstr(Hexagon::V6_lvsplatw, dl, ResTy,
1509 SDValue T0 = getInstr(Hexagon::V6_vmpyuhv, dl, PairTy, {Vs, Vt}, DAG);
1513 SDValue T1 = getInstr(Hexagon::V6_vlsrw, dl, ResTy, {LoVec(T0), S16}, DAG);
1516 SDValue D0 = getInstr(Hexagon::V6_vdelta, dl, ResTy, {Vt, P}, DAG);
1517 SDValue T2 = getInstr(Hexagon::V6_vmpyuhv, dl, PairTy, {Vs, D0}, DAG);
1522 SDValue T3 = getInstr(Hexagon::V6_vadduhw, dl, PairTy,
1525 SDValue T4 = DAG.getNode(ISD::ADD, dl, ResTy, {T1, LoVec(T3)});
1526 SDValue T5 = getInstr(Hexagon::V6_vlsrw, dl, ResTy, {T4, S16}, DAG);
1527 SDValue T6 = DAG.getNode(ISD::ADD, dl, ResTy, {HiVec(T0), HiVec(T3)});
1528 SDValue T7 = DAG.getNode(ISD::ADD, dl, ResTy, {T5, T6});
1532 SDValue
1533 HexagonTargetLowering::LowerHvxBitcast(SDValue Op, SelectionDAG &DAG) const {
1534 SDValue ValQ = Op.getOperand(0);
1542 SDValue VQ = compressHvxPred(ValQ, dl, WordTy, DAG);
1546 SDValue W0 = extractHvxElementReg(VQ, DAG.getConstant(0, dl, MVT::i32),
1556 SmallVector<SDValue,4> Words;
1558 SDValue W = extractHvxElementReg(
1562 SmallVector<SDValue,2> Combines;
1565 SDValue C = DAG.getNode(
1579 SDValue
1580 HexagonTargetLowering::LowerHvxExtend(SDValue Op, SelectionDAG &DAG) const {
1587 SDValue
1588 HexagonTargetLowering::LowerHvxShift(SDValue Op, SelectionDAG &DAG) const {
1589 if (SDValue S = getVectorShiftByInt(Op, DAG))
1594 SDValue
1595 HexagonTargetLowering::LowerHvxIntrinsic(SDValue Op, SelectionDAG &DAG) const {
1604 SDValue Vs = Op.getOperand(1);
1616 SDValue
1617 HexagonTargetLowering::SplitHvxPairOp(SDValue Op, SelectionDAG &DAG) const {
1619 SmallVector<SDValue,2> OpsL, OpsH;
1624 SDValue TV = DAG.getValueType(Ty);
1628 for (SDValue A : Op.getNode()->ops()) {
1643 SDValue L = DAG.getNode(Op.getOpcode(), dl, HalfTy, OpsL);
1644 SDValue H = DAG.getNode(Op.getOpcode(), dl, HalfTy, OpsH);
1645 SDValue S = DAG.getNode(ISD::CONCAT_VECTORS, dl, ResTy, L, H);
1649 SDValue
1650 HexagonTargetLowering::SplitHvxMemOp(SDValue Op, SelectionDAG &DAG) const {
1660 SDValue Chain = BN->getChain();
1661 SDValue Base0 = BN->getBasePtr();
1662 SDValue Base1 = DAG.getMemBasePlusOffset(Base0, HwLen, dl);
1672 SDValue NewOp;
1675 SDValue Load0 = DAG.getLoad(SingleTy, dl, Chain, Base0, MOp0);
1676 SDValue Load1 = DAG.getLoad(SingleTy, dl, Chain, Base1, MOp1);
1684 SDValue Store0 = DAG.getStore(Chain, dl, Vals.first, Base0, MOp0);
1685 SDValue Store1 = DAG.getStore(Chain, dl, Vals.second, Base1, MOp1);
1692 SDValue
1693 HexagonTargetLowering::LowerHvxOperation(SDValue Op, SelectionDAG &DAG) const {
1696 llvm::any_of(Op.getNode()->ops(), [this] (SDValue V) {
1753 case ISD::LOAD: return SDValue();
1763 SmallVectorImpl<SDValue> &Results, SelectionDAG &DAG) const {
1768 SmallVectorImpl<SDValue> &Results, SelectionDAG &DAG) const {
1773 SDValue Op(N, 0);
1774 SDValue C = LowerHvxBitcast(Op, DAG);
1783 SDValue
1787 SDValue Op(N, 0);
1792 SDValue Cond = Op.getOperand(0);
1794 SDValue C0 = Cond.getOperand(0), C1 = Cond.getOperand(1);
1796 SDValue VSel = DCI.DAG.getNode(ISD::VSELECT, dl, ty(Op), C0,
1802 return SDValue();
1806 HexagonTargetLowering::isHvxOperation(SDValue Op) const {
1811 [this] (SDValue V) {
1823 auto IsHvxOp = [this] (SDValue Op) {