Lines Matching defs:dl
173 SelectionDAG &DAG, const SDLoc &dl) {
174 SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), dl, MVT::i32);
176 Chain, dl, Dst, Src, SizeNode, Flags.getNonZeroByValAlign(),
202 const SDLoc &dl, SelectionDAG &DAG) const {
234 Val = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Val);
237 Val = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Val);
240 Val = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Val);
244 Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), Val, Glue);
257 return DAG.getNode(HexagonISD::RET_GLUE, dl, MVT::Other, RetOps);
348 const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
372 SDValue FR0 = DAG.getCopyFromReg(Chain, dl, RVLocs[i].getLocReg(),
376 SDValue TPR = DAG.getCopyToReg(FR0.getValue(1), dl, PredR,
382 RetVal = DAG.getCopyFromReg(TPR.getValue(0), dl, PredR, MVT::i1);
386 RetVal = DAG.getCopyFromReg(Chain, dl, RVLocs[i].getLocReg(),
403 SDLoc &dl = CLI.DL;
420 Callee = DAG.getTargetGlobalAddress(GAN->getGlobal(), dl, MVT::i32);
459 DAG.getCopyFromReg(Chain, dl, HRI.getStackRegister(), PtrVT);
483 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
486 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
489 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
495 SDValue MemAddr = DAG.getConstant(LocMemOffset, dl,
497 MemAddr = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, MemAddr);
505 Flags, DAG, dl));
509 SDValue S = DAG.getStore(Chain, dl, Arg, MemAddr, LocPI);
530 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
534 Chain = DAG.getCALLSEQ_START(Chain, NumBytes, 0, dl);
544 Chain = DAG.getCopyToReg(Chain, dl, R.first, R.second, Glue);
560 Chain = DAG.getCopyToReg(Chain, dl, R.first, R.second, Glue);
573 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl, PtrVT, 0, Flags);
598 return DAG.getNode(HexagonISD::TC_RETURN, dl, MVT::Other, Ops);
607 Chain = DAG.getNode(OpCode, dl, {MVT::Other, MVT::Glue}, Ops);
611 Chain = DAG.getCALLSEQ_END(Chain, NumBytes, 0, Glue, dl);
616 return LowerCallResult(Chain, Glue, CallConv, IsVarArg, Ins, dl, DAG,
726 SDLoc dl(Op);
728 return DAG.getNode(HexagonISD::READCYCLE, dl, VTs, Chain);
738 SDLoc dl(Op);
740 return DAG.getNode(HexagonISD::READTIMER, dl, VTs, Chain);
763 SDLoc dl(Op);
780 SDValue AC = DAG.getConstant(A, dl, MVT::i32);
782 SDValue AA = DAG.getNode(HexagonISD::ALLOCA, dl, VTs, Chain, Size, AC);
790 const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
859 SDValue Copy = DAG.getCopyFromReg(Chain, dl, VReg, RegVT);
866 SDValue T = DAG.getNode(ISD::AND, dl, RegVT,
867 Copy, DAG.getConstant(1, dl, RegVT));
868 Copy = DAG.getSetCC(dl, MVT::i1, T, DAG.getConstant(0, dl, RegVT),
900 SDValue L = DAG.getLoad(VA.getValVT(), dl, Chain, FIN,
1044 const SDLoc &dl(Op);
1056 return DAG.getSetCC(dl, ResTy,
1094 return DAG.getSetCC(dl, ResTy,
1107 const SDLoc &dl(Op);
1116 DAG.getSelect(dl, WideTy, PredOp,
1117 DAG.getSExtOrTrunc(Op1, dl, WideTy),
1118 DAG.getSExtOrTrunc(Op2, dl, WideTy)),
1119 dl, OpTy);
1192 SDLoc dl(Op);
1196 SDValue Offset = DAG.getConstant(4, dl, MVT::i32);
1197 return DAG.getLoad(VT, dl, DAG.getEntryNode(),
1198 DAG.getNode(ISD::ADD, dl, VT, FrameAddr, Offset),
1204 return DAG.getCopyFromReg(DAG.getEntryNode(), dl, Reg, VT);
1214 SDLoc dl(Op);
1216 SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl,
1219 FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
1226 SDLoc dl(Op);
1227 return DAG.getNode(HexagonISD::BARRIER, dl, MVT::Other, Op.getOperand(0));
1232 SDLoc dl(Op);
1242 SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset);
1245 return DAG.getNode(HexagonISD::CONST32_GP, dl, PtrVT, GA);
1246 return DAG.getNode(HexagonISD::CONST32, dl, PtrVT, GA);
1251 SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset,
1253 return DAG.getNode(HexagonISD::AT_PCREL, dl, PtrVT, GA);
1258 SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, HexagonII::MO_GOT);
1259 SDValue Off = DAG.getConstant(Offset, dl, MVT::i32);
1260 return DAG.getNode(HexagonISD::AT_GOT, dl, PtrVT, GOT, GA, Off);
1267 SDLoc dl(Op);
1273 return DAG.getNode(HexagonISD::CONST32_GP, dl, PtrVT, A);
1277 return DAG.getNode(HexagonISD::AT_PCREL, dl, PtrVT, A);
1296 SDLoc dl(GA);
1297 SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
1314 Chain = DAG.getNode(HexagonISD::CALL, dl, NodeTys, Ops);
1320 return DAG.getCopyFromReg(Chain, dl, ReturnReg, PtrVT, Glue);
1329 SDLoc dl(GA);
1334 SDValue TP = DAG.getCopyFromReg(DAG.getEntryNode(), dl, Hexagon::UGP, PtrVT);
1341 SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl, PtrVT,
1344 SDValue Sym = DAG.getNode(HexagonISD::CONST32, dl, PtrVT, TGA);
1352 Sym = DAG.getNode(ISD::ADD, dl, PtrVT, GOT, Sym);
1358 DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Sym, MachinePointerInfo());
1362 return DAG.getNode(ISD::ADD, dl, PtrVT, TP, LoadOffset);
1371 SDLoc dl(GA);
1376 SDValue TP = DAG.getCopyFromReg(DAG.getEntryNode(), dl, Hexagon::UGP, PtrVT);
1378 SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl, PtrVT, Offset,
1380 SDValue Sym = DAG.getNode(HexagonISD::CONST32, dl, PtrVT, TGA);
1384 return DAG.getNode(ISD::ADD, dl, PtrVT, TP, Sym);
1393 SDLoc dl(GA);
1398 SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl, PtrVT, Offset,
1405 SDValue Sym = DAG.getNode(HexagonISD::CONST32, dl, PtrVT, TGA);
1406 SDValue Chain = DAG.getNode(ISD::ADD, dl, PtrVT, GOT, Sym);
1410 Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, Hexagon::R0, Chain, InGlue);
1956 const SDLoc &dl, SelectionDAG &DAG) const {
1985 if (DebugLoc DL = dl.getDebugLoc())
1996 const SDLoc &dl(Op);
2001 SDValue Trap = DAG.getNode(ISD::TRAP, dl, MVT::Other, Chain);
2003 return DAG.getMergeValues({DAG.getUNDEF(ty(Op)), Trap}, dl);
2257 const SDLoc &dl(Op);
2312 SDValue T1 = DAG.getNode(ISD::BSWAP, dl, MVT::i32, T0);
2318 getCombine(Op1, Op0, dl, typeJoin({ty(Op1), ty(Op0)}), DAG);
2320 return getInstr(Hexagon::S2_vtrunehb, dl, VecTy, {Concat10}, DAG);
2322 return getInstr(Hexagon::S2_vtrunohb, dl, VecTy, {Concat10}, DAG);
2325 getCombine(Op0, Op1, dl, typeJoin({ty(Op0), ty(Op1)}), DAG);
2327 return getInstr(Hexagon::S2_vtrunehb, dl, VecTy, {Concat01}, DAG);
2329 return getInstr(Hexagon::S2_vtrunohb, dl, VecTy, {Concat01}, DAG);
2339 SDValue T1 = DAG.getNode(ISD::BSWAP, dl, MVT::i64, T0);
2345 return getInstr(Hexagon::S2_shuffeh, dl, VecTy, {Op1, Op0}, DAG);
2347 return getInstr(Hexagon::S2_shuffoh, dl, VecTy, {Op1, Op0}, DAG);
2349 return getInstr(Hexagon::S2_vtrunewh, dl, VecTy, {Op1, Op0}, DAG);
2351 return getInstr(Hexagon::S2_vtrunowh, dl, VecTy, {Op1, Op0}, DAG);
2353 VectorPair P = opSplit(Op0, dl, DAG);
2354 return getInstr(Hexagon::S2_packhl, dl, VecTy, {P.second, P.first}, DAG);
2359 return getInstr(Hexagon::S2_shuffeb, dl, VecTy, {Op1, Op0}, DAG);
2361 return getInstr(Hexagon::S2_shuffob, dl, VecTy, {Op1, Op0}, DAG);
2406 const SDLoc &dl(Op);
2434 auto ShiftPartI8 = [&dl, &DAG, this](unsigned Opc, SDValue V, SDValue A) {
2437 SDValue ExtV = Opc == HexagonISD::VASR ? DAG.getSExtOrTrunc(V, dl, ExtTy)
2438 : DAG.getZExtOrTrunc(V, dl, ExtTy);
2439 SDValue ExtS = DAG.getNode(Opc, dl, ExtTy, {ExtV, A});
2440 return DAG.getZExtOrTrunc(ExtS, dl, Ty);
2446 auto [LoV, HiV] = opSplit(Val, dl, DAG);
2447 return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResTy,
2464 const SDLoc &dl(Op);
2470 SDValue Ext = DAG.getZExtOrTrunc(Sc, dl, MVT::i32);
2471 return getInstr(Hexagon::C2_tfrrp, dl, ResTy, Ext, DAG);
2510 HexagonTargetLowering::buildVector32(ArrayRef<SDValue> Elem, const SDLoc &dl,
2528 return getZero(dl, VecTy, DAG);
2537 return DAG.getBitcast(VecTy, DAG.getConstant(V, dl, MVT::i32));
2541 E0 = DAG.getZExtOrTrunc(DAG.getBitcast(MVT::i16, Elem[0]), dl, MVT::i32);
2542 E1 = DAG.getZExtOrTrunc(DAG.getBitcast(MVT::i16, Elem[1]), dl, MVT::i32);
2547 SDValue N = getInstr(Hexagon::A2_combine_ll, dl, MVT::i32, {E1, E0}, DAG);
2558 return DAG.getBitcast(MVT::v4i8, DAG.getConstant(V, dl, MVT::i32));
2571 SDValue Ext = DAG.getZExtOrTrunc(Elem[First], dl, MVT::i32);
2572 return DAG.getNode(ISD::SPLAT_VECTOR, dl, VecTy, Ext);
2581 Vs[i] = DAG.getZExtOrTrunc(Elem[i], dl, MVT::i32);
2582 Vs[i] = DAG.getZeroExtendInReg(Vs[i], dl, MVT::i8);
2584 SDValue S8 = DAG.getConstant(8, dl, MVT::i32);
2585 SDValue T0 = DAG.getNode(ISD::SHL, dl, MVT::i32, {Vs[1], S8});
2586 SDValue T1 = DAG.getNode(ISD::SHL, dl, MVT::i32, {Vs[3], S8});
2587 SDValue B0 = DAG.getNode(ISD::OR, dl, MVT::i32, {Vs[0], T0});
2588 SDValue B1 = DAG.getNode(ISD::OR, dl, MVT::i32, {Vs[2], T1});
2590 SDValue R = getInstr(Hexagon::A2_combine_ll, dl, MVT::i32, {B1, B0}, DAG);
2601 HexagonTargetLowering::buildVector64(ArrayRef<SDValue> Elem, const SDLoc &dl,
2619 return getZero(dl, VecTy, DAG);
2634 SDValue Ext = DAG.getZExtOrTrunc(S, dl, MVT::i32);
2635 return DAG.getNode(ISD::SPLAT_VECTOR, dl, VecTy, Ext);
2646 SDValue V0 = DAG.getConstant(Val, dl, MVT::i64);
2654 : buildVector32(Elem.take_front(Num/2), dl, HalfTy, DAG);
2657 : buildVector32(Elem.drop_front(Num/2), dl, HalfTy, DAG);
2658 return getCombine(H, L, dl, VecTy, DAG);
2663 const SDLoc &dl, MVT ValTy, MVT ResTy,
2669 return extractVectorPred(VecV, IdxV, dl, ValTy, ResTy, DAG);
2681 SDValue WidthV = DAG.getConstant(ValWidth, dl, MVT::i32);
2690 ExtV = DAG.getZeroExtendInReg(VecV, dl, tyScalar(ValTy));
2692 SDValue OffV = DAG.getConstant(Off, dl, MVT::i32);
2695 ExtV = DAG.getNode(HexagonISD::EXTRACTU, dl, ScalarTy,
2700 IdxV = DAG.getZExtOrTrunc(IdxV, dl, MVT::i32);
2701 SDValue OffV = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV,
2702 DAG.getConstant(ElemWidth, dl, MVT::i32));
2703 ExtV = DAG.getNode(HexagonISD::EXTRACTU, dl, ScalarTy,
2708 ExtV = DAG.getZExtOrTrunc(ExtV, dl, tyScalar(ResTy));
2715 const SDLoc &dl, MVT ValTy, MVT ResTy,
2731 return DAG.getNode(HexagonISD::TYPECAST, dl, MVT::i1, VecV);
2736 SDValue A0 = getInstr(Hexagon::C2_tfrpr, dl, MVT::i32, {VecV}, DAG);
2737 SDValue M0 = DAG.getConstant(8 / VecWidth, dl, MVT::i32);
2738 SDValue I0 = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, M0);
2739 return DAG.getNode(HexagonISD::TSTBIT, dl, MVT::i1, A0, I0);
2752 SDValue S0 = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV,
2753 DAG.getConstant(8*VecRep, dl, MVT::i32));
2754 SDValue T0 = DAG.getNode(HexagonISD::P2D, dl, MVT::i64, VecV);
2755 SDValue T1 = DAG.getNode(ISD::SRL, dl, MVT::i64, T0, S0);
2760 T1 = expandPredicate(T1, dl, DAG);
2764 return DAG.getNode(HexagonISD::D2P, dl, ResTy, T1);
2769 const SDLoc &dl, MVT ValTy,
2773 return insertVectorPred(VecV, ValV, IdxV, dl, ValTy, DAG);
2788 ValV = DAG.getAnyExtOrTrunc(ValV, dl, ScalarTy);
2790 SDValue WidthV = DAG.getConstant(ValWidth, dl, MVT::i32);
2795 SDValue OffV = DAG.getConstant(W, dl, MVT::i32);
2796 InsV = DAG.getNode(HexagonISD::INSERT, dl, ScalarTy,
2800 IdxV = DAG.getZExtOrTrunc(IdxV, dl, MVT::i32);
2801 SDValue OffV = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, WidthV);
2802 InsV = DAG.getNode(HexagonISD::INSERT, dl, ScalarTy,
2806 return DAG.getNode(ISD::BITCAST, dl, VecTy, InsV);
2811 SDValue IdxV, const SDLoc &dl,
2817 SDValue ToReg = getInstr(Hexagon::C2_tfrpr, dl, MVT::i32, {VecV}, DAG);
2818 SDValue Ext = DAG.getSExtOrTrunc(ValV, dl, MVT::i32);
2819 SDValue Width = DAG.getConstant(8 / VecLen, dl, MVT::i32);
2820 SDValue Idx = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, Width);
2822 DAG.getNode(HexagonISD::INSERT, dl, MVT::i32, {ToReg, Ext, Width, Idx});
2823 return getInstr(Hexagon::C2_tfrrp, dl, VecTy, {Ins}, DAG);
2828 ? DAG.getNode(HexagonISD::P2D, dl, MVT::i64, ValV)
2829 : DAG.getSExtOrTrunc(ValV, dl, MVT::i64);
2835 ValR = contractPredicate(ValR, dl, DAG);
2836 ValR = getCombine(DAG.getUNDEF(MVT::i32), ValR, dl, MVT::i64, DAG);
2839 SDValue Width = DAG.getConstant(64 / Scale, dl, MVT::i32);
2840 SDValue Idx = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, Width);
2841 SDValue VecR = DAG.getNode(HexagonISD::P2D, dl, MVT::i64, VecV);
2843 DAG.getNode(HexagonISD::INSERT, dl, MVT::i64, {VecR, ValR, Width, Idx});
2844 return DAG.getNode(HexagonISD::D2P, dl, VecTy, Ins);
2848 HexagonTargetLowering::expandPredicate(SDValue Vec32, const SDLoc &dl,
2854 SDValue X = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i16, P);
2859 HexagonTargetLowering::contractPredicate(SDValue Vec64, const SDLoc &dl,
2866 SDValue S = DAG.getVectorShuffle(MVT::v8i8, dl, A, DAG.getUNDEF(MVT::v8i8),
2868 return extractVector(S, DAG.getConstant(0, dl, MVT::i32), dl, MVT::v4i8,
2873 HexagonTargetLowering::getZero(const SDLoc &dl, MVT Ty, SelectionDAG &DAG)
2878 return DAG.getBitcast(Ty, DAG.getConstant(0, dl, MVT::getIntegerVT(W)));
2879 return DAG.getNode(ISD::SPLAT_VECTOR, dl, Ty, getZero(dl, MVT::i32, DAG));
2883 return DAG.getConstant(0, dl, Ty);
2885 return DAG.getConstantFP(0.0, dl, Ty);
2900 const SDLoc &dl(Val);
2908 return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResTy, Concats);
2912 HexagonTargetLowering::getCombine(SDValue Hi, SDValue Lo, const SDLoc &dl,
2920 SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, dl, PairTy, Lo, Hi);
2928 DAG.getNode(ISD::BUILD_PAIR, dl, PairTy,
2937 const SDLoc &dl(Op);
2943 return buildVector32(Ops, dl, VecTy, DAG);
2945 return buildVector64(Ops, dl, VecTy, DAG);
2961 return DAG.getNode(HexagonISD::PFALSE, dl, VecTy);
2963 return DAG.getNode(HexagonISD::PTRUE, dl, VecTy);
2969 SDValue Z = getZero(dl, MVT::i32, DAG);
2973 SDValue S = DAG.getConstant(1ull << i, dl, MVT::i32);
2974 Rs[i] = DAG.getSelect(dl, MVT::i32, Ops[i/Rep], S, Z);
2978 Rs[i] = DAG.getNode(ISD::OR, dl, MVT::i32, Rs[2*i], Rs[2*i+1]);
2981 return getInstr(Hexagon::C2_tfrrp, dl, VecTy, {Rs[0]}, DAG);
2991 const SDLoc &dl(Op);
2994 return getCombine(Op.getOperand(1), Op.getOperand(0), dl, VecTy, DAG);
3014 SDValue W = DAG.getNode(HexagonISD::P2D, dl, MVT::i64, P);
3016 W = contractPredicate(W, dl, DAG);
3017 W = getCombine(DAG.getUNDEF(MVT::i32), W, dl, MVT::i64, DAG);
3024 SDValue WidthV = DAG.getConstant(64 / Scale, dl, MVT::i32);
3030 SDValue T = DAG.getNode(HexagonISD::INSERT, dl, MVT::i32,
3041 SDValue WW = getCombine(Words[IdxW][1], Words[IdxW][0], dl, MVT::i64, DAG);
3042 return DAG.getNode(HexagonISD::D2P, dl, VecTy, WW);
3094 const SDLoc &dl(Op);
3102 LN->getAddressingMode(), ISD::ZEXTLOAD, MVT::i32, dl, LN->getChain(),
3110 if (!validateConstPtrAlignment(LN->getBasePtr(), ClaimAlign, dl, DAG))
3117 SDValue TP = getInstr(Hexagon::C2_tfrrp, dl, MemTy, {LU}, DAG);
3119 TP = DAG.getSExtOrTrunc(TP, dl, Ty);
3121 TP = DAG.getZExtOrTrunc(TP, dl, Ty);
3124 return DAG.getMergeValues({TP, Ch}, dl);
3131 const SDLoc &dl(Op);
3138 SDValue TR = getInstr(Hexagon::C2_tfrpr, dl, MVT::i32, {Val}, DAG);
3139 SDValue NS = DAG.getTruncStore(SN->getChain(), dl, TR, SN->getBasePtr(),
3142 NS = DAG.getIndexedStore(NS, dl, SN->getBasePtr(), SN->getOffset(),
3149 if (!validateConstPtrAlignment(SN->getBasePtr(), ClaimAlign, dl, DAG))
3169 const SDLoc &dl(Op);
3195 return DAG.getMergeValues({P.first, P.second}, dl);
3214 BO.first = DAG.getNode(ISD::ADD, dl, MVT::i32, BO.first,
3215 DAG.getConstant(BO.second % LoadLen, dl, MVT::i32));
3219 ? DAG.getNode(HexagonISD::VALIGNADDR, dl, MVT::i32, BO.first,
3220 DAG.getConstant(NeedAlign, dl, MVT::i32))
3223 DAG.getMemBasePlusOffset(BaseNoOff, TypeSize::getFixed(BO.second), dl);
3225 BaseNoOff, TypeSize::getFixed(BO.second + LoadLen), dl);
3236 SDValue Load0 = DAG.getLoad(LoadTy, dl, Chain, Base0, WideMMO);
3237 SDValue Load1 = DAG.getLoad(LoadTy, dl, Chain, Base1, WideMMO);
3239 SDValue Aligned = DAG.getNode(HexagonISD::VALIGN, dl, LoadTy,
3241 SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3243 SDValue M = DAG.getMergeValues({Aligned, NewChain}, dl);
3254 const SDLoc &dl(Op);
3268 SDValue Op = DAG.getNode(ISD::ADD, dl, VTs.VTs[0], {X, Y});
3269 SDValue Ov = DAG.getSetCC(dl, MVT::i1, Op, getZero(dl, ty(Op), DAG),
3271 return DAG.getMergeValues({Op, Ov}, dl);
3274 SDValue Op = DAG.getNode(ISD::SUB, dl, VTs.VTs[0], {X, Y});
3275 SDValue Ov = DAG.getSetCC(dl, MVT::i1, Op,
3276 DAG.getConstant(-1, dl, ty(Op)), ISD::SETEQ);
3277 return DAG.getMergeValues({Op, Ov}, dl);
3286 const SDLoc &dl(Op);
3291 return DAG.getNode(HexagonISD::ADDC, dl, Op.getNode()->getVTList(),
3295 SDValue SubC = DAG.getNode(HexagonISD::SUBC, dl, Op.getNode()->getVTList(),
3296 { X, Y, DAG.getLogicalNOT(dl, C, CarryTy) });
3298 DAG.getLogicalNOT(dl, SubC.getValue(1), CarryTy) };
3299 return DAG.getMergeValues(Out, dl);
3307 SDLoc dl(Op);
3318 DAG.getNode(ISD::ADD, dl, PtrVT, DAG.getRegister(Hexagon::R30, PtrVT),
3319 DAG.getIntPtrConstant(4, dl));
3320 Chain = DAG.getStore(Chain, dl, Handler, StoreAddr, MachinePointerInfo());
3321 Chain = DAG.getCopyToReg(Chain, dl, OffsetReg, Offset);
3326 return DAG.getNode(HexagonISD::EH_RETURN, dl, MVT::Other, Chain);
3439 const SDLoc &dl(N);
3449 SDValue P = getInstr(Hexagon::C2_tfrpr, dl, MVT::i32,
3451 SDValue T = DAG.getAnyExtOrTrunc(P, dl, MVT::i8);
3469 const SDLoc &dl(Op);
3483 return DCI.DAG.getNode(ISD::TRUNCATE, dl, TruncTy, Elem0);
3494 return DCI.DAG.getConstant(-1, dl, ty(Op));
3496 return getZero(dl, ty(Op), DCI.DAG);
3508 SDValue VSel = DCI.DAG.getNode(ISD::VSELECT, dl, ty(Op), C0,
3524 return DCI.DAG.getNode(ISD::TRUNCATE, dl, TruncTy, Elem0);
3545 SDValue T0 = DCI.DAG.getNode(ISD::SHL, dl, ty(S), S,
3546 DCI.DAG.getConstant(A - 32, dl, MVT::i32));
3547 SDValue T1 = DCI.DAG.getZExtOrTrunc(T0, dl, MVT::i32);
3548 SDValue T2 = DCI.DAG.getZExtOrTrunc(Z, dl, MVT::i32);
3549 return DCI.DAG.getNode(HexagonISD::COMBINE, dl, MVT::i64, {T1, T2});