Lines Matching defs:CurDAG
145 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i64);
202 Res2 = CurDAG->getTargetConstant(ShtAmt, SDLoc(N), MVT::i32);
309 Imm = CurDAG->getTargetConstant(MulImm, SDLoc(N), MVT::i32);
325 Imm = CurDAG->getTargetConstant(MulImm, SDLoc(N), MVT::i32);
340 Imm = CurDAG->getRegister(BaseReg + C, MVT::Other);
578 SDValue RC = CurDAG->getTargetConstant(TRC->getID(), dl, MVT::i64);
580 SDValue(CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
615 Val = CurDAG->getTargetConstant(Immed, dl, MVT::i32);
616 Shift = CurDAG->getTargetConstant(ShVal, dl, MVT::i32);
649 return SelectArithImmed(CurDAG->getConstant(Immed, SDLoc(N), MVT::i32), Val,
699 if (CurDAG->shouldOptForSize() || V.hasOneUse())
792 SDValue NewShiftAmt = CurDAG->getTargetConstant(NewShiftC, DL, VT);
793 SDValue BitWidthMinus1 = CurDAG->getTargetConstant(BitWidth - 1, DL, VT);
794 Reg = SDValue(CurDAG->getMachineNode(NewShiftOp, DL, VT, LHS->getOperand(0),
798 Shift = CurDAG->getTargetConstant(ShVal, DL, MVT::i32);
863 if (CurDAG->shouldOptForSize() || V.hasOneUse())
899 Shift = CurDAG->getTargetConstant(ShVal, SDLoc(N), MVT::i32);
910 static SDValue narrowIfNeeded(SelectionDAG *CurDAG, SDValue N) {
915 return CurDAG->getTargetExtractSubreg(AArch64::sub_32, dl, MVT::i32, N);
928 Imm = CurDAG->getTargetConstant(RDVLImm, SDLoc(N), MVT::i32);
983 Reg = narrowIfNeeded(CurDAG, Reg);
984 Shift = CurDAG->getTargetConstant(getArithExtendImm(Ext, ShiftVal), SDLoc(N),
1008 Shift = CurDAG->getTargetConstant(getArithExtendImm(Ext, ShiftVal), SDLoc(N),
1051 const DataLayout &DL = CurDAG->getDataLayout();
1055 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
1056 OffImm = CurDAG->getTargetConstant(0, dl, MVT::i64);
1062 if (CurDAG->isBaseWithConstantOffset(N)) {
1074 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
1076 OffImm = CurDAG->getTargetConstant(RHSC >> Scale, dl, MVT::i64);
1089 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
1091 OffImm = CurDAG->getTargetConstant(RHSC >> Scale, dl, MVT::i64);
1102 OffImm = CurDAG->getTargetConstant(0, dl, MVT::i64);
1112 const DataLayout &DL = CurDAG->getDataLayout();
1116 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
1117 OffImm = CurDAG->getTargetConstant(0, dl, MVT::i64);
1134 if (CurDAG->isBaseWithConstantOffset(N)) {
1142 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
1144 OffImm = CurDAG->getTargetConstant(RHSC >> Scale, dl, MVT::i64);
1160 OffImm = CurDAG->getTargetConstant(0, dl, MVT::i64);
1172 if (!CurDAG->isBaseWithConstantOffset(N))
1181 Base = CurDAG->getTargetFrameIndex(
1182 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
1184 OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i64);
1191 static SDValue Widen(SelectionDAG *CurDAG, SDValue N) {
1194 CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, MVT::i64), 0);
1195 return CurDAG->getTargetInsertSubreg(AArch64::sub_32, dl, MVT::i64, ImpDef,
1216 Offset = narrowIfNeeded(CurDAG, N.getOperand(0).getOperand(0));
1217 SignExtend = CurDAG->getTargetConstant(Ext == AArch64_AM::SXTW, dl,
1221 SignExtend = CurDAG->getTargetConstant(0, dl, MVT::i32);
1264 DoShift = CurDAG->getTargetConstant(true, dl, MVT::i32);
1272 DoShift = CurDAG->getTargetConstant(true, dl, MVT::i32);
1277 DoShift = CurDAG->getTargetConstant(false, dl, MVT::i32);
1285 Offset = narrowIfNeeded(CurDAG, LHS.getOperand(0));
1286 SignExtend = CurDAG->getTargetConstant(Ext == AArch64_AM::SXTW, dl,
1297 Offset = narrowIfNeeded(CurDAG, RHS.getOperand(0));
1298 SignExtend = CurDAG->getTargetConstant(Ext == AArch64_AM::SXTW, dl,
1363 CurDAG->getMachineNode(AArch64::MOVi64imm, DL, MVT::i64, Ops);
1366 N = CurDAG->getNode(ISD::ADD, DL, MVT::i64, LHS, MOVIV);
1376 DoShift = CurDAG->getTargetConstant(true, DL, MVT::i32);
1384 DoShift = CurDAG->getTargetConstant(true, DL, MVT::i32);
1391 SignExtend = CurDAG->getTargetConstant(false, DL, MVT::i32);
1392 DoShift = CurDAG->getTargetConstant(false, DL, MVT::i32);
1453 CurDAG->getTargetConstant(RegClassIDs[Regs.size() - 2], DL, MVT::i32));
1458 Ops.push_back(CurDAG->getTargetConstant(SubRegs[i], DL, MVT::i32));
1462 CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, DL, MVT::Untyped, Ops);
1484 ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, VT, Ops));
1528 AUTKey = CurDAG->getTargetConstant(AUTKeyC, DL, MVT::i64);
1532 extractPtrauthBlendDiscriminators(AUTDisc, CurDAG);
1534 SDValue X16Copy = CurDAG->getCopyToReg(CurDAG->getEntryNode(), DL,
1538 SDNode *AUT = CurDAG->getMachineNode(AArch64::AUT, DL, MVT::i64, Ops);
1555 AUTKey = CurDAG->getTargetConstant(AUTKeyC, DL, MVT::i64);
1556 PACKey = CurDAG->getTargetConstant(PACKeyC, DL, MVT::i64);
1560 extractPtrauthBlendDiscriminators(AUTDisc, CurDAG);
1564 extractPtrauthBlendDiscriminators(PACDisc, CurDAG);
1566 SDValue X16Copy = CurDAG->getCopyToReg(CurDAG->getEntryNode(), DL,
1572 SDNode *AUTPAC = CurDAG->getMachineNode(AArch64::AUTPAC, DL, MVT::i64, Ops);
1650 SDValue Offset = CurDAG->getTargetConstant(OffsetVal, dl, MVT::i64);
1652 SDNode *Res = CurDAG->getMachineNode(Opcode, dl, MVT::i64, DstVT,
1657 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Res), {MemOp});
1662 SDValue SubReg = CurDAG->getTargetConstant(AArch64::sub_32, dl, MVT::i32);
1664 SDValue(CurDAG->getMachineNode(
1666 CurDAG->getTargetConstant(0, dl, MVT::i64), LoadedVal,
1674 CurDAG->RemoveDeadNode(N);
1689 SDNode *Ld = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
1693 CurDAG->getTargetExtractSubreg(SubRegIdx + i, dl, VT, SuperReg));
1701 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Ld), {MemOp});
1704 CurDAG->RemoveDeadNode(N);
1720 SDNode *Ld = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
1732 CurDAG->getTargetExtractSubreg(SubRegIdx + i, dl, VT, SuperReg));
1736 CurDAG->RemoveDeadNode(N);
1835 SDNode *WhilePair = CurDAG->getMachineNode(Opc, DL, MVT::Untyped, Ops);
1839 ReplaceUses(SDValue(N, I), CurDAG->getTargetExtractSubreg(
1842 CurDAG->RemoveDeadNode(N);
1851 SDNode *WhilePair = CurDAG->getMachineNode(Opc, DL, MVT::Untyped, Ops);
1855 ReplaceUses(SDValue(N, I), CurDAG->getTargetExtractSubreg(
1858 CurDAG->RemoveDeadNode(N);
1867 SDNode *Intrinsic = CurDAG->getMachineNode(Opcode, DL, MVT::Untyped, Ops);
1870 ReplaceUses(SDValue(N, i), CurDAG->getTargetExtractSubreg(
1873 CurDAG->RemoveDeadNode(N);
1903 Intrinsic = CurDAG->getMachineNode(Opcode, DL, MVT::Untyped,
1906 Intrinsic = CurDAG->getMachineNode(Opcode, DL, MVT::Untyped, Zdn, Zm);
1909 ReplaceUses(SDValue(N, i), CurDAG->getTargetExtractSubreg(
1912 CurDAG->RemoveDeadNode(N);
1928 CurDAG->getTargetConstant(0, DL, MVT::i64), Scale);
1936 SDNode *Load = CurDAG->getMachineNode(Opc, DL, ResTys, Ops);
1939 ReplaceUses(SDValue(N, i), CurDAG->getTargetExtractSubreg(
1945 CurDAG->RemoveDeadNode(N);
1960 SDValue Offset = CurDAG->getTargetConstant(0, DL, MVT::i64);
1971 SDNode *Load = CurDAG->getMachineNode(Opc, DL, ResTys, Ops);
1974 ReplaceUses(SDValue(N, i), CurDAG->getTargetExtractSubreg(
1980 CurDAG->RemoveDeadNode(N);
2005 CurDAG->getMachineNode(Opc, DL, {MVT::Untyped, MVT::Other}, Ops);
2009 ReplaceUses(SDValue(Node, I), CurDAG->getTargetExtractSubreg(
2015 CurDAG->RemoveDeadNode(Node);
2030 SDNode *Intrinsic = CurDAG->getMachineNode(Op, DL, MVT::Untyped, Ops);
2033 ReplaceUses(SDValue(N, i), CurDAG->getTargetExtractSubreg(
2036 CurDAG->RemoveDeadNode(N);
2086 SDValue SubReg = CurDAG->getRegister(BaseReg, MVT::Other);
2088 SDNode *Mov = CurDAG->getMachineNode(Op, DL, {MVT::Untyped, MVT::Other}, Ops);
2093 CurDAG->getTargetExtractSubreg(AArch64::zsub0 + I, DL, VT,
2098 CurDAG->RemoveDeadNode(N);
2124 SDNode *Mov = CurDAG->getMachineNode(Op, DL, {MVT::Untyped, MVT::Other}, Ops);
2129 CurDAG->getTargetExtractSubreg(AArch64::zsub0 + I, DL, VT,
2135 CurDAG->RemoveDeadNode(N);
2159 SDNode *Res = CurDAG->getMachineNode(Opc, DL, MVT::Untyped, Ops);
2163 ReplaceUses(SDValue(N, I), CurDAG->getTargetExtractSubreg(
2165 CurDAG->RemoveDeadNode(N);
2179 SDNode *St = CurDAG->getMachineNode(Opc, dl, N->getValueType(0), Ops);
2183 CurDAG->setNodeMemRefs(cast<MachineSDNode>(St), {MemOp});
2202 CurDAG->getTargetConstant(0, dl, MVT::i64), Scale);
2208 SDNode *St = CurDAG->getMachineNode(Opc, dl, N->getValueType(0), Ops);
2216 const DataLayout &DL = CurDAG->getDataLayout();
2222 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
2223 OffImm = CurDAG->getTargetConstant(0, dl, MVT::i64);
2246 SDNode *St = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
2297 WidenVector(*CurDAG));
2305 SDValue Ops[] = {RegSeq, CurDAG->getTargetConstant(LaneNo, dl, MVT::i64),
2307 SDNode *Ld = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
2314 SDValue NV = CurDAG->getTargetExtractSubreg(QSubs[i], dl, WideVT, SuperReg);
2316 NV = NarrowVector(NV, *CurDAG);
2321 CurDAG->RemoveDeadNode(N);
2335 WidenVector(*CurDAG));
2345 CurDAG->getTargetConstant(LaneNo, dl,
2350 SDNode *Ld = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
2359 Narrow ? NarrowVector(SuperReg, *CurDAG) : SuperReg);
2365 SDValue NV = CurDAG->getTargetExtractSubreg(QSubs[i], dl, WideVT,
2368 NV = NarrowVector(NV, *CurDAG);
2375 CurDAG->RemoveDeadNode(N);
2389 WidenVector(*CurDAG));
2395 SDValue Ops[] = {RegSeq, CurDAG->getTargetConstant(LaneNo, dl, MVT::i64),
2397 SDNode *St = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
2401 CurDAG->setNodeMemRefs(cast<MachineSDNode>(St), {MemOp});
2417 WidenVector(*CurDAG));
2426 SDValue Ops[] = {RegSeq, CurDAG->getTargetConstant(LaneNo, dl, MVT::i64),
2430 SDNode *St = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
2434 CurDAG->setNodeMemRefs(cast<MachineSDNode>(St), {MemOp});
2439 static bool isBitfieldExtractOpFromAnd(SelectionDAG *CurDAG, SDNode *N,
2483 Opd0 = Widen(CurDAG, Op0->getOperand(0).getOperand(0));
2688 SDValue Opd0 = Widen(CurDAG, Op.getOperand(0));
2691 SDValue Ops[] = {Opd0, CurDAG->getTargetConstant(Immr, dl, VT),
2692 CurDAG->getTargetConstant(Imms, dl, VT)};
2693 CurDAG->SelectNodeTo(N, AArch64::SBFMXri, VT, Ops);
2697 static bool isBitfieldExtractOp(SelectionDAG *CurDAG, SDNode *N, unsigned &Opc,
2710 return isBitfieldExtractOpFromAnd(CurDAG, N, Opc, Opd0, Immr, Imms,
2741 if (!isBitfieldExtractOp(CurDAG, N, Opc, Opd0, Immr, Imms))
2750 SDValue Ops64[] = {Opd0, CurDAG->getTargetConstant(Immr, dl, MVT::i64),
2751 CurDAG->getTargetConstant(Imms, dl, MVT::i64)};
2753 SDNode *BFM = CurDAG->getMachineNode(Opc, dl, MVT::i64, Ops64);
2754 SDValue Inner = CurDAG->getTargetExtractSubreg(AArch64::sub_32, dl,
2760 SDValue Ops[] = {Opd0, CurDAG->getTargetConstant(Immr, dl, VT),
2761 CurDAG->getTargetConstant(Imms, dl, VT)};
2762 CurDAG->SelectNodeTo(N, Opc, VT, Ops);
3004 static SDValue getLeftShift(SelectionDAG *CurDAG, SDValue Op, int ShlAmount) {
3016 ShiftNode = CurDAG->getMachineNode(
3018 CurDAG->getTargetConstant(BitWidth - ShlAmount, dl, VT),
3019 CurDAG->getTargetConstant(BitWidth - 1 - ShlAmount, dl, VT));
3024 ShiftNode = CurDAG->getMachineNode(
3025 UBFMOpc, dl, VT, Op, CurDAG->getTargetConstant(ShrAmount, dl, VT),
3026 CurDAG->getTargetConstant(BitWidth - 1, dl, VT));
3033 static bool isBitfieldPositioningOpFromAnd(SelectionDAG *CurDAG, SDValue Op,
3040 static bool isBitfieldPositioningOpFromShl(SelectionDAG *CurDAG, SDValue Op,
3048 static bool isBitfieldPositioningOp(SelectionDAG *CurDAG, SDValue Op,
3056 KnownBits Known = CurDAG->computeKnownBits(Op);
3068 return isBitfieldPositioningOpFromAnd(CurDAG, Op, BiggerPattern,
3071 return isBitfieldPositioningOpFromShl(CurDAG, Op, BiggerPattern,
3078 static bool isBitfieldPositioningOpFromAnd(SelectionDAG *CurDAG, SDValue Op,
3123 ShlOp0 = Widen(CurDAG, ShlVal.getOperand(0));
3162 Src = getLeftShift(CurDAG, ShlOp0, ShlImm - DstLSB);
3200 static bool isBitfieldPositioningOpFromShl(SelectionDAG *CurDAG, SDValue Op,
3228 Src = getLeftShift(CurDAG, Op.getOperand(0), ShlImm - DstLSB);
3241 static bool tryBitfieldInsertOpFromOrAndImm(SDNode *N, SelectionDAG *CurDAG) {
3269 KnownBits Known = CurDAG->computeKnownBits(And);
3317 SDNode *MOVI = CurDAG->getMachineNode(
3318 MOVIOpc, DL, VT, CurDAG->getTargetConstant(BFIImm, DL, VT));
3322 CurDAG->getTargetConstant(ImmR, DL, VT),
3323 CurDAG->getTargetConstant(ImmS, DL, VT)};
3325 CurDAG->SelectNodeTo(N, Opc, VT, Ops);
3329 static bool isWorthFoldingIntoOrrWithShift(SDValue Dst, SelectionDAG *CurDAG,
3371 SDNode *UBFMNode = CurDAG->getMachineNode(
3373 CurDAG->getTargetConstant(SrlImm + NumTrailingZeroInShiftedMask, DL,
3375 CurDAG->getTargetConstant(
3405 SDValue Src, SDValue Dst, SelectionDAG *CurDAG,
3435 if (isWorthFoldingIntoOrrWithShift(Dst, CurDAG, ShiftedOperand,
3438 CurDAG->getTargetConstant(EncodedShiftImm, DL, VT)};
3439 CurDAG->SelectNodeTo(N, OrrOpc, VT, Ops);
3453 CurDAG->getTargetConstant(
3455 CurDAG->SelectNodeTo(N, OrrOpc, VT, Ops);
3472 CurDAG->getTargetConstant(
3474 CurDAG->SelectNodeTo(N, OrrOpc, VT, Ops);
3494 CurDAG->getTargetConstant(
3496 CurDAG->SelectNodeTo(N, OrrOpc, VT, Ops);
3505 SelectionDAG *CurDAG) {
3550 if (isBitfieldExtractOp(CurDAG, OrOpd0, BFXOpc, Src, ImmR, ImmS,
3569 } else if (isBitfieldPositioningOp(CurDAG, OrOpd0Val,
3585 KnownBits Known = CurDAG->computeKnownBits(OrOpd1Val);
3608 if (tryOrrWithShift(N, OrOpd0Val, OrOpd1Val, Src, Dst, CurDAG,
3614 SDValue Ops[] = {Dst, Src, CurDAG->getTargetConstant(ImmR, DL, VT),
3615 CurDAG->getTargetConstant(ImmS, DL, VT)};
3617 CurDAG->SelectNodeTo(N, Opc, VT, Ops);
3658 SDNode *LSR = CurDAG->getMachineNode(
3659 ShiftOpc, DL, VT, Src, CurDAG->getTargetConstant(LsrImm, DL, VT),
3660 CurDAG->getTargetConstant(BitWidth - 1, DL, VT));
3668 CurDAG->getTargetConstant(ImmR, DL, VT),
3669 CurDAG->getTargetConstant(ImmS, DL, VT)};
3671 CurDAG->SelectNodeTo(N, Opc, VT, Ops);
3687 CurDAG->SelectNodeTo(N, TargetOpcode::IMPLICIT_DEF, N->getValueType(0));
3691 if (tryBitfieldInsertOpFromOr(N, NUsefulBits, CurDAG))
3694 return tryBitfieldInsertOpFromOrAndImm(N, CurDAG);
3710 if (!isBitfieldPositioningOp(CurDAG, SDValue(N, 0), /*BiggerPattern=*/false,
3720 SDValue Ops[] = {Op0, CurDAG->getTargetConstant(ImmR, DL, VT),
3721 CurDAG->getTargetConstant(ImmS, DL, VT)};
3723 CurDAG->SelectNodeTo(N, Opc, VT, Ops);
3796 CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL, ZeroReg, SubVT);
3798 CurDAG->getMachineNode(NegOpc, DL, SubVT, Zero, Add1);
3816 CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL, ZeroReg, SubVT);
3818 CurDAG->getMachineNode(NotOpc, DL, SubVT, Zero, Add1);
3839 NewShiftAmt = narrowIfNeeded(CurDAG, NewShiftAmt);
3841 SDValue SubReg = CurDAG->getTargetConstant(AArch64::sub_32, DL, MVT::i32);
3842 MachineSDNode *Ext = CurDAG->getMachineNode(
3844 CurDAG->getTargetConstant(0, DL, MVT::i64), NewShiftAmt, SubReg);
3849 CurDAG->SelectNodeTo(N, Opc, VT, Ops);
3853 static bool checkCVTFixedPointOperandWithFBits(SelectionDAG *CurDAG, SDValue N,
3899 FixedPos = CurDAG->getTargetConstant(FBits, SDLoc(N), MVT::i32);
3905 return checkCVTFixedPointOperandWithFBits(CurDAG, N, FixedPos, RegWidth,
3912 return checkCVTFixedPointOperandWithFBits(CurDAG, N, FixedPos, RegWidth,
3984 SDValue SysRegImm = CurDAG->getTargetConstant(Imm, DL, MVT::i32);
3986 CurDAG->SelectNodeTo(N, Opcode64Bit, MVT::i64, MVT::Other /* Chain */,
3989 SDNode *MRRS = CurDAG->getMachineNode(
3996 SDValue Lo = CurDAG->getTargetExtractSubreg(AArch64::sube64, DL, MVT::i64,
3998 SDValue Hi = CurDAG->getTargetExtractSubreg(AArch64::subo64, DL, MVT::i64,
4032 CurDAG->SelectNodeTo(
4033 N, State, MVT::Other, CurDAG->getTargetConstant(Reg, DL, MVT::i32),
4034 CurDAG->getTargetConstant(Immed, DL, MVT::i16), N->getOperand(0));
4068 CurDAG->SelectNodeTo(N, AArch64::MSR, MVT::Other,
4069 CurDAG->getTargetConstant(Imm, DL, MVT::i32),
4074 SDNode *Pair = CurDAG->getMachineNode(
4076 {CurDAG->getTargetConstant(AArch64::XSeqPairsClassRegClass.getID(), DL,
4079 CurDAG->getTargetConstant(AArch64::sube64, DL, MVT::i32),
4081 CurDAG->getTargetConstant(AArch64::subo64, DL, MVT::i32)});
4083 CurDAG->SelectNodeTo(N, AArch64::MSRR, MVT::Other,
4084 CurDAG->getTargetConstant(Imm, DL, MVT::i32),
4113 SDNode *CmpSwap = CurDAG->getMachineNode(
4115 CurDAG->getVTList(RegTy, MVT::i32, MVT::Other), Ops);
4118 CurDAG->setNodeMemRefs(cast<MachineSDNode>(CmpSwap), {MemOp});
4122 CurDAG->RemoveDeadNode(N);
4141 Shift = CurDAG->getTargetConstant(0, DL, MVT::i32);
4142 Imm = CurDAG->getTargetConstant(Val, DL, MVT::i32);
4149 Shift = CurDAG->getTargetConstant(0, DL, MVT::i32);
4150 Imm = CurDAG->getTargetConstant(Val, DL, MVT::i32);
4155 Shift = CurDAG->getTargetConstant(8, DL, MVT::i32);
4156 Imm = CurDAG->getTargetConstant(Val >> 8, DL, MVT::i32);
4191 Shift = CurDAG->getTargetConstant(0, DL, MVT::i32);
4192 Imm = CurDAG->getTargetConstant(Val, DL, MVT::i32);
4199 Shift = CurDAG->getTargetConstant(0, DL, MVT::i32);
4200 Imm = CurDAG->getTargetConstant(Val, DL, MVT::i32);
4205 Shift = CurDAG->getTargetConstant(8, DL, MVT::i32);
4206 Imm = CurDAG->getTargetConstant(Val >> 8, DL, MVT::i32);
4231 Shift = CurDAG->getTargetConstant(0, DL, MVT::i32);
4232 Imm = CurDAG->getTargetConstant(Val & 0xFF, DL, MVT::i32);
4239 Shift = CurDAG->getTargetConstant(0, DL, MVT::i32);
4240 Imm = CurDAG->getTargetConstant(Val & 0xFF, DL, MVT::i32);
4245 Shift = CurDAG->getTargetConstant(8, DL, MVT::i32);
4246 Imm = CurDAG->getTargetConstant((Val >> 8) & 0xFF, DL, MVT::i32);
4262 Imm = CurDAG->getTargetConstant(ImmVal, DL, MVT::i32);
4290 Imm = CurDAG->getTargetConstant(ImmVal, SDLoc(N), MVT::i32);
4331 Imm = CurDAG->getTargetConstant(encoding, DL, MVT::i64);
4360 Imm = CurDAG->getTargetConstant(ImmVal, SDLoc(N), MVT::i32);
4384 SDValue FiOp = CurDAG->getTargetFrameIndex(
4385 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
4388 SDNode *Out = CurDAG->getMachineNode(
4390 {FiOp, CurDAG->getTargetConstant(0, DL, MVT::i64), N->getOperand(2),
4391 CurDAG->getTargetConstant(TagOffset, DL, MVT::i64)});
4407 SDNode *N1 = CurDAG->getMachineNode(AArch64::SUBP, DL, MVT::i64,
4409 SDNode *N2 = CurDAG->getMachineNode(AArch64::ADDXrr, DL, MVT::i64,
4411 SDNode *N3 = CurDAG->getMachineNode(
4413 {SDValue(N2, 0), CurDAG->getTargetConstant(0, DL, MVT::i64),
4414 CurDAG->getTargetConstant(TagOffset, DL, MVT::i64)});
4443 auto RC = CurDAG->getTargetConstant(AArch64::ZPRRegClassID, DL, MVT::i64);
4444 ReplaceNode(N, CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS, DL, VT,
4472 auto RC = CurDAG->getTargetConstant(AArch64::ZPRRegClassID, DL, MVT::i64);
4473 ReplaceNode(N, CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS, DL, VT,
4505 if (!TLI->isAllActivePredicate(*CurDAG, N0.getOperand(0)) ||
4506 !TLI->isAllActivePredicate(*CurDAG, N1.getOperand(0)))
4523 CurDAG->getTargetConstant(ShrAmt.getZExtValue(), DL, MVT::i32);
4529 CurDAG->SelectNodeTo(N, Opc, VT, Ops);
4554 SDValue Imm = CurDAG->getTargetConstant(
4561 CurDAG->SelectNodeTo(N, AArch64::XAR, N0.getValueType(), Ops);
4569 LLVM_DEBUG(errs() << "== "; Node->dump(CurDAG); errs() << "\n");
4651 SDValue New = CurDAG->getCopyFromReg(
4652 CurDAG->getEntryNode(), SDLoc(Node), AArch64::WZR, MVT::i32);
4656 SDValue New = CurDAG->getCopyFromReg(
4657 CurDAG->getEntryNode(), SDLoc(Node), AArch64::XZR, MVT::i64);
4670 SDValue TFI = CurDAG->getTargetFrameIndex(
4671 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
4673 SDValue Ops[] = { TFI, CurDAG->getTargetConstant(0, DL, MVT::i32),
4674 CurDAG->getTargetConstant(Shifter, DL, MVT::i32) };
4675 CurDAG->SelectNodeTo(Node, AArch64::ADDXri, MVT::i64, Ops);
4687 SDValue Zero = CurDAG->getCopyFromReg(Chain, DL, AArch64::XZR, MVT::i64);
4689 CurDAG->getMachineNode(AArch64::GCSSS1, DL, MVT::Other, Val, Chain);
4690 SDNode *SS2 = CurDAG->getMachineNode(AArch64::GCSSS2, DL, MVT::i64,
4703 SDNode *Ld = CurDAG->getMachineNode(Op, DL, MVT::i64, MVT::i64,
4709 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Ld), {MemOp});
4726 SDNode *St = CurDAG->getMachineNode(Op, DL, MVT::i32, MVT::Other, Ops);
4730 CurDAG->setNodeMemRefs(cast<MachineSDNode>(St), {MemOp});
5473 SDValue CopyFP = CurDAG->getCopyFromReg(Chain, DL, AArch64::FP, MVT::i64);
5475 CurDAG->getMachineNode(AArch64::SUBXri, DL, MVT::i64, CopyFP,
5476 CurDAG->getTargetConstant(8, DL, MVT::i32),
5477 CurDAG->getTargetConstant(0, DL, MVT::i32)),
5481 CurDAG->RemoveDeadNode(Node);
5483 auto &MF = CurDAG->getMachineFunction();
7222 const EVT MemVT = getMemVTFromNode(*(CurDAG->getContext()), Root);
7223 const DataLayout &DL = CurDAG->getDataLayout();
7231 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
7232 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i64);
7266 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
7269 OffImm = CurDAG->getTargetConstant(Offset, SDLoc(N), MVT::i64);
7304 Offset = CurDAG->getTargetConstant(ImmOff >> Scale, DL, MVT::i64);
7306 SDNode *MI = CurDAG->getMachineNode(AArch64::MOVi64imm, DL, MVT::i64, Ops);
7330 return TLI->isAllActivePredicate(*CurDAG, N);
7347 Offset = CurDAG->getTargetConstant(ImmOff / Scale, SDLoc(N), MVT::i64);
7354 Offset = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i64);