Lines Matching defs:dl
176 SelectionDAG &DAG, const SDLoc &dl) {
177 SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), dl, MVT::i32);
179 Chain, dl, Dst, Src, SizeNode, Flags.getNonZeroByValAlign(),
205 const SDLoc &dl, SelectionDAG &DAG) const {
237 Val = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Val);
240 Val = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Val);
243 Val = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Val);
247 Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), Val, Glue);
260 return DAG.getNode(HexagonISD::RET_GLUE, dl, MVT::Other, RetOps);
351 const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
375 SDValue FR0 = DAG.getCopyFromReg(Chain, dl, RVLocs[i].getLocReg(),
379 SDValue TPR = DAG.getCopyToReg(FR0.getValue(1), dl, PredR,
385 RetVal = DAG.getCopyFromReg(TPR.getValue(0), dl, PredR, MVT::i1);
389 RetVal = DAG.getCopyFromReg(Chain, dl, RVLocs[i].getLocReg(),
406 SDLoc &dl = CLI.DL;
423 Callee = DAG.getTargetGlobalAddress(GAN->getGlobal(), dl, MVT::i32);
462 DAG.getCopyFromReg(Chain, dl, HRI.getStackRegister(), PtrVT);
486 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
489 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
492 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
498 SDValue MemAddr = DAG.getConstant(LocMemOffset, dl,
500 MemAddr = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, MemAddr);
508 Flags, DAG, dl));
512 SDValue S = DAG.getStore(Chain, dl, Arg, MemAddr, LocPI);
533 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, MemOpChains);
537 Chain = DAG.getCALLSEQ_START(Chain, NumBytes, 0, dl);
547 Chain = DAG.getCopyToReg(Chain, dl, R.first, R.second, Glue);
563 Chain = DAG.getCopyToReg(Chain, dl, R.first, R.second, Glue);
576 Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl, PtrVT, 0, Flags);
602 return DAG.getNode(HexagonISD::TC_RETURN, dl, NodeTys, Ops);
611 Chain = DAG.getNode(OpCode, dl, NodeTys, Ops);
615 Chain = DAG.getCALLSEQ_END(Chain, NumBytes, 0, Glue, dl);
620 return LowerCallResult(Chain, Glue, CallConv, IsVarArg, Ins, dl, DAG,
730 SDLoc dl(Op);
732 return DAG.getNode(HexagonISD::READCYCLE, dl, VTs, Chain);
742 SDLoc dl(Op);
744 return DAG.getNode(HexagonISD::READTIMER, dl, VTs, Chain);
767 SDLoc dl(Op);
784 SDValue AC = DAG.getConstant(A, dl, MVT::i32);
786 SDValue AA = DAG.getNode(HexagonISD::ALLOCA, dl, VTs, Chain, Size, AC);
794 const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
863 SDValue Copy = DAG.getCopyFromReg(Chain, dl, VReg, RegVT);
870 SDValue T = DAG.getNode(ISD::AND, dl, RegVT,
871 Copy, DAG.getConstant(1, dl, RegVT));
872 Copy = DAG.getSetCC(dl, MVT::i1, T, DAG.getConstant(0, dl, RegVT),
904 SDValue L = DAG.getLoad(VA.getValVT(), dl, Chain, FIN,
1048 const SDLoc &dl(Op);
1060 return DAG.getSetCC(dl, ResTy,
1098 return DAG.getSetCC(dl, ResTy,
1111 const SDLoc &dl(Op);
1120 DAG.getSelect(dl, WideTy, PredOp,
1121 DAG.getSExtOrTrunc(Op1, dl, WideTy),
1122 DAG.getSExtOrTrunc(Op2, dl, WideTy)),
1123 dl, OpTy);
1196 SDLoc dl(Op);
1200 SDValue Offset = DAG.getConstant(4, dl, MVT::i32);
1201 return DAG.getLoad(VT, dl, DAG.getEntryNode(),
1202 DAG.getNode(ISD::ADD, dl, VT, FrameAddr, Offset),
1208 return DAG.getCopyFromReg(DAG.getEntryNode(), dl, Reg, VT);
1218 SDLoc dl(Op);
1220 SDValue FrameAddr = DAG.getCopyFromReg(DAG.getEntryNode(), dl,
1223 FrameAddr = DAG.getLoad(VT, dl, DAG.getEntryNode(), FrameAddr,
1230 SDLoc dl(Op);
1231 return DAG.getNode(HexagonISD::BARRIER, dl, MVT::Other, Op.getOperand(0));
1236 SDLoc dl(Op);
1246 SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset);
1249 return DAG.getNode(HexagonISD::CONST32_GP, dl, PtrVT, GA);
1250 return DAG.getNode(HexagonISD::CONST32, dl, PtrVT, GA);
1255 SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset,
1257 return DAG.getNode(HexagonISD::AT_PCREL, dl, PtrVT, GA);
1262 SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, 0, HexagonII::MO_GOT);
1263 SDValue Off = DAG.getConstant(Offset, dl, MVT::i32);
1264 return DAG.getNode(HexagonISD::AT_GOT, dl, PtrVT, GOT, GA, Off);
1271 SDLoc dl(Op);
1277 return DAG.getNode(HexagonISD::CONST32_GP, dl, PtrVT, A);
1281 return DAG.getNode(HexagonISD::AT_PCREL, dl, PtrVT, A);
1300 SDLoc dl(GA);
1301 SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl,
1318 Chain = DAG.getNode(HexagonISD::CALL, dl, NodeTys, Ops);
1324 return DAG.getCopyFromReg(Chain, dl, ReturnReg, PtrVT, Glue);
1333 SDLoc dl(GA);
1338 SDValue TP = DAG.getCopyFromReg(DAG.getEntryNode(), dl, Hexagon::UGP, PtrVT);
1345 SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl, PtrVT,
1348 SDValue Sym = DAG.getNode(HexagonISD::CONST32, dl, PtrVT, TGA);
1356 Sym = DAG.getNode(ISD::ADD, dl, PtrVT, GOT, Sym);
1362 DAG.getLoad(PtrVT, dl, DAG.getEntryNode(), Sym, MachinePointerInfo());
1366 return DAG.getNode(ISD::ADD, dl, PtrVT, TP, LoadOffset);
1375 SDLoc dl(GA);
1380 SDValue TP = DAG.getCopyFromReg(DAG.getEntryNode(), dl, Hexagon::UGP, PtrVT);
1382 SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl, PtrVT, Offset,
1384 SDValue Sym = DAG.getNode(HexagonISD::CONST32, dl, PtrVT, TGA);
1388 return DAG.getNode(ISD::ADD, dl, PtrVT, TP, Sym);
1397 SDLoc dl(GA);
1402 SDValue TGA = DAG.getTargetGlobalAddress(GA->getGlobal(), dl, PtrVT, Offset,
1409 SDValue Sym = DAG.getNode(HexagonISD::CONST32, dl, PtrVT, TGA);
1410 SDValue Chain = DAG.getNode(ISD::ADD, dl, PtrVT, GOT, Sym);
1414 Chain = DAG.getCopyToReg(DAG.getEntryNode(), dl, Hexagon::R0, Chain, InGlue);
1966 const SDLoc &dl, SelectionDAG &DAG) const {
1995 if (DebugLoc DL = dl.getDebugLoc())
2006 const SDLoc &dl(Op);
2011 SDValue Trap = DAG.getNode(ISD::TRAP, dl, MVT::Other, Chain);
2013 return DAG.getMergeValues({DAG.getUNDEF(ty(Op)), Trap}, dl);
2267 const SDLoc &dl(Op);
2322 SDValue T1 = DAG.getNode(ISD::BSWAP, dl, MVT::i32, T0);
2328 getCombine(Op1, Op0, dl, typeJoin({ty(Op1), ty(Op0)}), DAG);
2330 return getInstr(Hexagon::S2_vtrunehb, dl, VecTy, {Concat10}, DAG);
2332 return getInstr(Hexagon::S2_vtrunohb, dl, VecTy, {Concat10}, DAG);
2335 getCombine(Op0, Op1, dl, typeJoin({ty(Op0), ty(Op1)}), DAG);
2337 return getInstr(Hexagon::S2_vtrunehb, dl, VecTy, {Concat01}, DAG);
2339 return getInstr(Hexagon::S2_vtrunohb, dl, VecTy, {Concat01}, DAG);
2349 SDValue T1 = DAG.getNode(ISD::BSWAP, dl, MVT::i64, T0);
2355 return getInstr(Hexagon::S2_shuffeh, dl, VecTy, {Op1, Op0}, DAG);
2357 return getInstr(Hexagon::S2_shuffoh, dl, VecTy, {Op1, Op0}, DAG);
2359 return getInstr(Hexagon::S2_vtrunewh, dl, VecTy, {Op1, Op0}, DAG);
2361 return getInstr(Hexagon::S2_vtrunowh, dl, VecTy, {Op1, Op0}, DAG);
2363 VectorPair P = opSplit(Op0, dl, DAG);
2364 return getInstr(Hexagon::S2_packhl, dl, VecTy, {P.second, P.first}, DAG);
2369 return getInstr(Hexagon::S2_shuffeb, dl, VecTy, {Op1, Op0}, DAG);
2371 return getInstr(Hexagon::S2_shuffob, dl, VecTy, {Op1, Op0}, DAG);
2416 const SDLoc &dl(Op);
2444 auto ShiftPartI8 = [&dl, &DAG, this](unsigned Opc, SDValue V, SDValue A) {
2447 SDValue ExtV = Opc == HexagonISD::VASR ? DAG.getSExtOrTrunc(V, dl, ExtTy)
2448 : DAG.getZExtOrTrunc(V, dl, ExtTy);
2449 SDValue ExtS = DAG.getNode(Opc, dl, ExtTy, {ExtV, A});
2450 return DAG.getZExtOrTrunc(ExtS, dl, Ty);
2456 auto [LoV, HiV] = opSplit(Val, dl, DAG);
2457 return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResTy,
2474 const SDLoc &dl(Op);
2480 SDValue Ext = DAG.getZExtOrTrunc(Sc, dl, MVT::i32);
2481 return getInstr(Hexagon::C2_tfrrp, dl, ResTy, Ext, DAG);
2520 HexagonTargetLowering::buildVector32(ArrayRef<SDValue> Elem, const SDLoc &dl,
2538 return getZero(dl, VecTy, DAG);
2547 return DAG.getBitcast(VecTy, DAG.getConstant(V, dl, MVT::i32));
2551 E0 = DAG.getZExtOrTrunc(DAG.getBitcast(MVT::i16, Elem[0]), dl, MVT::i32);
2552 E1 = DAG.getZExtOrTrunc(DAG.getBitcast(MVT::i16, Elem[1]), dl, MVT::i32);
2557 SDValue N = getInstr(Hexagon::A2_combine_ll, dl, MVT::i32, {E1, E0}, DAG);
2568 return DAG.getBitcast(MVT::v4i8, DAG.getConstant(V, dl, MVT::i32));
2581 SDValue Ext = DAG.getZExtOrTrunc(Elem[First], dl, MVT::i32);
2582 return DAG.getNode(ISD::SPLAT_VECTOR, dl, VecTy, Ext);
2591 Vs[i] = DAG.getZExtOrTrunc(Elem[i], dl, MVT::i32);
2592 Vs[i] = DAG.getZeroExtendInReg(Vs[i], dl, MVT::i8);
2594 SDValue S8 = DAG.getConstant(8, dl, MVT::i32);
2595 SDValue T0 = DAG.getNode(ISD::SHL, dl, MVT::i32, {Vs[1], S8});
2596 SDValue T1 = DAG.getNode(ISD::SHL, dl, MVT::i32, {Vs[3], S8});
2597 SDValue B0 = DAG.getNode(ISD::OR, dl, MVT::i32, {Vs[0], T0});
2598 SDValue B1 = DAG.getNode(ISD::OR, dl, MVT::i32, {Vs[2], T1});
2600 SDValue R = getInstr(Hexagon::A2_combine_ll, dl, MVT::i32, {B1, B0}, DAG);
2611 HexagonTargetLowering::buildVector64(ArrayRef<SDValue> Elem, const SDLoc &dl,
2629 return getZero(dl, VecTy, DAG);
2644 SDValue Ext = DAG.getZExtOrTrunc(S, dl, MVT::i32);
2645 return DAG.getNode(ISD::SPLAT_VECTOR, dl, VecTy, Ext);
2656 SDValue V0 = DAG.getConstant(Val, dl, MVT::i64);
2664 : buildVector32(Elem.take_front(Num/2), dl, HalfTy, DAG);
2667 : buildVector32(Elem.drop_front(Num/2), dl, HalfTy, DAG);
2668 return getCombine(H, L, dl, VecTy, DAG);
2673 const SDLoc &dl, MVT ValTy, MVT ResTy,
2679 return extractVectorPred(VecV, IdxV, dl, ValTy, ResTy, DAG);
2691 SDValue WidthV = DAG.getConstant(ValWidth, dl, MVT::i32);
2700 ExtV = DAG.getZeroExtendInReg(VecV, dl, tyScalar(ValTy));
2702 SDValue OffV = DAG.getConstant(Off, dl, MVT::i32);
2705 ExtV = DAG.getNode(HexagonISD::EXTRACTU, dl, ScalarTy,
2710 IdxV = DAG.getZExtOrTrunc(IdxV, dl, MVT::i32);
2711 SDValue OffV = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV,
2712 DAG.getConstant(ElemWidth, dl, MVT::i32));
2713 ExtV = DAG.getNode(HexagonISD::EXTRACTU, dl, ScalarTy,
2718 ExtV = DAG.getZExtOrTrunc(ExtV, dl, tyScalar(ResTy));
2725 const SDLoc &dl, MVT ValTy, MVT ResTy,
2741 return DAG.getNode(HexagonISD::TYPECAST, dl, MVT::i1, VecV);
2746 SDValue A0 = getInstr(Hexagon::C2_tfrpr, dl, MVT::i32, {VecV}, DAG);
2747 SDValue M0 = DAG.getConstant(8 / VecWidth, dl, MVT::i32);
2748 SDValue I0 = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, M0);
2749 return DAG.getNode(HexagonISD::TSTBIT, dl, MVT::i1, A0, I0);
2762 SDValue S0 = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV,
2763 DAG.getConstant(8*VecRep, dl, MVT::i32));
2764 SDValue T0 = DAG.getNode(HexagonISD::P2D, dl, MVT::i64, VecV);
2765 SDValue T1 = DAG.getNode(ISD::SRL, dl, MVT::i64, T0, S0);
2770 T1 = expandPredicate(T1, dl, DAG);
2774 return DAG.getNode(HexagonISD::D2P, dl, ResTy, T1);
2779 const SDLoc &dl, MVT ValTy,
2783 return insertVectorPred(VecV, ValV, IdxV, dl, ValTy, DAG);
2798 ValV = DAG.getAnyExtOrTrunc(ValV, dl, ScalarTy);
2800 SDValue WidthV = DAG.getConstant(ValWidth, dl, MVT::i32);
2805 SDValue OffV = DAG.getConstant(W, dl, MVT::i32);
2806 InsV = DAG.getNode(HexagonISD::INSERT, dl, ScalarTy,
2810 IdxV = DAG.getZExtOrTrunc(IdxV, dl, MVT::i32);
2811 SDValue OffV = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, WidthV);
2812 InsV = DAG.getNode(HexagonISD::INSERT, dl, ScalarTy,
2816 return DAG.getNode(ISD::BITCAST, dl, VecTy, InsV);
2821 SDValue IdxV, const SDLoc &dl,
2827 SDValue ToReg = getInstr(Hexagon::C2_tfrpr, dl, MVT::i32, {VecV}, DAG);
2828 SDValue Ext = DAG.getSExtOrTrunc(ValV, dl, MVT::i32);
2829 SDValue Width = DAG.getConstant(8 / VecLen, dl, MVT::i32);
2830 SDValue Idx = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, Width);
2832 DAG.getNode(HexagonISD::INSERT, dl, MVT::i32, {ToReg, Ext, Width, Idx});
2833 return getInstr(Hexagon::C2_tfrrp, dl, VecTy, {Ins}, DAG);
2838 ? DAG.getNode(HexagonISD::P2D, dl, MVT::i64, ValV)
2839 : DAG.getSExtOrTrunc(ValV, dl, MVT::i64);
2845 ValR = contractPredicate(ValR, dl, DAG);
2846 ValR = getCombine(DAG.getUNDEF(MVT::i32), ValR, dl, MVT::i64, DAG);
2849 SDValue Width = DAG.getConstant(64 / Scale, dl, MVT::i32);
2850 SDValue Idx = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, Width);
2851 SDValue VecR = DAG.getNode(HexagonISD::P2D, dl, MVT::i64, VecV);
2853 DAG.getNode(HexagonISD::INSERT, dl, MVT::i64, {VecR, ValR, Width, Idx});
2854 return DAG.getNode(HexagonISD::D2P, dl, VecTy, Ins);
2858 HexagonTargetLowering::expandPredicate(SDValue Vec32, const SDLoc &dl,
2864 SDValue X = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i16, P);
2869 HexagonTargetLowering::contractPredicate(SDValue Vec64, const SDLoc &dl,
2876 SDValue S = DAG.getVectorShuffle(MVT::v8i8, dl, A, DAG.getUNDEF(MVT::v8i8),
2878 return extractVector(S, DAG.getConstant(0, dl, MVT::i32), dl, MVT::v4i8,
2883 HexagonTargetLowering::getZero(const SDLoc &dl, MVT Ty, SelectionDAG &DAG)
2888 return DAG.getBitcast(Ty, DAG.getConstant(0, dl, MVT::getIntegerVT(W)));
2889 return DAG.getNode(ISD::SPLAT_VECTOR, dl, Ty, getZero(dl, MVT::i32, DAG));
2893 return DAG.getConstant(0, dl, Ty);
2895 return DAG.getConstantFP(0.0, dl, Ty);
2910 const SDLoc &dl(Val);
2918 return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResTy, Concats);
2922 HexagonTargetLowering::getCombine(SDValue Hi, SDValue Lo, const SDLoc &dl,
2930 SDValue Pair = DAG.getNode(ISD::BUILD_PAIR, dl, PairTy, Lo, Hi);
2938 DAG.getNode(ISD::BUILD_PAIR, dl, PairTy,
2947 const SDLoc &dl(Op);
2953 return buildVector32(Ops, dl, VecTy, DAG);
2955 return buildVector64(Ops, dl, VecTy, DAG);
2971 return DAG.getNode(HexagonISD::PFALSE, dl, VecTy);
2973 return DAG.getNode(HexagonISD::PTRUE, dl, VecTy);
2979 SDValue Z = getZero(dl, MVT::i32, DAG);
2983 SDValue S = DAG.getConstant(1ull << i, dl, MVT::i32);
2984 Rs[i] = DAG.getSelect(dl, MVT::i32, Ops[i/Rep], S, Z);
2988 Rs[i] = DAG.getNode(ISD::OR, dl, MVT::i32, Rs[2*i], Rs[2*i+1]);
2991 return getInstr(Hexagon::C2_tfrrp, dl, VecTy, {Rs[0]}, DAG);
3001 const SDLoc &dl(Op);
3004 return getCombine(Op.getOperand(1), Op.getOperand(0), dl, VecTy, DAG);
3024 SDValue W = DAG.getNode(HexagonISD::P2D, dl, MVT::i64, P);
3026 W = contractPredicate(W, dl, DAG);
3027 W = getCombine(DAG.getUNDEF(MVT::i32), W, dl, MVT::i64, DAG);
3034 SDValue WidthV = DAG.getConstant(64 / Scale, dl, MVT::i32);
3040 SDValue T = DAG.getNode(HexagonISD::INSERT, dl, MVT::i32,
3051 SDValue WW = getCombine(Words[IdxW][1], Words[IdxW][0], dl, MVT::i64, DAG);
3052 return DAG.getNode(HexagonISD::D2P, dl, VecTy, WW);
3104 const SDLoc &dl(Op);
3112 LN->getAddressingMode(), ISD::ZEXTLOAD, MVT::i32, dl, LN->getChain(),
3120 if (!validateConstPtrAlignment(LN->getBasePtr(), ClaimAlign, dl, DAG))
3127 SDValue TP = getInstr(Hexagon::C2_tfrrp, dl, MemTy, {LU}, DAG);
3129 TP = DAG.getSExtOrTrunc(TP, dl, Ty);
3131 TP = DAG.getZExtOrTrunc(TP, dl, Ty);
3134 return DAG.getMergeValues({TP, Ch}, dl);
3141 const SDLoc &dl(Op);
3148 SDValue TR = getInstr(Hexagon::C2_tfrpr, dl, MVT::i32, {Val}, DAG);
3149 SDValue NS = DAG.getTruncStore(SN->getChain(), dl, TR, SN->getBasePtr(),
3152 NS = DAG.getIndexedStore(NS, dl, SN->getBasePtr(), SN->getOffset(),
3159 if (!validateConstPtrAlignment(SN->getBasePtr(), ClaimAlign, dl, DAG))
3179 const SDLoc &dl(Op);
3205 return DAG.getMergeValues({P.first, P.second}, dl);
3224 BO.first = DAG.getNode(ISD::ADD, dl, MVT::i32, BO.first,
3225 DAG.getConstant(BO.second % LoadLen, dl, MVT::i32));
3229 ? DAG.getNode(HexagonISD::VALIGNADDR, dl, MVT::i32, BO.first,
3230 DAG.getConstant(NeedAlign, dl, MVT::i32))
3233 DAG.getMemBasePlusOffset(BaseNoOff, TypeSize::getFixed(BO.second), dl);
3235 BaseNoOff, TypeSize::getFixed(BO.second + LoadLen), dl);
3246 SDValue Load0 = DAG.getLoad(LoadTy, dl, Chain, Base0, WideMMO);
3247 SDValue Load1 = DAG.getLoad(LoadTy, dl, Chain, Base1, WideMMO);
3249 SDValue Aligned = DAG.getNode(HexagonISD::VALIGN, dl, LoadTy,
3251 SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3253 SDValue M = DAG.getMergeValues({Aligned, NewChain}, dl);
3264 const SDLoc &dl(Op);
3278 SDValue Op = DAG.getNode(ISD::ADD, dl, VTs.VTs[0], {X, Y});
3279 SDValue Ov = DAG.getSetCC(dl, MVT::i1, Op, getZero(dl, ty(Op), DAG),
3281 return DAG.getMergeValues({Op, Ov}, dl);
3284 SDValue Op = DAG.getNode(ISD::SUB, dl, VTs.VTs[0], {X, Y});
3285 SDValue Ov = DAG.getSetCC(dl, MVT::i1, Op,
3286 DAG.getConstant(-1, dl, ty(Op)), ISD::SETEQ);
3287 return DAG.getMergeValues({Op, Ov}, dl);
3296 const SDLoc &dl(Op);
3301 return DAG.getNode(HexagonISD::ADDC, dl, Op.getNode()->getVTList(),
3305 SDValue SubC = DAG.getNode(HexagonISD::SUBC, dl, Op.getNode()->getVTList(),
3306 { X, Y, DAG.getLogicalNOT(dl, C, CarryTy) });
3308 DAG.getLogicalNOT(dl, SubC.getValue(1), CarryTy) };
3309 return DAG.getMergeValues(Out, dl);
3317 SDLoc dl(Op);
3328 DAG.getNode(ISD::ADD, dl, PtrVT, DAG.getRegister(Hexagon::R30, PtrVT),
3329 DAG.getIntPtrConstant(4, dl));
3330 Chain = DAG.getStore(Chain, dl, Handler, StoreAddr, MachinePointerInfo());
3331 Chain = DAG.getCopyToReg(Chain, dl, OffsetReg, Offset);
3336 return DAG.getNode(HexagonISD::EH_RETURN, dl, MVT::Other, Chain);
3449 const SDLoc &dl(N);
3459 SDValue P = getInstr(Hexagon::C2_tfrpr, dl, MVT::i32,
3461 SDValue T = DAG.getAnyExtOrTrunc(P, dl, MVT::i8);
3479 const SDLoc &dl(Op);
3493 return DCI.DAG.getNode(ISD::TRUNCATE, dl, TruncTy, Elem0);
3504 return DCI.DAG.getConstant(-1, dl, ty(Op));
3506 return getZero(dl, ty(Op), DCI.DAG);
3518 SDValue VSel = DCI.DAG.getNode(ISD::VSELECT, dl, ty(Op), C0,
3534 return DCI.DAG.getNode(ISD::TRUNCATE, dl, TruncTy, Elem0);
3555 SDValue T0 = DCI.DAG.getNode(ISD::SHL, dl, ty(S), S,
3556 DCI.DAG.getConstant(A - 32, dl, MVT::i32));
3557 SDValue T1 = DCI.DAG.getZExtOrTrunc(T0, dl, MVT::i32);
3558 SDValue T2 = DCI.DAG.getZExtOrTrunc(Z, dl, MVT::i32);
3559 return DCI.DAG.getNode(HexagonISD::COMBINE, dl, MVT::i64, {T1, T2});