Lines Matching defs:CurDAG
270 Base = CurDAG->getTargetFrameIndex(
271 AM.Base_FrameIndex, TLI->getPointerTy(CurDAG->getDataLayout()));
275 Base = CurDAG->getRegister(0, VT);
284 SDValue Neg = SDValue(CurDAG->getMachineNode(NegOpc, DL, VT, MVT::i32,
292 Index = CurDAG->getRegister(0, VT);
297 Disp = CurDAG->getTargetGlobalAddress(AM.GV, SDLoc(),
301 Disp = CurDAG->getTargetConstantPool(AM.CP, MVT::i32, AM.Alignment,
305 Disp = CurDAG->getTargetExternalSymbol(AM.ES, MVT::i32, AM.SymbolFlags);
309 Disp = CurDAG->getMCSymbol(AM.MCSym, MVT::i32);
312 Disp = CurDAG->getTargetJumpTable(AM.JT, MVT::i32, AM.SymbolFlags);
314 Disp = CurDAG->getTargetBlockAddress(AM.BlockAddr, MVT::i32, AM.Disp,
317 Disp = CurDAG->getTargetConstant(AM.Disp, DL, MVT::i32);
322 Segment = CurDAG->getRegister(0, MVT::i16);
337 if (!CurDAG->shouldOptForSize())
408 return CurDAG->getTargetConstant(Imm, DL, MVT::i8);
413 return CurDAG->getTargetConstant(Imm, DL, MVT::i32);
418 return CurDAG->getTargetConstant(Imm, DL, MVT::i64);
454 SDVTList VTs = CurDAG->getVTList(MVT::i32, MVT::i32);
456 CurDAG->getMachineNode(X86::MOV32r0, dl, VTs, std::nullopt), 0);
459 CurDAG->getMachineNode(
461 CurDAG->getTargetConstant(0, dl, MVT::i64), Zero,
462 CurDAG->getTargetConstant(X86::sub_32bit, dl, MVT::i32)),
472 CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EFLAGS,
479 VTs = CurDAG->getVTList(SBBVT, MVT::i32);
481 CurDAG->getMachineNode(Opc, dl, VTs,
495 APInt Mask = Val | CurDAG->computeKnownBits(N->getOperand(0)).Zero;
800 static void moveBelowOrigChain(SelectionDAG *CurDAG, SDValue Load,
815 CurDAG->getNode(ISD::TokenFactor, SDLoc(Load), MVT::Other, Ops);
820 CurDAG->UpdateNodeOperands(OrigChain.getNode(), Ops);
821 CurDAG->UpdateNodeOperands(Load.getNode(), Call.getOperand(0),
827 CurDAG->UpdateNodeOperands(Call.getNode(), Ops);
899 for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
900 E = CurDAG->allnodes_end(); I != E; ) {
929 SDValue Complement = CurDAG->getConstant(~Imm, dl, VT, false, true);
930 Complement = CurDAG->getNOT(dl, Complement, VT);
932 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Complement);
943 SDValue Res = CurDAG->getNode(ISD::AND, SDLoc(N), N->getValueType(0),
946 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
985 CurDAG->getAllOnesConstant(DL, MVT::getVectorVT(MVT::i32, NumElts));
986 AllOnes = CurDAG->getBitcast(VT, AllOnes);
990 CurDAG->getNode(NewOpcode, DL, VT, N->getOperand(0), AllOnes);
992 CurDAG->ReplaceAllUsesWith(N, Res.getNode());
1007 CurDAG->getNode(X86ISD::VBROADCAST, dl, NarrowVT, N->getOperand(0));
1009 CurDAG->getNode(ISD::INSERT_SUBVECTOR, dl, VT, CurDAG->getUNDEF(VT),
1010 NarrowBCast, CurDAG->getIntPtrConstant(0, dl));
1012 Res = CurDAG->getNode(ISD::INSERT_SUBVECTOR, dl, VT, Res, NarrowBCast,
1013 CurDAG->getIntPtrConstant(Index, dl));
1016 CurDAG->ReplaceAllUsesWith(N, Res.getNode());
1031 SDVTList VTs = CurDAG->getVTList(NarrowVT, MVT::Other);
1033 SDValue NarrowBCast = CurDAG->getMemIntrinsicNode(
1037 CurDAG->getNode(ISD::INSERT_SUBVECTOR, dl, VT, CurDAG->getUNDEF(VT),
1038 NarrowBCast, CurDAG->getIntPtrConstant(0, dl));
1040 Res = CurDAG->getNode(ISD::INSERT_SUBVECTOR, dl, VT, Res, NarrowBCast,
1041 CurDAG->getIntPtrConstant(Index, dl));
1045 CurDAG->ReplaceAllUsesWith(N, To);
1083 SDValue Extract = CurDAG->getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT,
1085 CurDAG->getIntPtrConstant(0, dl));
1086 SDValue Res = CurDAG->getBitcast(VT, Extract);
1090 CurDAG->ReplaceAllUsesWith(N, To);
1107 if (Subtarget->hasVLX() && CurDAG->ComputeNumSignBits(N->getOperand(0)) ==
1109 R = CurDAG->getNode(X86ISD::VPTERNLOG, SDLoc(N), N->getValueType(0),
1111 CurDAG->getTargetConstant(0xCA, SDLoc(N), MVT::i8));
1113 R = CurDAG->getNode(X86ISD::BLENDV, SDLoc(N), N->getValueType(0),
1118 CurDAG->ReplaceAllUsesWith(N, R.getNode());
1147 CurDAG->getNode(NewOpc, SDLoc(N), {N->getValueType(0), MVT::Other},
1151 CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
1154 CurDAG->ReplaceAllUsesWith(N, Res.getNode());
1174 SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
1177 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
1200 SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
1203 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
1242 Res = CurDAG->getNode(X86ISD::STRICT_VRNDSCALE, dl,
1245 CurDAG->getTargetConstant(Imm, dl, MVT::i32)});
1247 Res = CurDAG->getNode(X86ISD::VRNDSCALE, dl, N->getValueType(0),
1249 CurDAG->getTargetConstant(Imm, dl, MVT::i32));
1251 CurDAG->ReplaceAllUsesWith(N, Res.getNode());
1271 SDValue Op0 = CurDAG->getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT,
1273 SDValue Op1 = CurDAG->getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT,
1279 Op0 = CurDAG->getNode(ISD::BITCAST, dl, IntVT, Op0);
1280 Op1 = CurDAG->getNode(ISD::BITCAST, dl, IntVT, Op1);
1289 Res = CurDAG->getNode(Opc, dl, IntVT, Op0, Op1);
1290 Res = CurDAG->getNode(ISD::BITCAST, dl, VecVT, Res);
1292 Res = CurDAG->getNode(N->getOpcode(), dl, VecVT, Op0, Op1);
1294 Res = CurDAG->getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Res,
1295 CurDAG->getIntPtrConstant(0, dl));
1297 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
1336 moveBelowOrigChain(CurDAG, Load, SDValue(N, 0), Chain);
1384 SDValue MemTmp = CurDAG->CreateStackTemporary(MemVT);
1387 MachinePointerInfo::getFixedStack(CurDAG->getMachineFunction(), SPFI);
1392 SDValue Store = CurDAG->getTruncStore(
1393 CurDAG->getEntryNode(), dl, N->getOperand(0), MemTmp, MPI, MemVT);
1394 SDValue Result = CurDAG->getExtLoad(ISD::EXTLOAD, dl, DstVT, Store,
1402 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Result);
1440 SDValue MemTmp = CurDAG->CreateStackTemporary(MemVT);
1443 MachinePointerInfo::getFixedStack(CurDAG->getMachineFunction(), SPFI);
1451 SDVTList VTs = CurDAG->getVTList(MVT::Other);
1453 Store = CurDAG->getMemIntrinsicNode(X86ISD::FST, dl, VTs, Ops, MemVT,
1463 Store = CurDAG->getStore(N->getOperand(0), dl, N->getOperand(1), MemTmp,
1468 SDVTList VTs = CurDAG->getVTList(DstVT, MVT::Other);
1470 Result = CurDAG->getMemIntrinsicNode(
1480 Result = CurDAG->getLoad(DstVT, dl, Store, MemTmp, MPI);
1488 CurDAG->ReplaceAllUsesWith(N, Result.getNode());
1502 CurDAG->RemoveDeadNodes();
1530 MachineSDNode *Extend = CurDAG->getMachineNode(X86::MOVSX64rr32, SDLoc(N),
1546 SelectionDAG::allnodes_iterator Position = CurDAG->allnodes_end();
1549 while (Position != CurDAG->allnodes_begin()) {
1595 CurDAG->getMachineNode(Opc, SDLoc(N), MVT::i32, Ops);
1634 MachineSDNode *Test = CurDAG->getMachineNode(
1636 CurDAG->setNodeMemRefs(
1684 MachineSDNode *KTest = CurDAG->getMachineNode(
1736 CurDAG->UpdateNodeOperands(N, N->getOperand(0), In, N->getOperand(2));
1743 CurDAG->RemoveDeadNodes();
1751 auto &DL = CurDAG->getDataLayout();
1753 TargetLowering::CallLoweringInfo CLI(*CurDAG);
1754 CLI.setChain(CurDAG->getRoot())
1755 .setCallee(CallingConv::C, Type::getVoidTy(*CurDAG->getContext()),
1756 CurDAG->getExternalSymbol("__main", TLI->getPointerTy(DL)),
1758 const TargetLowering &TLI = CurDAG->getTargetLoweringInfo();
1760 CurDAG->setRoot(Result.second);
1849 AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
1852 AM.Segment = CurDAG->getRegister(X86::FS, MVT::i16);
1934 AM.setBaseReg(CurDAG->getRegister(X86::RIP, MVT::i64));
1977 AM.Base_Reg = CurDAG->getRegister(X86::RIP, MVT::i64);
2350 if (CurDAG->isBaseWithConstantOffset(N)) {
2381 if (CurDAG->isBaseWithConstantOffset(Src)) {
2387 SDValue ExtSrc = CurDAG->getNode(Opc, DL, VT, AddSrc);
2388 SDValue ExtVal = CurDAG->getConstant(Offset, DL, VT);
2389 SDValue ExtAdd = CurDAG->getNode(ISD::ADD, DL, VT, ExtSrc, ExtVal);
2390 insertDAGNode(*CurDAG, N, ExtSrc);
2391 insertDAGNode(*CurDAG, N, ExtVal);
2392 insertDAGNode(*CurDAG, N, ExtAdd);
2393 CurDAG->ReplaceAllUsesWith(N, ExtAdd);
2394 CurDAG->RemoveDeadNode(N.getNode());
2408 CurDAG->isADDLike(Src, /*NoWrap=*/true)) &&
2410 if (CurDAG->isBaseWithConstantOffset(Src)) {
2426 CurDAG->MaskedValueIsZero(ShVal, HiBits))) {
2428 SDValue ExtShVal = CurDAG->getNode(Opc, DL, VT, ShVal);
2429 SDValue ExtShift = CurDAG->getNode(ISD::SHL, DL, VT, ExtShVal,
2431 insertDAGNode(*CurDAG, N, ExtShVal);
2432 insertDAGNode(*CurDAG, N, ExtShift);
2437 SDValue ExtSrc = CurDAG->getNode(Opc, DL, VT, AddSrc);
2438 SDValue ExtVal = CurDAG->getConstant(Offset, DL, VT);
2439 SDValue ExtAdd = CurDAG->getNode(SrcOpc, DL, VT, ExtSrc, ExtVal);
2440 insertDAGNode(*CurDAG, N, ExtSrc);
2441 insertDAGNode(*CurDAG, N, ExtVal);
2442 insertDAGNode(*CurDAG, N, ExtAdd);
2443 CurDAG->ReplaceAllUsesWith(N, ExtAdd);
2444 CurDAG->RemoveDeadNode(N.getNode());
2460 AM.dump(CurDAG);
2563 if (!foldMaskAndShiftToScale(*CurDAG, N, Mask, N, X, AM))
2675 if (!CurDAG->isADDLike(N))
2705 if (!foldMaskAndShiftToExtract(*CurDAG, N, Mask, Shift, X, AM))
2709 if (!foldMaskAndShiftToScale(*CurDAG, N, Mask, Shift, X, AM))
2713 if (!foldMaskedShiftToBEXTR(*CurDAG, N, Mask, Shift, X, AM, *Subtarget))
2719 if (!foldMaskedShiftToScaledMask(*CurDAG, N, AM))
2765 !CurDAG->MaskedValueIsZero(ShlSrc, HighZeros & Mask))
2778 Res = CurDAG->getConstant(Mask.lshr(ShAmtV), DL, SrcVT);
2779 insertDAGNode(*CurDAG, N, Res);
2780 Res = CurDAG->getNode(ISD::AND, DL, SrcVT, ShlSrc, Res);
2781 insertDAGNode(*CurDAG, N, Res);
2783 SDValue Zext = CurDAG->getNode(ISD::ZERO_EXTEND, DL, VT, Res);
2784 insertDAGNode(*CurDAG, N, Zext);
2785 SDValue NewShl = CurDAG->getNode(ISD::SHL, DL, VT, Zext, ShlAmt);
2786 insertDAGNode(*CurDAG, N, NewShl);
2787 CurDAG->ReplaceAllUsesWith(N, NewShl);
2788 CurDAG->RemoveDeadNode(N.getNode());
2801 if (!foldMaskAndShiftToExtract(*CurDAG, N, Mask.getZExtValue(), Src,
2806 if (!foldMaskAndShiftToScale(*CurDAG, N, Mask.getZExtValue(), Src,
2811 if (!foldMaskedShiftToBEXTR(*CurDAG, N, Mask.getZExtValue(), Src,
2851 AM.dump(CurDAG);
2921 AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
2923 AM.Segment = CurDAG->getRegister(X86::FS, MVT::i16);
2925 AM.Segment = CurDAG->getRegister(X86::SS, MVT::i16);
2963 AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
2965 AM.Segment = CurDAG->getRegister(X86::FS, MVT::i16);
2967 AM.Segment = CurDAG->getRegister(X86::SS, MVT::i16);
3026 Base = CurDAG->getRegister(0, MVT::i64);
3029 SDValue ImplDef = SDValue(CurDAG->getMachineNode(X86::IMPLICIT_DEF, DL,
3031 Base = CurDAG->getTargetInsertSubreg(X86::sub_32bit, DL, MVT::i64, ImplDef,
3037 Index = CurDAG->getRegister(0, MVT::i64);
3041 SDValue ImplDef = SDValue(CurDAG->getMachineNode(X86::IMPLICIT_DEF, DL,
3043 Index = CurDAG->getTargetInsertSubreg(X86::sub_32bit, DL, MVT::i64, ImplDef,
3065 SDValue T = CurDAG->getRegister(0, MVT::i32);
3160 AM.IndexReg = CurDAG->getRegister(X86::EBX, MVT::i32);
3200 Op = CurDAG->getTargetGlobalAddress(GA->getGlobal(), SDLoc(N), VT,
3239 return CurDAG->getRegister(GlobalBaseReg, TLI->getPointerTy(DL)).getNode();
3426 SDValue StoredVal, SelectionDAG *CurDAG,
3533 CurDAG->getNode(ISD::TokenFactor, SDLoc(Chain), MVT::Other, ChainOps);
3592 if (!isFusableLoadOpStorePattern(StoreNode, StoredVal, CurDAG, LoadOpNo,
3599 if (!isFusableLoadOpStorePattern(StoreNode, StoredVal, CurDAG, LoadOpNo,
3633 Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32,
3640 if (!Subtarget->slowIncDec() || CurDAG->shouldOptForSize()) {
3650 Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32,
3736 Operand = CurDAG->getTargetConstant(OperandV, SDLoc(Node), MemVT);
3743 CurDAG->getCopyToReg(InputChain, SDLoc(Node), X86::EFLAGS,
3748 Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32, MVT::Other,
3753 Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32, MVT::Other,
3764 CurDAG->setNodeMemRefs(Result, MemOps);
3770 CurDAG->RemoveDeadNode(Node);
3852 return CurDAG->MaskedValueIsAllOnes(
3971 X = CurDAG->getAllOnesConstant(SDLoc(Node), NVT);
3983 NBits = CurDAG->getNode(ISD::TRUNCATE, DL, MVT::i8, NBits);
3984 insertDAGNode(*CurDAG, SDValue(Node, 0), NBits);
3989 CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, DL, MVT::i32), 0);
3990 insertDAGNode(*CurDAG, SDValue(Node, 0), ImplDef);
3992 SDValue SRIdxVal = CurDAG->getTargetConstant(X86::sub_8bit, DL, MVT::i32);
3993 insertDAGNode(*CurDAG, SDValue(Node, 0), SRIdxVal);
3994 NBits = SDValue(CurDAG->getMachineNode(TargetOpcode::INSERT_SUBREG, DL,
3997 insertDAGNode(*CurDAG, SDValue(Node, 0), NBits);
4002 SDValue BitWidthC = CurDAG->getConstant(NVT.getSizeInBits(), DL, MVT::i32);
4003 insertDAGNode(*CurDAG, SDValue(Node, 0), BitWidthC);
4005 NBits = CurDAG->getNode(ISD::SUB, DL, MVT::i32, BitWidthC, NBits);
4006 insertDAGNode(*CurDAG, SDValue(Node, 0), NBits);
4013 NBits = CurDAG->getNode(ISD::ANY_EXTEND, DL, NVT, NBits);
4014 insertDAGNode(*CurDAG, SDValue(Node, 0), NBits);
4017 SDValue Extract = CurDAG->getNode(X86ISD::BZHI, DL, NVT, X, NBits);
4044 SDValue C8 = CurDAG->getConstant(8, DL, MVT::i8);
4045 insertDAGNode(*CurDAG, SDValue(Node, 0), C8);
4046 SDValue Control = CurDAG->getNode(ISD::SHL, DL, MVT::i32, NBits, C8);
4047 insertDAGNode(*CurDAG, SDValue(Node, 0), Control);
4061 ShiftAmt = CurDAG->getNode(ISD::ZERO_EXTEND, DL, MVT::i32, ShiftAmt);
4062 insertDAGNode(*CurDAG, OrigShiftAmt, ShiftAmt);
4065 Control = CurDAG->getNode(ISD::OR, DL, MVT::i32, Control, ShiftAmt);
4066 insertDAGNode(*CurDAG, SDValue(Node, 0), Control);
4071 Control = CurDAG->getNode(ISD::ANY_EXTEND, DL, XVT, Control);
4072 insertDAGNode(*CurDAG, SDValue(Node, 0), Control);
4076 SDValue Extract = CurDAG->getNode(X86ISD::BEXTR, DL, XVT, X, Control);
4080 insertDAGNode(*CurDAG, SDValue(Node, 0), Extract);
4081 Extract = CurDAG->getNode(ISD::TRUNCATE, DL, NVT, Extract);
4160 Control = CurDAG->getTargetConstant(Shift + MaskSize, dl, NVT);
4166 Control = SDValue(CurDAG->getMachineNode(NewOpc, dl, NVT, Control), 0);
4172 Control = CurDAG->getTargetConstant(Shift | (MaskSize << 8), dl, NVT);
4184 Control = SDValue(CurDAG->getMachineNode(NewOpc, dl, NVT, Control), 0);
4194 SDVTList VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
4195 NewNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
4199 CurDAG->setNodeMemRefs(NewNode, {cast<LoadSDNode>(Input)->getMemOperand()});
4201 NewNode = CurDAG->getMachineNode(ROpc, dl, NVT, MVT::i32, Input, Control);
4206 SDValue ShAmt = CurDAG->getTargetConstant(Shift, dl, NVT);
4210 CurDAG->getMachineNode(NewOpc, dl, NVT, SDValue(NewNode, 0), ShAmt);
4224 Imm = CurDAG->getTargetConstant(*Val, SDLoc(Node), Imm.getValueType());
4231 SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Other);
4232 MachineSDNode *CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
4236 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
4241 SDVTList VTs = CurDAG->getVTList(VT, MVT::i32);
4242 MachineSDNode *CNode = CurDAG->getMachineNode(ROpc, dl, VTs, Ops);
4257 Imm = CurDAG->getTargetConstant(*Val, SDLoc(Node), Imm.getValueType());
4264 SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Other, MVT::Glue);
4265 MachineSDNode *CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
4270 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N2)->getMemOperand()});
4275 SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Glue);
4276 MachineSDNode *CNode = CurDAG->getMachineNode(ROpc, dl, VTs, Ops);
4328 SDValue AllOnes = CurDAG->getAllOnesConstant(DL, OpVT);
4329 NewShiftAmt = CurDAG->getNode(ISD::XOR, DL, OpVT,
4331 insertDAGNode(*CurDAG, OrigShiftAmt, AllOnes);
4332 insertDAGNode(*CurDAG, OrigShiftAmt, NewShiftAmt);
4350 Add0 = CurDAG->getZExtOrTrunc(Add0, DL, SubVT);
4351 insertDAGNode(*CurDAG, OrigShiftAmt, Add0);
4354 X = CurDAG->getNode(ISD::ADD, DL, SubVT, Add1, Add0);
4355 insertDAGNode(*CurDAG, OrigShiftAmt, X);
4361 SDValue Zero = CurDAG->getConstant(0, DL, SubVT);
4362 SDValue Neg = CurDAG->getNode(ISD::SUB, DL, SubVT, Zero, X);
4367 insertDAGNode(*CurDAG, OrigShiftAmt, Zero);
4368 insertDAGNode(*CurDAG, OrigShiftAmt, Neg);
4376 NewShiftAmt = CurDAG->getNode(ISD::TRUNCATE, DL, MVT::i8, NewShiftAmt);
4378 insertDAGNode(*CurDAG, OrigShiftAmt, NewShiftAmt);
4383 NewShiftAmt = CurDAG->getNode(ISD::AND, DL, MVT::i8, NewShiftAmt,
4384 CurDAG->getConstant(Size - 1, DL, MVT::i8));
4386 insertDAGNode(*CurDAG, OrigShiftAmt, NewShiftAmt);
4388 SDNode *UpdatedNode = CurDAG->UpdateNodeOperands(N, N->getOperand(0),
4400 CurDAG->RemoveDeadNode(OrigShiftAmt.getNode());
4499 if (CurDAG->MaskedValueIsZero(N->getOperand(0), NeededMask))
4505 SDValue NewX = CurDAG->getNode(ISD::ANY_EXTEND, dl, NVT, X);
4506 insertDAGNode(*CurDAG, SDValue(N, 0), NewX);
4510 SDValue NewCst = CurDAG->getConstant(ShiftedVal, dl, NVT);
4511 insertDAGNode(*CurDAG, SDValue(N, 0), NewCst);
4512 SDValue NewBinOp = CurDAG->getNode(Opcode, dl, NVT, X, NewCst);
4513 insertDAGNode(*CurDAG, SDValue(N, 0), NewBinOp);
4514 SDValue NewSHL = CurDAG->getNode(ISD::SHL, dl, NVT, NewBinOp,
4582 SDValue TImm = CurDAG->getTargetConstant(Imm, DL, MVT::i8);
4588 SDVTList VTs = CurDAG->getVTList(NVT, MVT::Other);
4618 MNode = CurDAG->getMachineNode(Opc, DL, VTs, Ops);
4623 CurDAG->setNodeMemRefs(MNode, {cast<MemSDNode>(C)->getMemOperand()});
4636 MNode = CurDAG->getMachineNode(Opc, DL, NVT, {A, B, C, TImm});
4640 CurDAG->RemoveDeadNode(Root);
4790 if (!CurDAG->MaskedValueIsZero(And0, HighZeros))
4801 SDValue NewMask = CurDAG->getConstant(NegMaskVal, SDLoc(And), VT);
4802 insertDAGNode(*CurDAG, SDValue(And, 0), NewMask);
4803 SDValue NewAnd = CurDAG->getNode(ISD::AND, SDLoc(And), VT, And0, NewMask);
4967 SDValue ImplDef = SDValue(CurDAG->getMachineNode(X86::IMPLICIT_DEF, dl,
4969 Src0 = CurDAG->getTargetInsertSubreg(SubReg, dl, CmpVT, ImplDef, Src0);
4972 Src1 = CurDAG->getTargetInsertSubreg(SubReg, dl, CmpVT, ImplDef, Src1);
4977 SDValue RC = CurDAG->getTargetConstant(RegClass, dl, MVT::i32);
4978 InMask = SDValue(CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
4989 SDVTList VTs = CurDAG->getVTList(MaskVT, MVT::Other);
4994 CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
4998 CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
5004 CurDAG->setNodeMemRefs(CNode, {cast<MemSDNode>(Src1)->getMemOperand()});
5007 CNode = CurDAG->getMachineNode(Opc, dl, MaskVT, InMask, Src0, Src1);
5009 CNode = CurDAG->getMachineNode(Opc, dl, MaskVT, Src0, Src1);
5015 SDValue RC = CurDAG->getTargetConstant(RegClass, dl, MVT::i32);
5016 CNode = CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
5021 CurDAG->RemoveDeadNode(Root);
5067 SDValue Imm = CurDAG->getTargetConstant(0xCA, dl, MVT::i8);
5068 SDValue Ternlog = CurDAG->getNode(X86ISD::VPTERNLOG, dl, NVT, A, B, C, Imm);
5081 LLVM_DEBUG(dbgs() << "== "; Node->dump(CurDAG); dbgs() << '\n');
5109 Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM0, Node->getOperand(3),
5112 Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM1, Node->getOperand(4),
5115 MachineSDNode *Res = CurDAG->getMachineNode(
5126 CurDAG->getMachineFunction().getInfo<X86MachineFunctionInfo>();
5135 SDValue Disp = CurDAG->getTargetConstant(0, dl, MVT::i32);
5136 SDValue Segment = CurDAG->getRegister(0, MVT::i16);
5147 CNode = CurDAG->getMachineNode(Opc, dl, {MVT::x86amx, MVT::Other}, Ops);
5185 SDValue Chain = CurDAG->getCopyToReg(Node->getOperand(0), dl, PtrReg,
5192 Chain = CurDAG->getCopyToReg(Chain, dl, X86::ECX, Node->getOperand(3),
5195 Chain = CurDAG->getCopyToReg(Chain, dl, X86::EDX, Node->getOperand(4),
5200 MachineSDNode *CNode = CurDAG->getMachineNode(Opc, dl, MVT::Other,
5210 CurDAG->getMachineFunction().getInfo<X86MachineFunctionInfo>();
5217 SDValue Disp = CurDAG->getTargetConstant(0, dl, MVT::i32);
5218 SDValue Segment = CurDAG->getRegister(0, MVT::i16);
5230 CNode = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
5240 CurDAG->getMachineFunction().getInfo<X86MachineFunctionInfo>();
5255 SDValue Disp = CurDAG->getTargetConstant(0, dl, MVT::i32);
5256 SDValue Segment = CurDAG->getRegister(0, MVT::i16);
5261 CNode = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
5264 CNode = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
5284 SDValue ZextTarget = CurDAG->getZExtOrTrunc(Target, dl, MVT::i64);
5285 SDValue Brind = CurDAG->getNode(Opcode, dl, MVT::Other,
5303 CurDAG->RemoveDeadNode(Node);
5346 CurDAG->RemoveDeadNode(Node);
5376 if (!CurDAG->shouldOptForSize())
5518 SDVTList VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
5519 MachineSDNode *CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
5523 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N0)->getMemOperand()});
5525 CurDAG->RemoveDeadNode(Node);
5530 CurDAG->SelectNodeTo(Node, ROpc, NVT, MVT::i32, N0, N1);
5577 SDValue InGlue = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, LoReg,
5586 VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
5588 VTs = CurDAG->getVTList(NVT, NVT, MVT::i32, MVT::Other);
5592 CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
5597 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
5603 VTs = CurDAG->getVTList(NVT, MVT::i32);
5605 VTs = CurDAG->getVTList(NVT, NVT, MVT::i32);
5607 CNode = CurDAG->getMachineNode(ROpc, dl, VTs, {N1, InGlue});
5612 CurDAG->RemoveDeadNode(Node);
5663 SDValue InGlue = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, LoReg,
5672 SDVTList VTs = CurDAG->getVTList(NVT, MVT::Other);
5673 CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
5677 SDVTList VTs = CurDAG->getVTList(NVT, NVT, MVT::Other);
5678 CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
5683 SDVTList VTs = CurDAG->getVTList(MVT::Other, MVT::Glue);
5684 CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
5692 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
5696 SDVTList VTs = CurDAG->getVTList(NVT);
5697 SDNode *CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
5700 SDVTList VTs = CurDAG->getVTList(NVT, NVT);
5701 SDNode *CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
5705 SDVTList VTs = CurDAG->getVTList(MVT::Glue);
5706 SDNode *CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
5715 ResLo = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl, LoReg,
5720 LLVM_DEBUG(dbgs() << "=> "; ResLo.getNode()->dump(CurDAG);
5727 ResHi = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl, HiReg,
5732 LLVM_DEBUG(dbgs() << "=> "; ResHi.getNode()->dump(CurDAG);
5736 CurDAG->RemoveDeadNode(Node);
5790 bool signBitIsZero = CurDAG->SignBitIsZero(N0);
5802 Move = CurDAG->getMachineNode(Opc, dl, MVT::i16, MVT::Other, Ops);
5806 CurDAG->setNodeMemRefs(Move, {cast<LoadSDNode>(N0)->getMemOperand()});
5810 Move = CurDAG->getMachineNode(Opc, dl, MVT::i16, N0);
5811 Chain = CurDAG->getEntryNode();
5813 Chain = CurDAG->getCopyToReg(Chain, dl, X86::AX, SDValue(Move, 0),
5818 CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl,
5823 SDValue(CurDAG->getMachineNode(SExtOpcode, dl, MVT::Glue, InGlue),0);
5826 SDVTList VTs = CurDAG->getVTList(MVT::i32, MVT::i32);
5828 CurDAG->getMachineNode(X86::MOV32r0, dl, VTs, std::nullopt), 0);
5832 SDValue(CurDAG->getMachineNode(
5834 CurDAG->getTargetConstant(X86::sub_16bit, dl,
5842 SDValue(CurDAG->getMachineNode(
5844 CurDAG->getTargetConstant(0, dl, MVT::i64), ClrNode,
5845 CurDAG->getTargetConstant(X86::sub_32bit, dl,
5853 InGlue = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, ClrReg,
5862 CurDAG->getMachineNode(MOpc, dl, MVT::Other, MVT::Glue, Ops);
5867 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
5870 SDValue(CurDAG->getMachineNode(ROpc, dl, MVT::Glue, N1, InGlue), 0);
5881 SDValue AHCopy = CurDAG->getRegister(X86::AH, MVT::i8);
5885 SDNode *RNode = CurDAG->getMachineNode(AHExtOpcode, dl, MVT::i32,
5891 CurDAG->getTargetExtractSubreg(X86::sub_8bit, dl, MVT::i8, Result);
5894 LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
5899 SDValue Result = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl,
5903 LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
5908 SDValue Result = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl,
5912 LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
5915 CurDAG->RemoveDeadNode(Node);
5951 IsStrictCmp ? Node->getOperand(0) : CurDAG->getEntryNode();
5954 SDVTList VTs = CurDAG->getVTList(MVT::Other, MVT::Glue);
5955 Chain = SDValue(CurDAG->getMachineNode(Opc, dl, VTs, {N0, N1, Chain}), 0);
5958 Glue = SDValue(CurDAG->getMachineNode(Opc, dl, MVT::Glue, N0, N1), 0);
5963 SDValue(CurDAG->getMachineNode(X86::FNSTSW16r, dl, MVT::i16, Glue), 0);
5967 CurDAG->getTargetExtractSubreg(X86::sub_8bit_hi, dl, MVT::i8, FNSTSW);
5973 SDValue AH = CurDAG->getCopyToReg(Chain, dl, X86::AH, Extract, SDValue());
5976 CurDAG->getMachineNode(X86::SAHF, dl, MVT::i32, AH.getValue(1)), 0);
5982 CurDAG->RemoveDeadNode(Node);
6006 NewNode = CurDAG->getMachineNode(TestOpc, dl, MVT::i32, BEXTR, BEXTR);
6008 CurDAG->RemoveDeadNode(Node);
6089 SDValue ShiftC = CurDAG->getTargetConstant(ShiftAmt, dl, MVT::i64);
6091 CurDAG->getMachineNode(ShiftOpcode, dl, MVT::i64, MVT::i32,
6096 CurDAG->getTargetExtractSubreg(SubRegIdx, dl, SubRegVT, Shift);
6099 CurDAG->getMachineNode(TestOpcode, dl, MVT::i32, Shift, Shift);
6154 SDValue Imm = CurDAG->getTargetConstant(Mask, dl, VT);
6172 NewNode = CurDAG->getMachineNode(MOpc, dl, MVT::i32, MVT::Other, Ops);
6176 CurDAG->setNodeMemRefs(NewNode,
6181 Reg = CurDAG->getTargetExtractSubreg(SubRegOp, dl, VT, Reg);
6183 NewNode = CurDAG->getMachineNode(ROpc, dl, MVT::i32, Reg, Imm);
6220 CurDAG->RemoveDeadNode(Node);
6228 SDValue InGlue = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EAX,
6231 InGlue = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EDX,
6259 CurDAG->RemoveDeadNode(Node);
6283 CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EFLAGS,
6291 CurDAG->getMachineNode(Opc, dl, SetVT, EFLAGS, EFLAGS.getValue(1)),
6302 Result = CurDAG->getTargetExtractSubreg(SubIndex, dl, VT, Result);
6306 CurDAG->RemoveDeadNode(Node);
6323 Result = CurDAG->getTargetExtractSubreg(SubIndex, dl, VT, Result);
6328 CurDAG->RemoveDeadNode(Node);
6412 SDVTList VTs = CurDAG->getVTList(ValueVT, MaskVT, MVT::Other);
6418 NewNode = CurDAG->getMachineNode(Opc, SDLoc(dl), VTs, Ops);
6422 NewNode = CurDAG->getMachineNode(Opc, SDLoc(dl), VTs, Ops);
6424 CurDAG->setNodeMemRefs(NewNode, {Mgt->getMemOperand()});
6427 CurDAG->RemoveDeadNode(Node);
6485 SDVTList VTs = CurDAG->getVTList(Mask.getValueType(), MVT::Other);
6488 MachineSDNode *NewNode = CurDAG->getMachineNode(Opc, SDLoc(dl), VTs, Ops);
6489 CurDAG->setNodeMemRefs(NewNode, {Sc->getMemOperand()});
6491 CurDAG->RemoveDeadNode(Node);
6495 auto *MFI = CurDAG->getMachineFunction().getInfo<X86MachineFunctionInfo>();
6499 SDValue CallIdValue = CurDAG->getTargetConstant(CallId, dl, MVT::i32);
6500 MachineSDNode *New = CurDAG->getMachineNode(
6503 CurDAG->RemoveDeadNode(Node);
6507 auto *MFI = CurDAG->getMachineFunction().getInfo<X86MachineFunctionInfo>();
6511 SDValue CallIdValue = CurDAG->getTargetConstant(CallId, dl, MVT::i32);
6517 MachineSDNode *New = CurDAG->getMachineNode(
6519 CurDAG->getVTList(TLI->getPointerTy(CurDAG->getDataLayout()),
6524 CurDAG->RemoveDeadNode(Node);
6559 Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM0, Node->getOperand(2),
6561 Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM1, Node->getOperand(3),
6563 Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM2, Node->getOperand(4),
6565 Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM3, Node->getOperand(5),
6567 Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM4, Node->getOperand(6),
6569 Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM5, Node->getOperand(7),
6571 Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM6, Node->getOperand(8),
6573 Chain = CurDAG->getCopyToReg(Chain, dl, X86::XMM7, Node->getOperand(9),
6576 MachineSDNode *Res = CurDAG->getMachineNode(
6579 CurDAG->setNodeMemRefs(Res, cast<MemSDNode>(Node)->getMemOperand());