|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
gen/lib/Target/AArch64/AArch64GenDAGISel.inc115640 return CurDAG->getTargetConstant(N->getZExtValue(), SDLoc(N), MVT::i32);
115647 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
115654 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
115661 return CurDAG->getTargetConstant(AArch64CC::getInvertedCondCode(CC), SDLoc(N),
115669 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i64);
115677 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i64);
115684 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i64);
115692 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i64);
115700 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i64);
115708 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i64);
115716 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i64);
115723 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i64);
115730 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i64);
115738 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
115746 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
115752 return CurDAG->getTargetConstant(
115761 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
115771 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
115777 return CurDAG->getTargetConstant(
115784 return CurDAG->getTargetConstant(8 + N->getZExtValue(), SDLoc(N), MVT::i32);
115790 return CurDAG->getTargetConstant(8 * N->getZExtValue(), SDLoc(N), MVT::i64);
115796 return CurDAG->getTargetConstant(4 * N->getZExtValue(), SDLoc(N), MVT::i64);
115802 return CurDAG->getTargetConstant(2 * N->getZExtValue(), SDLoc(N), MVT::i64);
gen/lib/Target/AMDGPU/AMDGPUGenDAGISel.inc79788 return CurDAG->getConstant(-N->getSExtValue(), SDLoc(N), MVT::i32);
79794 return SDValue(packNegConstantV2I16(N, *CurDAG), 0);
79800 return CurDAG->getTargetConstant(N->getZExtValue(), SDLoc(N), MVT::i1);
79806 return CurDAG->getTargetConstant(N->getSExtValue(), SDLoc(N), MVT::i32);
79812 return CurDAG->getTargetConstant(N->getSExtValue(), SDLoc(N), MVT::i16);
79818 return CurDAG->getTargetConstant(N->getZExtValue(), SDLoc(N), MVT::i8);
79824 return CurDAG->getTargetConstant(N->getZExtValue() & 1, SDLoc(N), MVT::i8);
79830 return CurDAG->getTargetConstant((N->getZExtValue() >> 1) & 1, SDLoc(N), MVT::i8);
79836 return CurDAG->getTargetConstant((N->getZExtValue() >> 2) & 1, SDLoc(N), MVT::i8);
79842 return CurDAG->getTargetConstant((N->getZExtValue() >> 3) & 1, SDLoc(N), MVT::i8);
79848 return CurDAG->getTargetConstant(countPopulation(N->getZExtValue()), SDLoc(N),
79855 return CurDAG->getTargetConstant(
79862 return CurDAG->getTargetConstant(N->get(), SDLoc(N), MVT::i32);
79868 return CurDAG->getTargetConstant(N->getSExtValue(), SDLoc(N), MVT::i64);
79875 return CurDAG->getTargetFrameIndex(FI->getIndex(), MVT::i32);
79881 return CurDAG->getTargetConstant(
gen/lib/Target/AMDGPU/R600GenDAGISel.inc12400 LD->getMemOperand()->getValue(), CurDAG->getDataLayout()));
12414 LD->getMemOperand()->getValue(), CurDAG->getDataLayout())));
12622 return CurDAG->getTargetConstant(countPopulation(N->getZExtValue()), SDLoc(N),
gen/lib/Target/ARM/ARMGenDAGISel.inc54116 return CurDAG->ComputeNumSignBits(SDValue(N,0)) >= 17;
54212 CurDAG->MaskedValueIsZero(SDValue(N,0), APInt::getHighBitsSet(32, 16));
55025 return CurDAG->getTargetConstant((uint32_t)N->getZExtValue() >> 16, SDLoc(N),
55032 return CurDAG->getTargetConstant(~((uint32_t)N->getZExtValue()), SDLoc(N),
55041 case 0: return CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
55042 case 8: return CurDAG->getTargetConstant(1, SDLoc(N), MVT::i32);
55043 case 16: return CurDAG->getTargetConstant(2, SDLoc(N), MVT::i32);
55044 case 24: return CurDAG->getTargetConstant(3, SDLoc(N), MVT::i32);
55051 return CurDAG->getTargetConstant(-(int)N->getZExtValue(), SDLoc(N), MVT::i32);
55057 return CurDAG->getTargetConstant(-((int)N->getZExtValue()), SDLoc(N),
55065 return CurDAG->getTargetConstant(ARM::dsub_0 + N->getZExtValue()/4, SDLoc(N),
55072 return CurDAG->getTargetConstant(N->getZExtValue() & 3, SDLoc(N), MVT::i32);
55079 return CurDAG->getTargetConstant(ARM::dsub_0 + N->getZExtValue()/2, SDLoc(N),
55086 return CurDAG->getTargetConstant(N->getZExtValue() & 1, SDLoc(N), MVT::i32);
55092 return CurDAG->getTargetConstant(~(int)N->getZExtValue(), SDLoc(N), MVT::i32);
55100 return CurDAG->getTargetConstant(~N16bitSignExt, SDLoc(N), MVT::i32);
55106 return CurDAG->getTargetConstant((int)N->getZExtValue() - 1, SDLoc(N),
55113 return CurDAG->getTargetConstant((int)N->getZExtValue() - 1, SDLoc(N),
55121 return CurDAG->getTargetConstant((Imm == 32 ? 0 : Imm), SDLoc(N), MVT::i32);
55128 return CurDAG->getTargetConstant(ARMCC::getOppositeCondition(CC), SDLoc(N),
55136 return CurDAG->getTargetConstant(ARM::dsub_0 + N->getZExtValue()/8, SDLoc(N),
55143 return CurDAG->getTargetConstant(N->getZExtValue() & 7, SDLoc(N), MVT::i32);
55150 return CurDAG->getTargetConstant(ARM::ssub_0 + N->getZExtValue(), SDLoc(N),
55158 return CurDAG->getTargetConstant(ARM::ssub_0 + N->getZExtValue()/2, SDLoc(N),
55166 return CurDAG->getTargetConstant(ARM::dsub_0 + N->getZExtValue(), SDLoc(N),
55174 return CurDAG->getTargetConstant(V, SDLoc(N), MVT::i32);
55181 return CurDAG->getTargetConstant(V, SDLoc(N), MVT::i32);
55187 return CurDAG->getTargetConstant(N->getZExtValue() - 255, SDLoc(N), MVT::i32);
55195 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
55203 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
55211 return CurDAG->getTargetConstant(enc, SDLoc(N), MVT::i32);
gen/lib/Target/AVR/AVRGenDAGISel.inc 1754 return CurDAG->getTargetConstant(uint8_t(N->getZExtValue()) - 0x20, SDLoc(N), MVT::i8);
1760 return CurDAG->getTargetConstant(Log2_32(uint8_t(N->getZExtValue())),
1767 return CurDAG->getTargetConstant(Log2_32(uint8_t(~N->getZExtValue())),
1774 return CurDAG->getTargetConstant(-N->getAPIntValue(), SDLoc(N), MVT::i16);
1780 return CurDAG->getTargetConstant(-N->getAPIntValue(), SDLoc(N), MVT::i8);
gen/lib/Target/BPF/BPFGenDAGISel.inc 1904 case 2: return (CurDAG->getDataLayout().isLittleEndian());
1905 case 3: return (!CurDAG->getDataLayout().isLittleEndian());
gen/lib/Target/Hexagon/HexagonGenDAGISel.inc72960 return CurDAG->getTargetConstant(NV, SDLoc(N), MVT::i32);
72967 return CurDAG->getTargetConstant(NV, SDLoc(N), MVT::i32);
72974 return CurDAG->getTargetConstant(NV, SDLoc(N), MVT::i32);
72981 return CurDAG->getTargetConstant(Log2_32(NV), SDLoc(N), MVT::i32);
72988 return CurDAG->getTargetConstant(Log2_32(NV), SDLoc(N), MVT::i32);
72995 return CurDAG->getTargetConstant(Log2_32(NV), SDLoc(N), MVT::i32);
73002 return CurDAG->getTargetConstant(Log2_32(V), SDLoc(N), MVT::i32);
73009 return CurDAG->getTargetConstant(Log2_32(V), SDLoc(N), MVT::i32);
73016 return CurDAG->getTargetConstant(Log2_32(V), SDLoc(N), MVT::i32);
73023 return CurDAG->getTargetConstant(Imm & -8, SDLoc(N), MVT::i32);
73032 return CurDAG->getTargetConstant(imm, SDLoc(N), MVT::i32);
73041 return CurDAG->getTargetConstant(imm, SDLoc(N), MVT::i32);
73052 return CurDAG->getTargetConstant(imm, SDLoc(N), MVT::i32);
73059 return CurDAG->getTargetConstant(Log2_64(V), SDLoc(N), MVT::i32);
73067 return CurDAG->getTargetConstant(V-32, SDLoc(N), MVT::i32);
73074 return CurDAG->getTargetConstant(Log2_64(NV), SDLoc(N), MVT::i32);
73082 return CurDAG->getTargetConstant(V-1, SDLoc(N), MVT::i32);
73089 return CurDAG->getTargetConstant(V-1, SDLoc(N), MVT::i32);
73096 return CurDAG->getTargetConstant(V-2, SDLoc(N), MVT::i32);
73103 return CurDAG->getTargetConstant(V-3, SDLoc(N), MVT::i32);
73110 return CurDAG->getTargetConstant(V, SDLoc(N), MVT::i64);
73117 return CurDAG->getTargetConstant(64 - Imm, SDLoc(N), MVT::i32);
73124 return CurDAG->getTargetConstant(128 - Imm, SDLoc(N), MVT::i32);
73131 return CurDAG->getTargetConstant(I.getZExtValue(), SDLoc(N),
73138 return CurDAG->getTargetConstant((64 - N->getSExtValue()) / 8,
73144 int32_t V = 64 - N->getSExtValue();return CurDAG->getTargetConstant(V, SDLoc(N), MVT::i32);
73149 return CurDAG->getTargetConstant(N->getZExtValue() / 8, SDLoc(N), MVT::i32);
73154 int32_t V = 32 - N->getSExtValue();return CurDAG->getTargetConstant(V, SDLoc(N), MVT::i32);
73159 return CurDAG->getTargetConstant(N->getSExtValue(), SDLoc(N), MVT::i32);
73168 return CurDAG->getTargetConstant(S, SDLoc(N), MVT::i32);
73176 return CurDAG->getTargetConstant(V << 16 | V, SDLoc(N), MVT::i32);
73182 const auto &ST = static_cast<const HexagonSubtarget&>(CurDAG->getSubtarget());
73183 return CurDAG->getTargetConstant(ST.getVectorLength()/2, SDLoc(N), MVT::i32);
gen/lib/Target/Lanai/LanaiGenDAGISel.inc 1551 return CurDAG->getTargetConstant((uint64_t)N->getZExtValue() & 0xffff,
1558 return CurDAG->getTargetConstant((uint64_t)N->getZExtValue() >> 16, SDLoc(N),
1565 return CurDAG->getTargetConstant(-N->getSExtValue(), SDLoc(N), MVT::i32);
1571 return CurDAG->getTargetConstant((uint64_t)N->getZExtValue() & 0x1fffff,
gen/lib/Target/NVPTX/NVPTXGenDAGISel.inc72355 return CurDAG->getTargetConstant(32 - N->getZExtValue(), SDLoc(N), MVT::i32);
72361 return CurDAG->getTargetConstant(64-N->getZExtValue(), SDLoc(N), MVT::i32);
72375 return CurDAG->getTargetConstant(temp.shl(v), SDLoc(N), MVT::i32);
72383 return CurDAG->getTargetConstant(temp.shl(v), SDLoc(N), MVT::i16);
gen/lib/Target/PowerPC/PPCGenDAGISel.inc44485 return PPC::get_VSPLTI_elt(N, 1, *CurDAG).getNode() != nullptr;
44493 return PPC::get_VSPLTI_elt(N, 2, *CurDAG).getNode() != nullptr;
44501 return PPC::get_VSPLTI_elt(N, 4, *CurDAG).getNode() != nullptr;
44533 return PPC::isVSLDOIShuffleMask(N, 1, *CurDAG) != -1;
44541 return PPC::isVPKUWUMShuffleMask(cast<ShuffleVectorSDNode>(N), 1, *CurDAG);
44549 return PPC::isVPKUHUMShuffleMask(cast<ShuffleVectorSDNode>(N), 1, *CurDAG);
44557 return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 1, 1, *CurDAG);
44565 return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 2, 1, *CurDAG);
44573 return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 4, 1, *CurDAG);
44581 return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 1, 1, *CurDAG);
44589 return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 2, 1, *CurDAG);
44597 return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 4, 1, *CurDAG);
44605 return PPC::isVMRGEOShuffleMask(cast<ShuffleVectorSDNode>(N), true, 1, *CurDAG);
44613 return PPC::isVMRGEOShuffleMask(cast<ShuffleVectorSDNode>(N), false, 1, *CurDAG);
44621 return PPC::isVPKUDUMShuffleMask(cast<ShuffleVectorSDNode>(N), 1, *CurDAG);
44629 return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 1, 0, *CurDAG);
44637 return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 2, 0, *CurDAG);
44645 return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 4, 0, *CurDAG);
44653 return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 1, 0, *CurDAG);
44661 return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 2, 0, *CurDAG);
44669 return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 4, 0, *CurDAG);
44677 return PPC::isVPKUHUMShuffleMask(cast<ShuffleVectorSDNode>(N), 0, *CurDAG);
44685 return PPC::isVPKUWUMShuffleMask(cast<ShuffleVectorSDNode>(N), 0, *CurDAG);
44693 return PPC::isVSLDOIShuffleMask(N, 0, *CurDAG) != -1;
44701 return PPC::isVSLDOIShuffleMask(N, 2, *CurDAG) != -1;
44709 return PPC::isVPKUWUMShuffleMask(cast<ShuffleVectorSDNode>(N), 2, *CurDAG);
44717 return PPC::isVPKUHUMShuffleMask(cast<ShuffleVectorSDNode>(N), 2, *CurDAG);
44725 return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 1, 2, *CurDAG);
44733 return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 2, 2, *CurDAG);
44741 return PPC::isVMRGLShuffleMask(cast<ShuffleVectorSDNode>(N), 4, 2, *CurDAG);
44749 return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 1, 2, *CurDAG);
44757 return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 2, 2, *CurDAG);
44765 return PPC::isVMRGHShuffleMask(cast<ShuffleVectorSDNode>(N), 4, 2, *CurDAG);
44773 return PPC::isVMRGEOShuffleMask(cast<ShuffleVectorSDNode>(N), true, 0, *CurDAG);
44781 return PPC::isVMRGEOShuffleMask(cast<ShuffleVectorSDNode>(N), false, 0, *CurDAG);
44789 return PPC::isVMRGEOShuffleMask(cast<ShuffleVectorSDNode>(N), true, 2, *CurDAG);
44797 return PPC::isVMRGEOShuffleMask(cast<ShuffleVectorSDNode>(N), false, 2, *CurDAG);
44805 return PPC::isVPKUDUMShuffleMask(cast<ShuffleVectorSDNode>(N), 0, *CurDAG);
44813 return PPC::isVPKUDUMShuffleMask(cast<ShuffleVectorSDNode>(N), 2, *CurDAG);
44957 return PPC::get_VSPLTI_elt(N, 1, *CurDAG);
44963 return PPC::get_VSPLTI_elt(N, 2, *CurDAG);
44969 return PPC::get_VSPLTI_elt(N, 4, *CurDAG);
44975 return getI32Imm(PPC::getSplatIdxForPPCMnemonics(N, 1, *CurDAG), SDLoc(N));
44981 return getI32Imm(PPC::getSplatIdxForPPCMnemonics(N, 2, *CurDAG), SDLoc(N));
44987 return getI32Imm(PPC::getSplatIdxForPPCMnemonics(N, 4, *CurDAG), SDLoc(N));
44993 return getI32Imm(PPC::isVSLDOIShuffleMask(N, 1, *CurDAG), SDLoc(N));
44999 return getI32Imm(PPC::isVSLDOIShuffleMask(N, 0, *CurDAG), SDLoc(N));
45005 return getI32Imm(PPC::isVSLDOIShuffleMask(N, 2, *CurDAG), SDLoc(N));
gen/lib/Target/RISCV/RISCVGenDAGISel.inc14189 return CurDAG->getTargetConstant(((N->getZExtValue()+0x800) >> 12) & 0xfffff,
14196 return CurDAG->getTargetConstant(SignExtend64<12>(N->getZExtValue()),
gen/lib/Target/Sparc/SparcGenDAGISel.inc 3635 return CurDAG->getTargetConstant(~(unsigned)N->getZExtValue() >> 10, SDLoc(N),
3642 return CurDAG->getTargetConstant(N->getSExtValue(), SDLoc(N), MVT::i32);
3649 return CurDAG->getTargetConstant((unsigned)N->getZExtValue() >> 10, SDLoc(N),
3656 return CurDAG->getTargetConstant((unsigned)N->getZExtValue() & 1023, SDLoc(N),
3664 return CurDAG->getTargetConstant(Val, SDLoc(N), MVT::i32);
3670 return CurDAG->getTargetConstant(~(~N->getZExtValue() & 0x3ff), SDLoc(N),
3678 return CurDAG->getTargetConstant(Val, SDLoc(N), MVT::i32);
3685 return CurDAG->getTargetConstant(Val, SDLoc(N), MVT::i32);
gen/lib/Target/SystemZ/SystemZGenDAGISel.inc30119 return CurDAG->MaskedValueIsZero(N->getOperand(0),
30129 return CurDAG->MaskedValueIsZero(N->getOperand(1),
30513 return CurDAG->getTargetConstant(uint8_t(N->getZExtValue()), SDLoc(N),
30520 return CurDAG->getTargetConstant(int8_t(N->getZExtValue()), SDLoc(N),
30527 return CurDAG->getTargetConstant(int16_t(N->getZExtValue()), SDLoc(N),
30534 return CurDAG->getTargetConstant(int16_t(-N->getZExtValue()), SDLoc(N),
30541 return CurDAG->getTargetConstant(int32_t(-N->getZExtValue()), SDLoc(N),
30548 return CurDAG->getTargetConstant(uint32_t(N->getZExtValue()), SDLoc(N),
30556 return CurDAG->getTargetConstant(Value, SDLoc(N), MVT::i64);
30563 return CurDAG->getTargetConstant(Value, SDLoc(N), MVT::i64);
30570 return CurDAG->getTargetConstant(Value, SDLoc(N), MVT::i64);
30577 return CurDAG->getTargetConstant(Value, SDLoc(N), MVT::i64);
30584 return CurDAG->getTargetConstant(Value, SDLoc(N), MVT::i64);
30591 return CurDAG->getTargetConstant(Value, SDLoc(N), MVT::i64);
30597 return CurDAG->getTargetConstant(uint16_t(N->getZExtValue()), SDLoc(N),
30604 return CurDAG->getTargetConstant(int32_t(N->getZExtValue()), SDLoc(N),
30611 return CurDAG->getTargetConstant(N->getZExtValue() & 0xfe, SDLoc(N),
30619 return CurDAG->getTargetConstant(Value, SDLoc(N), MVT::i64);
30626 return CurDAG->getTargetConstant(Value, SDLoc(N), MVT::i64);
30632 return CurDAG->getTargetConstant(uint32_t(-N->getZExtValue()), SDLoc(N),
30639 return CurDAG->getTargetConstant(N->getZExtValue() & 0xfff, SDLoc(N),
gen/lib/Target/WebAssembly/WebAssemblyGenDAGISel.inc21204 return CurDAG->MaskedValueIsZero(N->getOperand(0), CN->getAPIntValue());
21206 KnownBits Known0 = CurDAG->computeKnownBits(N->getOperand(0), 0);
21207 KnownBits Known1 = CurDAG->computeKnownBits(N->getOperand(1), 0);
gen/lib/Target/X86/X86GenDAGISel.inc254120 KnownBits Known = CurDAG->computeKnownBits(N->getOperand(1));
254136 return CurDAG->MaskedValueIsZero(N->getOperand(0), CN->getAPIntValue());
254138 KnownBits Known0 = CurDAG->computeKnownBits(N->getOperand(0), 0);
254139 KnownBits Known1 = CurDAG->computeKnownBits(N->getOperand(1), 0);
254805 return CurDAG->getTargetConstant(X86::GetOppositeBranchCondition(CC),
include/llvm/CodeGen/SelectionDAGISel.h 212 CurDAG->ReplaceAllUsesOfValueWith(F, T);
219 CurDAG->ReplaceAllUsesOfValuesWith(F, T, Num);
227 CurDAG->ReplaceAllUsesWith(F, T);
233 CurDAG->ReplaceAllUsesWith(F, T);
235 CurDAG->RemoveDeadNode(F);
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 9705 *CurDAG->getContext(), F.getCallingConv(), VT);
9707 *CurDAG->getContext(), F.getCallingConv(), VT);
9760 MVT RegVT = TLI->getRegisterType(*CurDAG->getContext(), VT);
9814 MVT PartVT = TLI->getRegisterTypeForCallingConv(*CurDAG->getContext(),
9817 *CurDAG->getContext(), F.getCallingConv(), VT);
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp 314 SDB(new SelectionDAGBuilder(*CurDAG, *FuncInfo, *SwiftError, OL)),
328 delete CurDAG;
450 CurDAG->init(*MF, *ORE, this, LibInfo,
452 FuncInfo->set(Fn, *MF, CurDAG);
718 CurDAG->NewNodesMustHaveLegalTypes = false;
728 CurDAG->setRoot(SDB->getControlRoot());
741 Worklist.push_back(CurDAG->getRoot().getNode());
771 unsigned NumSignBits = CurDAG->ComputeNumSignBits(Src);
772 Known = CurDAG->computeKnownBits(Src);
788 CurDAG->NewNodesMustHaveLegalTypes = false;
807 CurDAG->dump());
810 CurDAG->viewGraph("dag-combine1 input for " + BlockName);
816 CurDAG->Combine(BeforeLegalizeTypes, AA, OptLevel);
821 CurDAG->VerifyDAGDiverence();
827 CurDAG->dump());
832 CurDAG->viewGraph("legalize-types input for " + BlockName);
838 Changed = CurDAG->LegalizeTypes();
843 CurDAG->VerifyDAGDiverence();
849 CurDAG->dump());
852 CurDAG->NewNodesMustHaveLegalTypes = true;
856 CurDAG->viewGraph("dag-combine-lt input for " + BlockName);
862 CurDAG->Combine(AfterLegalizeTypes, AA, OptLevel);
867 CurDAG->VerifyDAGDiverence();
873 CurDAG->dump());
879 Changed = CurDAG->LegalizeVectors();
886 CurDAG->dump());
891 CurDAG->LegalizeTypes();
897 CurDAG->dump());
900 CurDAG->viewGraph("dag-combine-lv input for " + BlockName);
906 CurDAG->Combine(AfterLegalizeVectorOps, AA, OptLevel);
912 CurDAG->dump());
916 CurDAG->VerifyDAGDiverence();
921 CurDAG->viewGraph("legalize input for " + BlockName);
926 CurDAG->Legalize();
931 CurDAG->VerifyDAGDiverence();
937 CurDAG->dump());
940 CurDAG->viewGraph("dag-combine2 input for " + BlockName);
946 CurDAG->Combine(AfterLegalizeDAG, AA, OptLevel);
951 CurDAG->VerifyDAGDiverence();
957 CurDAG->dump());
963 CurDAG->viewGraph("isel input for " + BlockName);
976 CurDAG->dump());
979 CurDAG->viewGraph("scheduler input for " + BlockName);
986 Scheduler->Run(CurDAG, FuncInfo->MBB);
1017 CurDAG->clear();
1104 DAGSize = CurDAG->AssignTopologicalOrder();
1109 HandleSDNode Dummy(CurDAG->getRoot());
1110 SelectionDAG::allnodes_iterator ISelPosition (CurDAG->getRoot().getNode());
1115 ISelUpdater ISU(*CurDAG, ISelPosition);
1121 while (ISelPosition != CurDAG->allnodes_begin()) {
1165 Node = CurDAG->mutateStrictFPToFP(Node);
1168 Node->dump(CurDAG));
1173 CurDAG->setRoot(Dummy.getValue());
1231 TLI->getRegClassFor(TLI->getPointerTy(CurDAG->getDataLayout()));
1356 CurDAG->setFunctionLoweringInfo(FuncInfo);
1377 CurDAG->setRoot(SDB->getControlRoot());
1726 CurDAG->setRoot(SDB->getRoot());
1754 CurDAG->setRoot(SDB->getRoot());
1764 CurDAG->setRoot(SDB->getRoot());
1782 CurDAG->setRoot(SDB->getRoot());
1819 CurDAG->setRoot(SDB->getRoot());
1869 CurDAG->setRoot(SDB->getRoot());
1879 CurDAG->setRoot(SDB->getRoot());
1916 CurDAG->setRoot(SDB->getRoot());
1987 if (CurDAG->MaskedValueIsZero(LHS, NeededMask))
2016 KnownBits Known = CurDAG->computeKnownBits(LHS);
2077 Ops.push_back(CurDAG->getTargetConstant(NewFlags, DL, MVT::i32));
2225 SDValue New = CurDAG->getNode(Branch ? ISD::INLINEASM_BR : ISD::INLINEASM, DL, VTs, Ops);
2228 CurDAG->RemoveDeadNode(N);
2237 CurDAG->getMachineFunction());
2238 SDValue New = CurDAG->getCopyFromReg(
2242 CurDAG->RemoveDeadNode(Op);
2251 CurDAG->getMachineFunction());
2252 SDValue New = CurDAG->getCopyToReg(
2256 CurDAG->RemoveDeadNode(Op);
2260 CurDAG->SelectNodeTo(N, TargetOpcode::IMPLICIT_DEF, N->getValueType(0));
2314 *CurDAG, [&](SDNode *N, SDNode *E) {
2329 CurDAG->RemoveDeadNodes(NowDeadNodes);
2422 SDNode *Res = CurDAG->MorphNodeTo(Node, ~TargetOpc, VTList, Ops);
2632 SDISel.CurDAG->getDataLayout());
2637 SDISel.CurDAG->getDataLayout());
2649 Table, Index, N, SDISel.TLI, SDISel.CurDAG->getDataLayout(),
2660 SDISel.CurDAG->getDataLayout());
2783 CurDAG->RemoveDeadNode(NodeToMatch);
2963 LLVM_DEBUG(dbgs() << "Expected MemSDNode "; N->dump(CurDAG);
3044 MSU.reset(new MatchStateUpdater(*CurDAG, &NodeToMatch, RecordedNodes,
3059 CurDAG->getDataLayout()))
3066 CurDAG->getDataLayout()))
3115 CaseVT = TLI->getPointerTy(CurDAG->getDataLayout());
3139 CurDAG->getDataLayout(),
3151 CurDAG->getDataLayout()))
3206 CurDAG->getTargetConstant(Val, SDLoc(NodeToMatch),
3215 CurDAG->getRegister(RegNo, VT), nullptr));
3227 CurDAG->getRegister(RegNo, VT), nullptr));
3239 Imm = CurDAG->getTargetConstant(*Val, SDLoc(NodeToMatch),
3243 Imm = CurDAG->getTargetConstantFP(*Val, SDLoc(NodeToMatch),
3274 InputChain = HandleMergeInputChains(ChainNodesMatched, CurDAG);
3316 InputChain = HandleMergeInputChains(ChainNodesMatched, CurDAG);
3333 InputChain = CurDAG->getEntryNode();
3335 InputChain = CurDAG->getCopyToReg(InputChain, SDLoc(NodeToMatch),
3382 VT = TLI->getPointerTy(CurDAG->getDataLayout()).SimpleTy;
3395 VTList = CurDAG->getVTList(VTs[0]);
3397 VTList = CurDAG->getVTList(VTs[0], VTs[1]);
3399 VTList = CurDAG->getVTList(VTs);
3443 Res = CurDAG->getMachineNode(TargetOpc, SDLoc(NodeToMatch),
3455 SelectionDAG::DAGNodeDeletedListener NDL(*CurDAG, [&](SDNode *N,
3457 CurDAG->salvageDebugInfo(*N);
3504 CurDAG->setNodeMemRefs(Res, FilteredMemRefs);
3511 Res->dump(CurDAG););
3564 CurDAG->RemoveDeadNode(NodeToMatch);
3649 N->printrFull(Msg, CurDAG);
lib/Target/AArch64/AArch64ISelDAGToDAG.cpp 282 SDValue RC = CurDAG->getTargetConstant(TRC->getID(), dl, MVT::i64);
284 SDValue(CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
319 Val = CurDAG->getTargetConstant(Immed, dl, MVT::i32);
320 Shift = CurDAG->getTargetConstant(ShVal, dl, MVT::i32);
353 return SelectArithImmed(CurDAG->getConstant(Immed, SDLoc(N), MVT::i32), Val,
441 Shift = CurDAG->getTargetConstant(ShVal, SDLoc(N), MVT::i32);
559 SDValue LaneIdxVal = CurDAG->getTargetConstant(LaneIdx, dl, MVT::i64);
582 ReplaceNode(N, CurDAG->getMachineNode(MLAOpc, dl, N->getValueType(0), Ops));
596 SDValue LaneIdxVal = CurDAG->getTargetConstant(LaneIdx, dl, MVT::i64);
627 ReplaceNode(N, CurDAG->getMachineNode(SMULLOpc, dl, N->getValueType(0), Ops));
686 Reg = narrowIfNeeded(CurDAG, Reg);
687 Shift = CurDAG->getTargetConstant(getArithExtendImm(Ext, ShiftVal), SDLoc(N),
721 const DataLayout &DL = CurDAG->getDataLayout();
725 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
726 OffImm = CurDAG->getTargetConstant(0, dl, MVT::i64);
732 if (CurDAG->isBaseWithConstantOffset(N)) {
744 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
746 OffImm = CurDAG->getTargetConstant(RHSC >> Scale, dl, MVT::i64);
759 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
761 OffImm = CurDAG->getTargetConstant(RHSC >> Scale, dl, MVT::i64);
772 OffImm = CurDAG->getTargetConstant(0, dl, MVT::i64);
782 const DataLayout &DL = CurDAG->getDataLayout();
786 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
787 OffImm = CurDAG->getTargetConstant(0, dl, MVT::i64);
811 if (CurDAG->isBaseWithConstantOffset(N)) {
819 Base = CurDAG->getTargetFrameIndex(FI, TLI->getPointerTy(DL));
821 OffImm = CurDAG->getTargetConstant(RHSC >> Scale, dl, MVT::i64);
837 OffImm = CurDAG->getTargetConstant(0, dl, MVT::i64);
849 if (!CurDAG->isBaseWithConstantOffset(N))
862 Base = CurDAG->getTargetFrameIndex(
863 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
865 OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i64);
899 Offset = narrowIfNeeded(CurDAG, N.getOperand(0).getOperand(0));
900 SignExtend = CurDAG->getTargetConstant(Ext == AArch64_AM::SXTW, dl,
904 SignExtend = CurDAG->getTargetConstant(0, dl, MVT::i32);
947 DoShift = CurDAG->getTargetConstant(true, dl, MVT::i32);
955 DoShift = CurDAG->getTargetConstant(true, dl, MVT::i32);
960 DoShift = CurDAG->getTargetConstant(false, dl, MVT::i32);
968 Offset = narrowIfNeeded(CurDAG, LHS.getOperand(0));
969 SignExtend = CurDAG->getTargetConstant(Ext == AArch64_AM::SXTW, dl,
980 Offset = narrowIfNeeded(CurDAG, RHS.getOperand(0));
981 SignExtend = CurDAG->getTargetConstant(Ext == AArch64_AM::SXTW, dl,
1047 CurDAG->getMachineNode(AArch64::MOVi64imm, DL, MVT::i64, Ops);
1050 N = CurDAG->getNode(ISD::ADD, DL, MVT::i64, LHS, MOVIV);
1060 DoShift = CurDAG->getTargetConstant(true, DL, MVT::i32);
1068 DoShift = CurDAG->getTargetConstant(true, DL, MVT::i32);
1075 SignExtend = CurDAG->getTargetConstant(false, DL, MVT::i32);
1076 DoShift = CurDAG->getTargetConstant(false, DL, MVT::i32);
1115 CurDAG->getTargetConstant(RegClassIDs[Regs.size() - 2], DL, MVT::i32));
1120 Ops.push_back(CurDAG->getTargetConstant(SubRegs[i], DL, MVT::i32));
1124 CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, DL, MVT::Untyped, Ops);
1146 ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, VT, Ops));
1220 SDValue Offset = CurDAG->getTargetConstant(OffsetVal, dl, MVT::i64);
1222 SDNode *Res = CurDAG->getMachineNode(Opcode, dl, MVT::i64, DstVT,
1227 SDValue SubReg = CurDAG->getTargetConstant(AArch64::sub_32, dl, MVT::i32);
1229 SDValue(CurDAG->getMachineNode(
1231 CurDAG->getTargetConstant(0, dl, MVT::i64), LoadedVal,
1239 CurDAG->RemoveDeadNode(N);
1254 SDNode *Ld = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
1258 CurDAG->getTargetExtractSubreg(SubRegIdx + i, dl, VT, SuperReg));
1264 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Ld), {MemOp});
1266 CurDAG->RemoveDeadNode(N);
1282 SDNode *Ld = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
1294 CurDAG->getTargetExtractSubreg(SubRegIdx + i, dl, VT, SuperReg));
1298 CurDAG->RemoveDeadNode(N);
1312 SDNode *St = CurDAG->getMachineNode(Opc, dl, N->getValueType(0), Ops);
1316 CurDAG->setNodeMemRefs(cast<MachineSDNode>(St), {MemOp});
1337 SDNode *St = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
1388 WidenVector(*CurDAG));
1397 SDValue Ops[] = {RegSeq, CurDAG->getTargetConstant(LaneNo, dl, MVT::i64),
1399 SDNode *Ld = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
1406 SDValue NV = CurDAG->getTargetExtractSubreg(QSubs[i], dl, WideVT, SuperReg);
1408 NV = NarrowVector(NV, *CurDAG);
1413 CurDAG->RemoveDeadNode(N);
1427 WidenVector(*CurDAG));
1438 CurDAG->getTargetConstant(LaneNo, dl,
1443 SDNode *Ld = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
1452 Narrow ? NarrowVector(SuperReg, *CurDAG) : SuperReg);
1458 SDValue NV = CurDAG->getTargetExtractSubreg(QSubs[i], dl, WideVT,
1461 NV = NarrowVector(NV, *CurDAG);
1468 CurDAG->RemoveDeadNode(N);
1482 WidenVector(*CurDAG));
1489 SDValue Ops[] = {RegSeq, CurDAG->getTargetConstant(LaneNo, dl, MVT::i64),
1491 SDNode *St = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
1495 CurDAG->setNodeMemRefs(cast<MachineSDNode>(St), {MemOp});
1511 WidenVector(*CurDAG));
1521 SDValue Ops[] = {RegSeq, CurDAG->getTargetConstant(LaneNo, dl, MVT::i64),
1525 SDNode *St = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
1529 CurDAG->setNodeMemRefs(cast<MachineSDNode>(St), {MemOp});
1787 SDValue Opd0 = Widen(CurDAG, Op.getOperand(0));
1790 SDValue Ops[] = {Opd0, CurDAG->getTargetConstant(Immr, dl, VT),
1791 CurDAG->getTargetConstant(Imms, dl, VT)};
1792 CurDAG->SelectNodeTo(N, AArch64::SBFMXri, VT, Ops);
1840 if (!isBitfieldExtractOp(CurDAG, N, Opc, Opd0, Immr, Imms))
1849 SDValue Ops64[] = {Opd0, CurDAG->getTargetConstant(Immr, dl, MVT::i64),
1850 CurDAG->getTargetConstant(Imms, dl, MVT::i64)};
1852 SDNode *BFM = CurDAG->getMachineNode(Opc, dl, MVT::i64, Ops64);
1853 SDValue SubReg = CurDAG->getTargetConstant(AArch64::sub_32, dl, MVT::i32);
1854 ReplaceNode(N, CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG, dl,
1859 SDValue Ops[] = {Opd0, CurDAG->getTargetConstant(Immr, dl, VT),
1860 CurDAG->getTargetConstant(Imms, dl, VT)};
1861 CurDAG->SelectNodeTo(N, Opc, VT, Ops);
2450 CurDAG->SelectNodeTo(N, TargetOpcode::IMPLICIT_DEF, N->getValueType(0));
2454 if (tryBitfieldInsertOpFromOr(N, NUsefulBits, CurDAG))
2457 return tryBitfieldInsertOpFromOrAndImm(N, CurDAG);
2473 if (!isBitfieldPositioningOp(CurDAG, SDValue(N, 0), /*BiggerPattern=*/false,
2483 SDValue Ops[] = {Op0, CurDAG->getTargetConstant(ImmR, DL, VT),
2484 CurDAG->getTargetConstant(ImmS, DL, VT)};
2486 CurDAG->SelectNodeTo(N, Opc, VT, Ops);
2559 CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL, ZeroReg, SubVT);
2559 CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL, ZeroReg, SubVT);
2561 CurDAG->getMachineNode(NegOpc, DL, SubVT, Zero, Add1);
2581 NewShiftAmt = narrowIfNeeded(CurDAG, NewShiftAmt);
2583 SDValue SubReg = CurDAG->getTargetConstant(AArch64::sub_32, DL, MVT::i32);
2584 MachineSDNode *Ext = CurDAG->getMachineNode(
2586 CurDAG->getTargetConstant(0, DL, MVT::i64), NewShiftAmt, SubReg);
2591 CurDAG->SelectNodeTo(N, Opc, VT, Ops);
2635 FixedPos = CurDAG->getTargetConstant(FBits, SDLoc(N), MVT::i32);
2681 ReplaceNode(N, CurDAG->getMachineNode(
2683 CurDAG->getTargetConstant(Reg, DL, MVT::i32),
2698 ReplaceNode(N, CurDAG->getMachineNode(
2700 CurDAG->getTargetConstant(Reg, DL, MVT::i32),
2706 ReplaceNode(N, CurDAG->getMachineNode(
2708 CurDAG->getTargetConstant(0, DL, MVT::i32),
2728 N, CurDAG->getMachineNode(AArch64::MSR, DL, MVT::Other,
2729 CurDAG->getTargetConstant(Reg, DL, MVT::i32),
2753 ReplaceNode(N, CurDAG->getMachineNode(
2755 CurDAG->getTargetConstant(Reg, DL, MVT::i32),
2756 CurDAG->getTargetConstant(Immed, DL, MVT::i16),
2771 ReplaceNode(N, CurDAG->getMachineNode(
2773 CurDAG->getTargetConstant(Reg, DL, MVT::i32),
2803 SDNode *CmpSwap = CurDAG->getMachineNode(
2805 CurDAG->getVTList(RegTy, MVT::i32, MVT::Other), Ops);
2808 CurDAG->setNodeMemRefs(cast<MachineSDNode>(CmpSwap), {MemOp});
2812 CurDAG->RemoveDeadNode(N);
2835 SDValue FiOp = CurDAG->getTargetFrameIndex(
2836 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
2839 SDNode *Out = CurDAG->getMachineNode(
2841 {FiOp, CurDAG->getTargetConstant(0, DL, MVT::i64), N->getOperand(2),
2842 CurDAG->getTargetConstant(TagOffset, DL, MVT::i64)});
2858 SDNode *N1 = CurDAG->getMachineNode(AArch64::SUBP, DL, MVT::i64,
2860 SDNode *N2 = CurDAG->getMachineNode(AArch64::ADDXrr, DL, MVT::i64,
2862 SDNode *N3 = CurDAG->getMachineNode(
2864 {SDValue(N2, 0), CurDAG->getTargetConstant(0, DL, MVT::i64),
2865 CurDAG->getTargetConstant(TagOffset, DL, MVT::i64)});
2872 LLVM_DEBUG(errs() << "== "; Node->dump(CurDAG); errs() << "\n");
2943 SDValue New = CurDAG->getCopyFromReg(
2944 CurDAG->getEntryNode(), SDLoc(Node), AArch64::WZR, MVT::i32);
2948 SDValue New = CurDAG->getCopyFromReg(
2949 CurDAG->getEntryNode(), SDLoc(Node), AArch64::XZR, MVT::i64);
2962 SDValue TFI = CurDAG->getTargetFrameIndex(
2963 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
2965 SDValue Ops[] = { TFI, CurDAG->getTargetConstant(0, DL, MVT::i32),
2966 CurDAG->getTargetConstant(Shifter, DL, MVT::i32) };
2967 CurDAG->SelectNodeTo(Node, AArch64::ADDXri, MVT::i64, Ops);
2983 SDNode *Ld = CurDAG->getMachineNode(Op, DL, MVT::i64, MVT::i64,
2989 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Ld), {MemOp});
3006 SDNode *St = CurDAG->getMachineNode(Op, DL, MVT::i32, MVT::Other, Ops);
3010 CurDAG->setNodeMemRefs(cast<MachineSDNode>(St), {MemOp});
lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp 416 SDVTList VTList = CurDAG->getVTList(VT, MVT::Other);
418 SDValue TiedIn = CurDAG->getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), VT, Lo);
432 CurDAG->getMemIntrinsicNode(LoadOp, SDLoc(LdHi), VTList,
436 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), NewLoadHi);
437 CurDAG->ReplaceAllUsesOfValueWith(SDValue(LdHi, 1), NewLoadHi.getValue(1));
450 SDVTList VTList = CurDAG->getVTList(VT, MVT::Other);
459 TiedIn = CurDAG->getNode(ISD::BITCAST, SDLoc(N), VT, TiedIn);
466 CurDAG->getMemIntrinsicNode(LoadOp, SDLoc(LdLo), VTList,
470 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), NewLoadLo);
471 CurDAG->ReplaceAllUsesOfValueWith(SDValue(LdLo, 1), NewLoadLo.getValue(1));
482 SelectionDAG::allnodes_iterator Position = CurDAG->allnodes_end();
485 while (Position != CurDAG->allnodes_begin()) {
500 CurDAG->RemoveDeadNodes();
502 CurDAG->dump(););
514 return CurDAG->isKnownNeverNaN(N);
551 MachineRegisterInfo &MRI = CurDAG->getMachineFunction().getRegInfo();
597 return CurDAG->MorphNodeTo(N, N->getOpcode(), N->getVTList(), Ops);
606 SDValue M0 = Lowering.copyToM0(*CurDAG, N->getOperand(0), SDLoc(N), Val);
614 return glueCopyToM0(N, CurDAG->getTargetConstant(-1, SDLoc(N), MVT::i32));
616 MachineFunction &MF = CurDAG->getMachineFunction();
619 glueCopyToM0(N, CurDAG->getTargetConstant(Value, SDLoc(N), MVT::i32));
626 SDNode *Lo = CurDAG->getMachineNode(
628 CurDAG->getTargetConstant(Imm & 0xFFFFFFFF, DL, MVT::i32));
630 CurDAG->getMachineNode(AMDGPU::S_MOV_B32, DL, MVT::i32,
631 CurDAG->getTargetConstant(Imm >> 32, DL, MVT::i32));
633 CurDAG->getTargetConstant(AMDGPU::SReg_64RegClassID, DL, MVT::i32),
634 SDValue(Lo, 0), CurDAG->getTargetConstant(AMDGPU::sub0, DL, MVT::i32),
635 SDValue(Hi, 0), CurDAG->getTargetConstant(AMDGPU::sub1, DL, MVT::i32)};
637 return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, DL, VT, Ops);
668 SDValue RegClass = CurDAG->getTargetConstant(RegClassID, DL, MVT::i32);
671 CurDAG->SelectNodeTo(N, AMDGPU::COPY_TO_REGCLASS, EltVT, N->getOperand(0),
683 RegSeqArgs[0] = CurDAG->getTargetConstant(RegClassID, DL, MVT::i32);
694 RegSeqArgs[1 + (2 * i) + 1] = CurDAG->getTargetConstant(Sub, DL, MVT::i32);
699 MachineSDNode *ImpDef = CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,
705 CurDAG->getTargetConstant(Sub, DL, MVT::i32);
711 CurDAG->SelectNodeTo(N, AMDGPU::REG_SEQUENCE, N->getVTList(), RegSeqArgs);
776 if (SDNode *Packed = packConstantV2I16(N, *CurDAG)) {
794 RC = CurDAG->getTargetConstant(AMDGPU::SGPR_128RegClassID, DL, MVT::i32);
795 SubReg0 = CurDAG->getTargetConstant(AMDGPU::sub0_sub1, DL, MVT::i32);
796 SubReg1 = CurDAG->getTargetConstant(AMDGPU::sub2_sub3, DL, MVT::i32);
798 RC = CurDAG->getTargetConstant(AMDGPU::SReg_64RegClassID, DL, MVT::i32);
799 SubReg0 = CurDAG->getTargetConstant(AMDGPU::sub0, DL, MVT::i32);
800 SubReg1 = CurDAG->getTargetConstant(AMDGPU::sub1, DL, MVT::i32);
806 ReplaceNode(N, CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, DL,
871 N = Lowering.legalizeTargetIndependentNode(N, *CurDAG);
901 N = CurDAG->MorphNodeTo(N, N->getOpcode(), CurDAG->getVTList(NewVT),
901 N = CurDAG->MorphNodeTo(N, N->getOpcode(), CurDAG->getVTList(NewVT),
952 Base = CurDAG->getRegister(R600::INDIRECT_BASE_ADDR, MVT::i32);
953 Offset = CurDAG->getTargetConstant(C->getZExtValue(), DL, MVT::i32);
956 Base = CurDAG->getRegister(R600::INDIRECT_BASE_ADDR, MVT::i32);
957 Offset = CurDAG->getTargetConstant(C->getZExtValue(), DL, MVT::i32);
961 Offset = CurDAG->getTargetConstant(C->getZExtValue(), DL, MVT::i32);
964 Offset = CurDAG->getTargetConstant(0, DL, MVT::i32);
972 SDNode *Mov = CurDAG->getMachineNode(
974 CurDAG->getTargetConstant(Val, DL, MVT::i32));
990 SDValue Sub0 = CurDAG->getTargetConstant(AMDGPU::sub0, DL, MVT::i32);
991 SDValue Sub1 = CurDAG->getTargetConstant(AMDGPU::sub1, DL, MVT::i32);
993 SDNode *Lo0 = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
995 SDNode *Hi0 = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
998 SDNode *Lo1 = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
1000 SDNode *Hi1 = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
1003 SDVTList VTList = CurDAG->getVTList(MVT::i32, MVT::Glue);
1011 AddLo = CurDAG->getMachineNode(Opc, DL, VTList, Args);
1014 AddLo = CurDAG->getMachineNode(CarryOpc, DL, VTList, Args);
1021 SDNode *AddHi = CurDAG->getMachineNode(CarryOpc, DL, VTList, AddHiArgs);
1024 CurDAG->getTargetConstant(AMDGPU::SReg_64RegClassID, DL, MVT::i32),
1030 SDNode *RegSequence = CurDAG->getMachineNode(AMDGPU::REG_SEQUENCE, DL,
1050 CurDAG->SelectNodeTo(
1052 {LHS, RHS, CI, CurDAG->getTargetConstant(0, {}, MVT::i1) /*clamp bit*/});
1062 CurDAG->SelectNodeTo(
1065 CurDAG->getTargetConstant(0, {}, MVT::i1) /*clamp bit*/});
1079 CurDAG->SelectNodeTo(N, AMDGPU::V_FMA_F32, N->getVTList(), Ops);
1092 CurDAG->SelectNodeTo(N, AMDGPU::V_MUL_F32_e64, N->getVTList(), Ops);
1107 CurDAG->SelectNodeTo(N, Opc, N->getVTList(), Ops);
1124 SDValue VCC = CurDAG->getCopyToReg(CurDAG->getEntryNode(), SL,
1124 SDValue VCC = CurDAG->getCopyToReg(CurDAG->getEntryNode(), SL,
1136 CurDAG->SelectNodeTo(N, Opc, N->getVTList(), Ops);
1146 SDValue Clamp = CurDAG->getTargetConstant(0, SL, MVT::i1);
1149 CurDAG->SelectNodeTo(N, Opc, N->getVTList(), Ops);
1164 return CurDAG->SignBitIsZero(Base);
1170 if (CurDAG->isBaseWithConstantOffset(Addr)) {
1177 Offset = CurDAG->getTargetConstant(C1->getZExtValue(), DL, MVT::i16);
1185 SDValue Zero = CurDAG->getTargetConstant(0, DL, MVT::i32);
1190 SDValue Sub = CurDAG->getNode(ISD::SUB, DL, MVT::i32,
1203 CurDAG->getTargetConstant(0, {}, MVT::i1)); // clamp bit
1207 CurDAG->getMachineNode(SubOp, DL, MVT::i32, Opnds);
1210 Offset = CurDAG->getTargetConstant(ByteOffset, DL, MVT::i16);
1224 SDValue Zero = CurDAG->getTargetConstant(0, DL, MVT::i32);
1225 MachineSDNode *MovZero = CurDAG->getMachineNode(AMDGPU::V_MOV_B32_e32,
1228 Offset = CurDAG->getTargetConstant(CAddr->getZExtValue(), DL, MVT::i16);
1235 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), MVT::i16);
1245 if (CurDAG->isBaseWithConstantOffset(Addr)) {
1254 Offset0 = CurDAG->getTargetConstant(DWordOffset0, DL, MVT::i8);
1255 Offset1 = CurDAG->getTargetConstant(DWordOffset1, DL, MVT::i8);
1266 SDValue Zero = CurDAG->getTargetConstant(0, DL, MVT::i32);
1271 SDValue Sub = CurDAG->getNode(ISD::SUB, DL, MVT::i32,
1282 CurDAG->getTargetConstant(0, {}, MVT::i1)); // clamp bit
1286 = CurDAG->getMachineNode(SubOp, DL, MVT::i32, Opnds);
1289 Offset0 = CurDAG->getTargetConstant(DWordOffset0, DL, MVT::i8);
1290 Offset1 = CurDAG->getTargetConstant(DWordOffset1, DL, MVT::i8);
1301 SDValue Zero = CurDAG->getTargetConstant(0, DL, MVT::i32);
1303 = CurDAG->getMachineNode(AMDGPU::V_MOV_B32_e32,
1306 Offset0 = CurDAG->getTargetConstant(DWordOffset0, DL, MVT::i8);
1307 Offset1 = CurDAG->getTargetConstant(DWordOffset1, DL, MVT::i8);
1315 Offset0 = CurDAG->getTargetConstant(0, DL, MVT::i8);
1316 Offset1 = CurDAG->getTargetConstant(1, DL, MVT::i8);
1334 GLC = CurDAG->getTargetConstant(0, DL, MVT::i1);
1336 SLC = CurDAG->getTargetConstant(0, DL, MVT::i1);
1337 TFE = CurDAG->getTargetConstant(0, DL, MVT::i1);
1338 DLC = CurDAG->getTargetConstant(0, DL, MVT::i1);
1339 SWZ = CurDAG->getTargetConstant(0, DL, MVT::i1);
1341 Idxen = CurDAG->getTargetConstant(0, DL, MVT::i1);
1342 Offen = CurDAG->getTargetConstant(0, DL, MVT::i1);
1343 Addr64 = CurDAG->getTargetConstant(0, DL, MVT::i1);
1344 SOffset = CurDAG->getTargetConstant(0, DL, MVT::i32);
1348 if (CurDAG->isBaseWithConstantOffset(Addr)) {
1361 Addr64 = CurDAG->getTargetConstant(1, DL, MVT::i1);
1379 Offset = CurDAG->getTargetConstant(0, DL, MVT::i16);
1385 Addr64 = CurDAG->getTargetConstant(1, DL, MVT::i1);
1389 VAddr = CurDAG->getTargetConstant(0, DL, MVT::i32);
1395 Offset = CurDAG->getTargetConstant(0, DL, MVT::i16);
1401 Offset = CurDAG->getTargetConstant(C1->getZExtValue(), DL, MVT::i16);
1406 Offset = CurDAG->getTargetConstant(0, DL, MVT::i16);
1408 SDValue(CurDAG->getMachineNode(
1410 CurDAG->getTargetConstant(C1->getZExtValue(), DL, MVT::i32)),
1437 SRsrc = SDValue(Lowering.wrapAddr64Rsrc(*CurDAG, DL, Ptr), 0);
1448 SLC = CurDAG->getTargetConstant(0, SDLoc(Addr), MVT::i1);
1460 const MachineFunction &MF = CurDAG->getMachineFunction();
1464 SDValue TFI = CurDAG->getTargetFrameIndex(FI->getIndex(),
1470 TFI, CurDAG->getRegister(Info->getStackPtrOffsetReg(), MVT::i32));
1475 return std::make_pair(N, CurDAG->getRegister(Info->getScratchWaveOffsetReg(),
1485 MachineFunction &MF = CurDAG->getMachineFunction();
1488 Rsrc = CurDAG->getRegister(Info->getScratchRSrcReg(), MVT::v4i32);
1493 SDValue HighBits = CurDAG->getTargetConstant(Imm & ~4095, DL, MVT::i32);
1494 MachineSDNode *MovHighBits = CurDAG->getMachineNode(AMDGPU::V_MOV_B32_e32,
1504 SOffset = CurDAG->getRegister(SOffsetReg, MVT::i32);
1505 ImmOffset = CurDAG->getTargetConstant(Imm & 4095, DL, MVT::i16);
1509 if (CurDAG->isBaseWithConstantOffset(Addr)) {
1533 CurDAG->SignBitIsZero(N0))) {
1535 ImmOffset = CurDAG->getTargetConstant(C1->getZExtValue(), DL, MVT::i16);
1542 ImmOffset = CurDAG->getTargetConstant(0, DL, MVT::i16);
1556 MachineFunction &MF = CurDAG->getMachineFunction();
1559 SRsrc = CurDAG->getRegister(Info->getScratchRSrcReg(), MVT::v4i32);
1567 SOffset = CurDAG->getRegister(SOffsetReg, MVT::i32);
1569 Offset = CurDAG->getTargetConstant(CAddr->getZExtValue(), DL, MVT::i16);
1596 SRsrc = SDValue(Lowering.buildRSRC(*CurDAG, DL, Ptr, 0, Rsrc), 0);
1642 CurDAG->isBaseWithConstantOffset(Addr)) {
1688 SDValue Sub0 = CurDAG->getTargetConstant(AMDGPU::sub0, DL, MVT::i32);
1689 SDValue Sub1 = CurDAG->getTargetConstant(AMDGPU::sub1, DL, MVT::i32);
1691 SDNode *N0Lo = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
1693 SDNode *N0Hi = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
1701 SDVTList VTs = CurDAG->getVTList(MVT::i32, MVT::i1);
1702 SDValue Clamp = CurDAG->getTargetConstant(0, DL, MVT::i1);
1704 SDNode *Add = CurDAG->getMachineNode(
1708 SDNode *Addc = CurDAG->getMachineNode(
1713 CurDAG->getTargetConstant(AMDGPU::VReg_64RegClassID, DL, MVT::i32),
1717 Addr = SDValue(CurDAG->getMachineNode(AMDGPU::REG_SEQUENCE, DL,
1723 Offset = CurDAG->getTargetConstant(OffsetVal, SDLoc(), MVT::i16);
1724 SLC = CurDAG->getTargetConstant(0, SDLoc(), MVT::i1);
1758 Offset = CurDAG->getTargetConstant(EncodedOffset, SL, MVT::i32);
1768 Offset = CurDAG->getTargetConstant(EncodedOffset, SL, MVT::i32);
1770 SDValue C32Bit = CurDAG->getTargetConstant(ByteOffset, SL, MVT::i32);
1771 Offset = SDValue(CurDAG->getMachineNode(AMDGPU::S_MOV_B32, SL, MVT::i32,
1785 const MachineFunction &MF = CurDAG->getMachineFunction();
1788 SDValue AddrHi = CurDAG->getTargetConstant(AddrHiVal, SL, MVT::i32);
1791 CurDAG->getTargetConstant(AMDGPU::SReg_64_XEXECRegClassID, SL, MVT::i32),
1793 CurDAG->getTargetConstant(AMDGPU::sub0, SL, MVT::i32),
1794 SDValue(CurDAG->getMachineNode(AMDGPU::S_MOV_B32, SL, MVT::i32, AddrHi),
1796 CurDAG->getTargetConstant(AMDGPU::sub1, SL, MVT::i32),
1799 return SDValue(CurDAG->getMachineNode(AMDGPU::REG_SEQUENCE, SL, MVT::i64,
1811 CurDAG->isBaseWithConstantOffset(Addr)) {
1821 Offset = CurDAG->getTargetConstant(0, SL, MVT::i32);
1875 if (CurDAG->isBaseWithConstantOffset(Index)) {
1883 if (C1->getSExtValue() <= 0 || CurDAG->SignBitIsZero(N0)) {
1885 Offset = CurDAG->getTargetConstant(C1->getZExtValue(), DL, MVT::i32);
1894 Offset = CurDAG->getTargetConstant(0, DL, MVT::i32);
1905 SDValue PackedConst = CurDAG->getTargetConstant(PackedVal, DL, MVT::i32);
1907 return CurDAG->getMachineNode(Opcode, DL, MVT::i32, Val, PackedConst);
2041 CurDAG->SelectNodeTo(N, AMDGPU::SI_BR_UNDEF, MVT::Other,
2068 Cond = SDValue(CurDAG->getMachineNode(ST->isWave32() ? AMDGPU::S_AND_B32
2071 CurDAG->getRegister(ST->isWave32() ? AMDGPU::EXEC_LO
2078 SDValue VCC = CurDAG->getCopyToReg(N->getOperand(0), SL, CondReg, Cond);
2079 CurDAG->SelectNodeTo(N, BrOp, MVT::Other,
2113 SDValue Zero = CurDAG->getTargetConstant(0, SDLoc(), MVT::i32);
2115 CurDAG->getTargetConstant(Src0Mods, SDLoc(), MVT::i32), Src0,
2116 CurDAG->getTargetConstant(Src1Mods, SDLoc(), MVT::i32), Src1,
2117 CurDAG->getTargetConstant(Src2Mods, SDLoc(), MVT::i32), Src2,
2118 CurDAG->getTargetConstant(0, SDLoc(), MVT::i1),
2122 CurDAG->SelectNodeTo(N,
2159 CmpSwap = CurDAG->getMachineNode(Opcode, SL, Mem->getVTList(), Ops);
2174 CmpSwap = CurDAG->getMachineNode(Opcode, SL, Mem->getVTList(), Ops);
2184 CurDAG->setNodeMemRefs(CmpSwap, {MMO});
2188 = CurDAG->getTargetExtractSubreg(SubReg, SL, VT, SDValue(CmpSwap, 0));
2192 CurDAG->RemoveDeadNode(N);
2208 if (CurDAG->isBaseWithConstantOffset(Ptr)) {
2215 Offset = CurDAG->getTargetConstant(OffsetVal, SDLoc(), MVT::i32);
2221 Offset = CurDAG->getTargetConstant(0, SDLoc(), MVT::i32);
2226 CurDAG->getTargetConstant(IsGDS, SDLoc(), MVT::i32),
2231 SDNode *Selected = CurDAG->SelectNodeTo(N, Opc, N->getVTList(), Ops);
2232 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Selected), {MMO});
2283 glueCopyToM0(N, CurDAG->getTargetConstant(0, SL, MVT::i32));
2286 if (CurDAG->isBaseWithConstantOffset(BaseOffset)) {
2295 = CurDAG->getMachineNode(AMDGPU::V_READFIRSTLANE_B32, SL, MVT::i32,
2299 = CurDAG->getMachineNode(AMDGPU::S_LSHL_B32, SL, MVT::i32,
2301 CurDAG->getTargetConstant(16, SL, MVT::i32));
2306 SDValue OffsetField = CurDAG->getTargetConstant(ImmOffset, SL, MVT::i32);
2309 SDValue GDS = CurDAG->getTargetConstant(1, SL, MVT::i1);
2319 SDNode *Selected = CurDAG->SelectNodeTo(N, Opc, N->getVTList(), Ops);
2320 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Selected), {MMO});
2357 CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), {Src});
2400 SrcMods = CurDAG->getTargetConstant(Mods, SDLoc(In), MVT::i32);
2418 SrcMods = CurDAG->getTargetConstant(0, SDLoc(In), MVT::i32);;
2434 Clamp = CurDAG->getTargetConstant(0, DL, MVT::i1);
2435 Omod = CurDAG->getTargetConstant(0, DL, MVT::i1);
2444 Clamp = Omod = CurDAG->getTargetConstant(0, SDLoc(In), MVT::i32);
2453 Clamp = CurDAG->getTargetConstant(0, DL, MVT::i1);
2454 Omod = CurDAG->getTargetConstant(0, DL, MVT::i1);
2499 SrcMods = CurDAG->getTargetConstant(Mods, SDLoc(In), MVT::i32);
2509 SrcMods = CurDAG->getTargetConstant(Mods, SDLoc(In), MVT::i32);
2519 Clamp = CurDAG->getTargetConstant(0, SL, MVT::i32);
2528 SrcMods = CurDAG->getTargetConstant(0, SDLoc(In), MVT::i32);
2538 Clamp = CurDAG->getTargetConstant(0, SL, MVT::i32);
2555 Clamp = CurDAG->getTargetConstant(0, SL, MVT::i32);
2607 SrcMods = CurDAG->getTargetConstant(Mods, SDLoc(In), MVT::i32);
2613 return CurDAG->getUNDEF(MVT::i32);
2617 return CurDAG->getConstant(C->getZExtValue() << 16, SL, MVT::i32);
2622 return CurDAG->getConstant(
2634 assert(CurDAG->getTarget().getTargetTriple().getArch() == Triple::amdgcn);
2714 SelectionDAG::allnodes_iterator Position = CurDAG->allnodes_begin();
2715 while (Position != CurDAG->allnodes_end()) {
2721 SDNode *ResNode = Lowering.PostISelFolding(MachineNode, *CurDAG);
2728 CurDAG->RemoveDeadNodes();
2750 IntPtr = CurDAG->getIntPtrConstant(Cst->getZExtValue() / 4, SDLoc(Addr),
2761 Offset = CurDAG->getIntPtrConstant(0, SDLoc(Addr), true);
2810 Base = CurDAG->getRegister(R600::INDIRECT_BASE_ADDR, MVT::i32);
2811 Offset = CurDAG->getTargetConstant(C->getZExtValue(), DL, MVT::i32);
2814 Base = CurDAG->getRegister(R600::INDIRECT_BASE_ADDR, MVT::i32);
2815 Offset = CurDAG->getTargetConstant(C->getZExtValue(), DL, MVT::i32);
2819 Offset = CurDAG->getTargetConstant(C->getZExtValue(), DL, MVT::i32);
2822 Offset = CurDAG->getTargetConstant(0, DL, MVT::i32);
2837 Offset = CurDAG->getTargetConstant(IMMOffset->getZExtValue(), SDLoc(Addr),
2843 Base = CurDAG->getCopyFromReg(CurDAG->getEntryNode(),
2843 Base = CurDAG->getCopyFromReg(CurDAG->getEntryNode(),
2844 SDLoc(CurDAG->getEntryNode()),
2846 Offset = CurDAG->getTargetConstant(IMMOffset->getZExtValue(), SDLoc(Addr),
2853 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), MVT::i32);
lib/Target/ARC/ARCISelDAGToDAG.cpp 53 Pred = CurDAG->getTargetConstant(CN->getZExtValue(), SDLoc(N), MVT::i32);
54 Reg = CurDAG->getRegister(ARC::STATUS32, MVT::i32);
79 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), MVT::i32);
92 !CurDAG->isBaseWithConstantOffset(Addr)) {
96 Base = CurDAG->getTargetFrameIndex(
97 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
101 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), MVT::i32);
116 Base = CurDAG->getTargetFrameIndex(
117 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
119 Offset = CurDAG->getTargetConstant(RHSC, SDLoc(Addr), MVT::i32);
123 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), MVT::i32);
139 Offset = CurDAG->getTargetConstant(RHSC, SDLoc(Addr), MVT::i32);
150 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i32);
151 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), MVT::i32);
160 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i32);
162 CurDAG->getTargetConstant(CN->getSExtValue(), SDLoc(Addr), MVT::i32);
173 ReplaceNode(N, CurDAG->getMachineNode(
176 CurDAG->getTargetConstant(CVal, SDLoc(N), MVT::i32)));
lib/Target/ARM/ARMISelDAGToDAG.cpp 75 return CurDAG->getTargetConstant(Imm, dl, MVT::i32);
106 Pred = CurDAG->getTargetConstant(CN->getZExtValue(), SDLoc(N), MVT::i32);
107 Reg = CurDAG->getRegister(ARM::CPSR, MVT::i32);
351 for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
352 E = CurDAG->allnodes_end(); I != E; ) {
416 Srl = CurDAG->getNode(ISD::SRL, SDLoc(Srl), MVT::i32,
418 CurDAG->getConstant(Srl_imm + TZ, SDLoc(Srl),
420 N1 = CurDAG->getNode(ISD::AND, SDLoc(N1), MVT::i32,
422 CurDAG->getConstant(And_imm, SDLoc(Srl), MVT::i32));
423 N1 = CurDAG->getNode(ISD::SHL, SDLoc(N1), MVT::i32,
424 N1, CurDAG->getConstant(TZ, SDLoc(Srl), MVT::i32));
425 CurDAG->UpdateNodeOperands(N, N0, N1);
447 CurDAG->getSubtarget().getInstrInfo());
514 NewMulConst = CurDAG->getConstant(NewMulConstVal, SDLoc(N), MVT::i32);
521 CurDAG->RepositionNode(N.getNode()->getIterator(), M.getNode());
542 Opc = CurDAG->getTargetConstant(
559 Opc = CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal),
586 Opc = CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, ShImmVal),
596 return CurDAG->haveNoCommonBitsSet(N, Parent->getOperand(1));
607 !CurDAG->isBaseWithConstantOffset(N)) {
611 Base = CurDAG->getTargetFrameIndex(
612 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
613 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
624 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
637 Base = CurDAG->getTargetFrameIndex(
638 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
640 OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32);
647 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
670 Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt,
681 !CurDAG->isBaseWithConstantOffset(N))
756 Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
792 Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, ShAmt, ShOpcVal),
808 Offset = CurDAG->getRegister(0, MVT::i32);
809 Opc = CurDAG->getTargetConstant(Val, SDLoc(Op), MVT::i32);
827 Offset = CurDAG->getRegister(0, MVT::i32);
828 Opc = CurDAG->getTargetConstant(ARM_AM::getAM2Opc(AddSub, Val,
849 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::sub, 0), SDLoc(N),
854 if (!CurDAG->isBaseWithConstantOffset(N)) {
858 Base = CurDAG->getTargetFrameIndex(
859 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
861 Offset = CurDAG->getRegister(0, MVT::i32);
862 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0), SDLoc(N),
874 Base = CurDAG->getTargetFrameIndex(
875 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
877 Offset = CurDAG->getRegister(0, MVT::i32);
884 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, RHSC), SDLoc(N),
891 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(ARM_AM::add, 0), SDLoc(N),
906 Offset = CurDAG->getRegister(0, MVT::i32);
907 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, Val), SDLoc(Op),
913 Opc = CurDAG->getTargetConstant(ARM_AM::getAM3Opc(AddSub, 0), SDLoc(Op),
920 if (!CurDAG->isBaseWithConstantOffset(N)) {
924 Base = CurDAG->getTargetFrameIndex(
925 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
932 Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
945 Base = CurDAG->getTargetFrameIndex(
946 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
956 Offset = CurDAG->getTargetConstant(ARM_AM::getAM5FP16Opc(AddSub, RHSC),
959 Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(AddSub, RHSC),
968 Offset = CurDAG->getTargetConstant(ARM_AM::getAM5FP16Opc(ARM_AM::add, 0),
971 Offset = CurDAG->getTargetConstant(ARM_AM::getAM5Opc(ARM_AM::add, 0),
1012 Align = CurDAG->getTargetConstant(Alignment, SDLoc(N), MVT::i32);
1025 Offset = CurDAG->getRegister(0, MVT::i32);
1035 Label = CurDAG->getTargetConstant(cast<ConstantSDNode>(N1)->getZExtValue(),
1064 if (N.getOpcode() != ISD::ADD && !CurDAG->isBaseWithConstantOffset(N)) {
1090 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
1094 if (!CurDAG->isBaseWithConstantOffset(N)) {
1107 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
1115 OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32);
1150 Base = CurDAG->getTargetFrameIndex(
1151 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
1152 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
1156 if (!CurDAG->isBaseWithConstantOffset(N))
1175 Base = CurDAG->getTargetFrameIndex(
1176 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
1177 OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32);
1190 if (N.getOpcode() == ISD::SUB || CurDAG->isBaseWithConstantOffset(N)) {
1198 CurDAG->getTargetConstant(RHSC * (1 << Shift), SDLoc(N), MVT::i32);
1205 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
1221 !CurDAG->isBaseWithConstantOffset(N)) {
1225 Base = CurDAG->getTargetFrameIndex(
1226 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
1227 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
1240 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
1257 Base = CurDAG->getTargetFrameIndex(
1258 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
1260 OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32);
1267 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
1275 !CurDAG->isBaseWithConstantOffset(N))
1287 Base = CurDAG->getTargetFrameIndex(
1288 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
1290 OffImm = CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32);
1307 ? CurDAG->getTargetConstant(RHSC, SDLoc(N), MVT::i32)
1308 : CurDAG->getTargetConstant(-RHSC, SDLoc(N), MVT::i32);
1318 if (N.getOpcode() == ISD::SUB || CurDAG->isBaseWithConstantOffset(N)) {
1325 Base = CurDAG->getTargetFrameIndex(
1326 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
1332 CurDAG->getTargetConstant(RHSC * (1 << Shift), SDLoc(N), MVT::i32);
1339 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
1360 ? CurDAG->getTargetConstant(RHSC * (1 << Shift), SDLoc(N), MVT::i32)
1361 : CurDAG->getTargetConstant(-RHSC * (1 << Shift), SDLoc(N),
1372 if (N.getOpcode() != ISD::ADD && !CurDAG->isBaseWithConstantOffset(N))
1423 ShImm = CurDAG->getTargetConstant(ShAmt, SDLoc(N), MVT::i32);
1433 OffImm = CurDAG->getTargetConstant(0, SDLoc(N), MVT::i32);
1435 if (N.getOpcode() != ISD::ADD || !CurDAG->isBaseWithConstantOffset(N))
1449 Base = CurDAG->getTargetFrameIndex(
1450 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
1453 OffImm = CurDAG->getTargetConstant(RHSC/4, SDLoc(N), MVT::i32);
1466 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Result), {MemOp});
1525 SDValue Ops[]= { Base, AMOpc, getAL(CurDAG, SDLoc(N)),
1526 CurDAG->getRegister(0, MVT::i32), Chain };
1527 SDNode *New = CurDAG->getMachineNode(Opcode, SDLoc(N), MVT::i32, MVT::i32,
1535 SDValue Ops[]= { Base, Offset, AMOpc, getAL(CurDAG, SDLoc(N)),
1536 CurDAG->getRegister(0, MVT::i32), Chain };
1537 SDNode *New = CurDAG->getMachineNode(Opcode, SDLoc(N), MVT::i32, MVT::i32,
1566 SDValue Ops[]= { Base, getAL(CurDAG, SDLoc(N)),
1567 CurDAG->getRegister(0, MVT::i32), Chain };
1568 SDNode *New = CurDAG->getMachineNode(ARM::tLDR_postidx, SDLoc(N), MVT::i32,
1614 SDValue Ops[]= { Base, Offset, getAL(CurDAG, SDLoc(N)),
1615 CurDAG->getRegister(0, MVT::i32), Chain };
1616 SDNode *New = CurDAG->getMachineNode(Opcode, SDLoc(N), MVT::i32, MVT::i32,
1676 CurDAG->getTargetConstant(ARMVCC::None, SDLoc(N), MVT::i32),
1677 CurDAG->getRegister(0, MVT::i32), Chain};
1678 SDNode *New = CurDAG->getMachineNode(Opcode, SDLoc(N), LD->getValueType(0),
1684 CurDAG->RemoveDeadNode(N);
1692 CurDAG->getTargetConstant(ARM::GPRPairRegClassID, dl, MVT::i32);
1693 SDValue SubReg0 = CurDAG->getTargetConstant(ARM::gsub_0, dl, MVT::i32);
1694 SDValue SubReg1 = CurDAG->getTargetConstant(ARM::gsub_1, dl, MVT::i32);
1696 return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
1703 CurDAG->getTargetConstant(ARM::DPR_VFP2RegClassID, dl, MVT::i32);
1704 SDValue SubReg0 = CurDAG->getTargetConstant(ARM::ssub_0, dl, MVT::i32);
1705 SDValue SubReg1 = CurDAG->getTargetConstant(ARM::ssub_1, dl, MVT::i32);
1707 return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
1713 SDValue RegClass = CurDAG->getTargetConstant(ARM::QPRRegClassID, dl,
1715 SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, dl, MVT::i32);
1716 SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, dl, MVT::i32);
1718 return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
1724 SDValue RegClass = CurDAG->getTargetConstant(ARM::QQPRRegClassID, dl,
1726 SDValue SubReg0 = CurDAG->getTargetConstant(ARM::qsub_0, dl, MVT::i32);
1727 SDValue SubReg1 = CurDAG->getTargetConstant(ARM::qsub_1, dl, MVT::i32);
1729 return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
1737 CurDAG->getTargetConstant(ARM::QPR_VFP2RegClassID, dl, MVT::i32);
1738 SDValue SubReg0 = CurDAG->getTargetConstant(ARM::ssub_0, dl, MVT::i32);
1739 SDValue SubReg1 = CurDAG->getTargetConstant(ARM::ssub_1, dl, MVT::i32);
1740 SDValue SubReg2 = CurDAG->getTargetConstant(ARM::ssub_2, dl, MVT::i32);
1741 SDValue SubReg3 = CurDAG->getTargetConstant(ARM::ssub_3, dl, MVT::i32);
1744 return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
1751 SDValue RegClass = CurDAG->getTargetConstant(ARM::QQPRRegClassID, dl,
1753 SDValue SubReg0 = CurDAG->getTargetConstant(ARM::dsub_0, dl, MVT::i32);
1754 SDValue SubReg1 = CurDAG->getTargetConstant(ARM::dsub_1, dl, MVT::i32);
1755 SDValue SubReg2 = CurDAG->getTargetConstant(ARM::dsub_2, dl, MVT::i32);
1756 SDValue SubReg3 = CurDAG->getTargetConstant(ARM::dsub_3, dl, MVT::i32);
1759 return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
1766 SDValue RegClass = CurDAG->getTargetConstant(ARM::QQQQPRRegClassID, dl,
1768 SDValue SubReg0 = CurDAG->getTargetConstant(ARM::qsub_0, dl, MVT::i32);
1769 SDValue SubReg1 = CurDAG->getTargetConstant(ARM::qsub_1, dl, MVT::i32);
1770 SDValue SubReg2 = CurDAG->getTargetConstant(ARM::qsub_2, dl, MVT::i32);
1771 SDValue SubReg3 = CurDAG->getTargetConstant(ARM::qsub_3, dl, MVT::i32);
1774 return CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl, VT, Ops);
1796 return CurDAG->getTargetConstant(Alignment, dl, MVT::i32);
1967 ResTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, ResTyElts);
1975 SDValue Pred = getAL(CurDAG, dl);
1976 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
2003 VLd = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
2013 SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, ResTy), 0);
2015 SDNode *VLdA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex], dl,
2033 VLd = CurDAG->getMachineNode(QOpcodes1[OpcodeIndex], dl, ResTys, Ops);
2038 CurDAG->setNodeMemRefs(cast<MachineSDNode>(VLd), {MemOp});
2053 CurDAG->getTargetExtractSubreg(Sub0 + Vec, dl, VT, SuperReg));
2057 CurDAG->RemoveDeadNode(N);
2107 SDValue Pred = getAL(CurDAG, dl);
2108 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
2127 ? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF,dl,VT), 0)
2161 SDNode *VSt = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
2164 CurDAG->setNodeMemRefs(cast<MachineSDNode>(VSt), {MemOp});
2178 ? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, VT), 0)
2185 SDNode *VStA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex], dl,
2188 CurDAG->setNodeMemRefs(cast<MachineSDNode>(VStA), {MemOp});
2205 SDNode *VStB = CurDAG->getMachineNode(QOpcodes1[OpcodeIndex], dl, ResTys,
2207 CurDAG->setNodeMemRefs(cast<MachineSDNode>(VStB), {MemOp});
2247 Align = CurDAG->getTargetConstant(Alignment, dl, MVT::i32);
2270 ResTys.push_back(EVT::getVectorVT(*CurDAG->getContext(),
2277 SDValue Pred = getAL(CurDAG, dl);
2278 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
2301 ? SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, VT), 0)
2316 SDNode *VLdLn = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
2317 CurDAG->setNodeMemRefs(cast<MachineSDNode>(VLdLn), {MemOp});
2331 CurDAG->getTargetExtractSubreg(Sub0 + Vec, dl, VT, SuperReg));
2335 CurDAG->RemoveDeadNode(N);
2341 Ops.push_back(CurDAG->getTargetConstant(ARMVCC::Then, Loc, MVT::i32));
2349 Ops.push_back(CurDAG->getTargetConstant(ARMVCC::Then, Loc, MVT::i32));
2356 Ops.push_back(CurDAG->getTargetConstant(ARMVCC::None, Loc, MVT::i32));
2357 Ops.push_back(CurDAG->getRegister(0, MVT::i32));
2363 Ops.push_back(CurDAG->getTargetConstant(ARMVCC::None, Loc, MVT::i32));
2364 Ops.push_back(CurDAG->getRegister(0, MVT::i32));
2366 CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, Loc, InactiveTy), 0));
2398 CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), makeArrayRef(Ops));
2420 Ops.push_back(getAL(CurDAG, Loc));
2421 Ops.push_back(CurDAG->getRegister(0, MVT::i32));
2423 CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), makeArrayRef(Ops));
2457 CurDAG->SelectNodeTo(N, Opcode, N->getVTList(), makeArrayRef(Ops));
2480 EVT DataTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, NumVecs * 2);
2484 CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, Loc, DataTy), 0);
2489 CurDAG->getMachineNode(OurOpcodes[Stage], Loc, ResultTys, Ops);
2496 CurDAG->getTargetExtractSubreg(ARM::qsub_0 + i, Loc, VT, Data));
2498 CurDAG->RemoveDeadNode(N);
2531 Align = CurDAG->getTargetConstant(Alignment, dl, MVT::i32);
2554 EVT ResTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, ResTyElts);
2562 SDValue Pred = getAL(CurDAG, dl);
2563 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
2589 VLdDup = CurDAG->getMachineNode(Opc, dl, ResTys, Ops);
2592 SDNode *VLdA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex],
2597 VLdDup = CurDAG->getMachineNode(QOpcodes1[OpcodeIndex], dl, ResTys, OpsB);
2600 SDValue(CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, ResTy), 0);
2602 SDNode *VLdA = CurDAG->getMachineNode(QOpcodes0[OpcodeIndex],
2608 VLdDup = CurDAG->getMachineNode(QOpcodes1[OpcodeIndex], dl, ResTys, OpsB);
2613 CurDAG->setNodeMemRefs(cast<MachineSDNode>(VLdDup), {MemOp});
2624 CurDAG->getTargetExtractSubreg(SubIdx+Vec, dl, VT, SuperReg));
2630 CurDAG->RemoveDeadNode(N);
2665 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
2672 CurDAG->getTargetConstant(LSB, dl, MVT::i32),
2673 getAL(CurDAG, dl), Reg0, Reg0 };
2674 CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
2681 CurDAG->getTargetConstant(ARM_AM::getSORegOpc(ShOpcVal, LSB), dl,
2684 getAL(CurDAG, dl), Reg0, Reg0 };
2685 CurDAG->SelectNodeTo(N, ARM::MOVsi, MVT::i32, Ops);
2691 CurDAG->getTargetConstant(LSB, dl, MVT::i32),
2692 CurDAG->getTargetConstant(Width, dl, MVT::i32),
2693 getAL(CurDAG, dl), Reg0 };
2694 CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
2713 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
2716 CurDAG->getTargetConstant(LSB, dl, MVT::i32),
2717 CurDAG->getTargetConstant(Width, dl, MVT::i32),
2718 getAL(CurDAG, dl), Reg0 };
2719 CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
2735 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
2738 CurDAG->getTargetConstant(Srl_imm, dl, MVT::i32),
2739 CurDAG->getTargetConstant(Width, dl, MVT::i32),
2740 getAL(CurDAG, dl), Reg0 };
2741 CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
2756 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
2759 CurDAG->getTargetConstant(LSB, dl, MVT::i32),
2760 CurDAG->getTargetConstant(Width - 1, dl, MVT::i32),
2761 getAL(CurDAG, dl), Reg0 };
2762 CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
2802 CurDAG->SelectNodeTo(N, Opcode, VT, ADDSrc0);
2824 SDNode *CmpSwap = CurDAG->getMachineNode(
2826 CurDAG->getVTList(MVT::i32, MVT::i32, MVT::Other), Ops);
2829 CurDAG->setNodeMemRefs(cast<MachineSDNode>(CmpSwap), {MemOp});
2833 CurDAG->RemoveDeadNode(N);
2879 SDValue Ops[] = { Src, CurDAG->getTargetConstant(Imm, dl, MVT::i32),
2880 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32),
2880 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32),
2881 CurDAG->getRegister(0, MVT::i32) };
2882 return CurDAG->getMachineNode(Opc, dl, MVT::i32, Ops);
2884 SDValue Ops[] = {CurDAG->getRegister(ARM::CPSR, MVT::i32), Src,
2885 CurDAG->getTargetConstant(Imm, dl, MVT::i32),
2886 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32)};
2886 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32)};
2887 return CurDAG->getMachineNode(Opc, dl, MVT::i32, Ops);
2950 CurDAG->getRegister(ARM::SP, MVT::i32),
2951 CurDAG->getTargetConstant(RHSC, dl, MVT::i32),
2952 getAL(CurDAG, dl),
2953 CurDAG->getRegister(0, MVT::i32),
2956 CurDAG->getMachineNode(ARM::tSTRspi, dl, MVT::Other, Ops);
2958 CurDAG->setNodeMemRefs(cast<MachineSDNode>(ResNode), {MemOp});
2988 SDValue CPIdx = CurDAG->getTargetConstantPool(
2989 ConstantInt::get(Type::getInt32Ty(*CurDAG->getContext()), Val),
2990 TLI->getPointerTy(CurDAG->getDataLayout()));
2996 getAL(CurDAG, dl),
2997 CurDAG->getRegister(0, MVT::i32),
2998 CurDAG->getEntryNode()
3000 ResNode = CurDAG->getMachineNode(ARM::tLDRpci, dl, MVT::i32, MVT::Other,
3005 CurDAG->getTargetConstant(0, dl, MVT::i32),
3006 getAL(CurDAG, dl),
3007 CurDAG->getRegister(0, MVT::i32),
3008 CurDAG->getEntryNode()
3010 ResNode = CurDAG->getMachineNode(ARM::LDRcp, dl, MVT::i32, MVT::Other,
3016 MachineFunction& MF = CurDAG->getMachineFunction();
3021 CurDAG->setNodeMemRefs(cast<MachineSDNode>(ResNode), {MemOp});
3033 SDValue TFI = CurDAG->getTargetFrameIndex(
3034 FI, TLI->getPointerTy(CurDAG->getDataLayout()));
3041 CurDAG->SelectNodeTo(N, ARM::tADDframe, MVT::i32, TFI,
3042 CurDAG->getTargetConstant(0, dl, MVT::i32));
3047 SDValue Ops[] = { TFI, CurDAG->getTargetConstant(0, dl, MVT::i32),
3048 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32),
3048 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32),
3049 CurDAG->getRegister(0, MVT::i32) };
3050 CurDAG->SelectNodeTo(N, Opc, MVT::i32, Ops);
3075 SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, dl, MVT::i32);
3076 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
3078 SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG, dl), Reg0, Reg0 };
3079 CurDAG->SelectNodeTo(N, ARM::t2ADDrs, MVT::i32, Ops);
3082 SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG, dl), Reg0,
3084 CurDAG->SelectNodeTo(N, ARM::ADDrsi, MVT::i32, Ops);
3094 SDValue ShImmOp = CurDAG->getTargetConstant(ShImm, dl, MVT::i32);
3095 SDValue Reg0 = CurDAG->getRegister(0, MVT::i32);
3097 SDValue Ops[] = { V, V, ShImmOp, getAL(CurDAG, dl), Reg0, Reg0 };
3098 CurDAG->SelectNodeTo(N, ARM::t2RSBrs, MVT::i32, Ops);
3101 SDValue Ops[] = { V, V, Reg0, ShImmOp, getAL(CurDAG, dl), Reg0,
3103 CurDAG->SelectNodeTo(N, ARM::RSBrsi, MVT::i32, Ops);
3133 CurDAG->getConstant(~N1C->getZExtValue(), dl, MVT::i32);
3137 CurDAG->RepositionNode(N->getIterator(), NewImm.getNode());
3140 SDValue Ops[] = {CurDAG->getRegister(ARM::CPSR, MVT::i32),
3141 N->getOperand(0), NewImm, getAL(CurDAG, dl),
3142 CurDAG->getRegister(0, MVT::i32)};
3143 ReplaceNode(N, CurDAG->getMachineNode(ARM::tBIC, dl, MVT::i32, Ops));
3146 SDValue Ops[] = {N->getOperand(0), NewImm, getAL(CurDAG, dl),
3147 CurDAG->getRegister(0, MVT::i32),
3148 CurDAG->getRegister(0, MVT::i32)};
3150 CurDAG->getMachineNode(ARM::t2BICrr, dl, MVT::i32, Ops));
3183 SDValue Imm16 = CurDAG->getTargetConstant((N2CVal & 0xFFFF0000U) >> 16,
3186 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32) };
3186 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32) };
3187 ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, VT, Ops));
3198 getAL(CurDAG, dl),
3199 CurDAG->getRegister(0, MVT::i32) };
3200 ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, MVT::i32, MVT::i32, Ops));
3206 N->getOperand(3), getAL(CurDAG, dl),
3207 CurDAG->getRegister(0, MVT::i32)};
3209 N, CurDAG->getMachineNode(ARM::t2UMLAL, dl, MVT::i32, MVT::i32, Ops));
3213 N->getOperand(3), getAL(CurDAG, dl),
3214 CurDAG->getRegister(0, MVT::i32),
3215 CurDAG->getRegister(0, MVT::i32) };
3216 ReplaceNode(N, CurDAG->getMachineNode(
3225 N->getOperand(3), getAL(CurDAG, dl),
3226 CurDAG->getRegister(0, MVT::i32)};
3228 N, CurDAG->getMachineNode(ARM::t2SMLAL, dl, MVT::i32, MVT::i32, Ops));
3232 N->getOperand(3), getAL(CurDAG, dl),
3233 CurDAG->getRegister(0, MVT::i32),
3234 CurDAG->getRegister(0, MVT::i32) };
3235 ReplaceNode(N, CurDAG->getMachineNode(
3267 N->getOperand(0), getAL(CurDAG, dl),
3268 CurDAG->getRegister(0, MVT::i32) };
3269 ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, MVT::i32, Ops));
3293 SDNode *New = CurDAG->getMachineNode(Opc, dl, MVT::Other, Ops);
3295 CurDAG->RemoveDeadNode(N);
3303 CurDAG->getMachineNode(ARM::t2LoopDec, dl,
3304 CurDAG->getVTList(MVT::i32, MVT::Other), Ops);
3306 CurDAG->RemoveDeadNode(N);
3343 SDValue Size = CurDAG->getTargetConstant(
3349 CurDAG->getMachineNode(ARM::t2LoopDec, dl,
3350 CurDAG->getVTList(MVT::i32, MVT::Other),
3356 CurDAG->getMachineNode(ARM::t2LoopEnd, dl, MVT::Other, EndArgs);
3359 CurDAG->RemoveDeadNode(N);
3360 CurDAG->RemoveDeadNode(InFlag.getNode());
3361 CurDAG->RemoveDeadNode(Int.getNode());
3383 SDValue Tmp2 = CurDAG->getTargetConstant(CC, dl, MVT::i32);
3385 SDNode *ResNode = CurDAG->getMachineNode(Opc, dl, MVT::Other,
3394 CurDAG->RemoveDeadNode(N);
3415 SDValue Ops[] = { X, CurDAG->getTargetConstant(Addend, dl, MVT::i32),
3416 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32),
3416 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32),
3417 CurDAG->getRegister(0, MVT::i32) };
3418 Add = CurDAG->getMachineNode(ARM::t2ADDri, dl, MVT::i32, Ops);
3421 SDValue Ops[] = {CurDAG->getRegister(ARM::CPSR, MVT::i32), X,
3422 CurDAG->getTargetConstant(Addend, dl, MVT::i32),
3423 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32)};
3423 getAL(CurDAG, dl), CurDAG->getRegister(0, MVT::i32)};
3424 Add = CurDAG->getMachineNode(Opc, dl, MVT::i32, Ops);
3428 SDValue Ops2[] = {SDValue(Add, 0), CurDAG->getConstant(0, dl, MVT::i32)};
3429 CurDAG->MorphNodeTo(N, ARMISD::CMPZ, CurDAG->getVTList(MVT::Glue), Ops2);
3429 CurDAG->MorphNodeTo(N, ARMISD::CMPZ, CurDAG->getVTList(MVT::Glue), Ops2);
3457 SDValue NewARMcc = CurDAG->getConstant((unsigned)CC, dl, MVT::i32);
3460 CurDAG->MorphNodeTo(N, ARMISD::CMOV, N->getVTList(), Ops);
3485 SDValue Pred = getAL(CurDAG, dl);
3486 SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
3488 ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, VT, VT, Ops));
3508 SDValue Pred = getAL(CurDAG, dl);
3509 SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
3511 ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, VT, VT, Ops));
3530 SDValue Pred = getAL(CurDAG, dl);
3531 SDValue PredReg = CurDAG->getRegister(0, MVT::i32);
3533 ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, VT, VT, Ops));
3823 Ops.push_back(getAL(CurDAG, dl));
3824 Ops.push_back(CurDAG->getRegister(0, MVT::i32));
3832 ReplaceNode(N, CurDAG->getMachineNode(Opc, dl, RetType, Ops));
3856 SDValue Ops[] = {MemAddr, getAL(CurDAG, dl),
3857 CurDAG->getRegister(0, MVT::i32), Chain};
3858 SDNode *Ld = CurDAG->getMachineNode(NewOpc, dl, ResTys, Ops);
3861 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Ld), {MemOp});
3871 CurDAG->getTargetConstant(ARM::gsub_0, dl, MVT::i32);
3872 SDNode *ResNode = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
3884 CurDAG->getTargetConstant(ARM::gsub_1, dl, MVT::i32);
3885 SDNode *ResNode = CurDAG->getMachineNode(TargetOpcode::EXTRACT_SUBREG,
3892 CurDAG->RemoveDeadNode(N);
3917 Ops.push_back(getAL(CurDAG, dl));
3918 Ops.push_back(CurDAG->getRegister(0, MVT::i32));
3925 SDNode *St = CurDAG->getMachineNode(NewOpc, dl, ResTys, Ops);
3928 CurDAG->setNodeMemRefs(cast<MachineSDNode>(St), {MemOp});
4421 getIntOperandsFromRegisterString(RegString->getString(), CurDAG, DL, Ops);
4440 Ops.push_back(getAL(CurDAG, DL));
4441 Ops.push_back(CurDAG->getRegister(0, MVT::i32));
4443 ReplaceNode(N, CurDAG->getMachineNode(Opcode, DL, ResTypes, Ops));
4451 Ops = { CurDAG->getTargetConstant(BankedReg, DL, MVT::i32),
4452 getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4452 getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4455 N, CurDAG->getMachineNode(IsThumb2 ? ARM::t2MRSbanked : ARM::MRSbanked,
4481 Ops = { getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4481 Ops = { getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4484 CurDAG->getMachineNode(Opcode, DL, MVT::i32, MVT::Other, Ops));
4496 SDValue Ops[] = { CurDAG->getTargetConstant(SYSmValue, DL, MVT::i32),
4497 getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4497 getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4500 N, CurDAG->getMachineNode(ARM::t2MRS_M, DL, MVT::i32, MVT::Other, Ops));
4507 Ops = { getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4507 Ops = { getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4509 ReplaceNode(N, CurDAG->getMachineNode(IsThumb2 ? ARM::t2MRS_AR : ARM::MRS,
4515 Ops = { getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4515 Ops = { getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4518 N, CurDAG->getMachineNode(IsThumb2 ? ARM::t2MRSsys_AR : ARM::MRSsys, DL,
4536 getIntOperandsFromRegisterString(RegString->getString(), CurDAG, DL, Ops);
4555 Ops.push_back(getAL(CurDAG, DL));
4556 Ops.push_back(CurDAG->getRegister(0, MVT::i32));
4559 ReplaceNode(N, CurDAG->getMachineNode(Opcode, DL, MVT::Other, Ops));
4566 Ops = { CurDAG->getTargetConstant(BankedReg, DL, MVT::i32), N->getOperand(2),
4567 getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4567 getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4570 N, CurDAG->getMachineNode(IsThumb2 ? ARM::t2MSRbanked : ARM::MSRbanked,
4589 Ops = { N->getOperand(2), getAL(CurDAG, DL),
4590 CurDAG->getRegister(0, MVT::i32), N->getOperand(0) };
4591 ReplaceNode(N, CurDAG->getMachineNode(Opcode, DL, MVT::Other, Ops));
4607 SDValue Ops[] = { CurDAG->getTargetConstant(SYSmValue, DL, MVT::i32),
4608 N->getOperand(2), getAL(CurDAG, DL),
4609 CurDAG->getRegister(0, MVT::i32), N->getOperand(0) };
4610 ReplaceNode(N, CurDAG->getMachineNode(ARM::t2MSR_M, DL, MVT::Other, Ops));
4619 Ops = { CurDAG->getTargetConstant(Mask, DL, MVT::i32), N->getOperand(2),
4620 getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4620 getAL(CurDAG, DL), CurDAG->getRegister(0, MVT::i32),
4622 ReplaceNode(N, CurDAG->getMachineNode(IsThumb2 ? ARM::t2MSR_AR : ARM::MSR,
4720 PairedReg = CurDAG->getRegister(GPVR, MVT::Untyped);
4724 SDValue RegCopy = CurDAG->getCopyFromReg(Chain, dl, GPVR, MVT::Untyped,
4728 SDValue Sub0 = CurDAG->getTargetExtractSubreg(ARM::gsub_0, dl, MVT::i32,
4730 SDValue Sub1 = CurDAG->getTargetExtractSubreg(ARM::gsub_1, dl, MVT::i32,
4732 SDValue T0 = CurDAG->getCopyToReg(Sub0, dl, Reg0, Sub0,
4734 SDValue T1 = CurDAG->getCopyToReg(Sub1, dl, Reg1, Sub1, T0.getValue(1));
4739 CurDAG->UpdateNodeOperands(GU, Ops);
4747 SDValue T0 = CurDAG->getCopyFromReg(Chain, dl, Reg0, MVT::i32,
4749 SDValue T1 = CurDAG->getCopyFromReg(Chain, dl, Reg1, MVT::i32,
4756 PairedReg = CurDAG->getRegister(GPVR, MVT::Untyped);
4757 Chain = CurDAG->getCopyToReg(T1, dl, GPVR, Pair, T1.getValue(1));
4773 AsmNodeOperands[AsmNodeOperands.size() -1] = CurDAG->getTargetConstant(
4787 SDValue New = CurDAG->getNode(N->getOpcode(), SDLoc(N),
4788 CurDAG->getVTList(MVT::Other, MVT::Glue), AsmNodeOperands);
lib/Target/AVR/AVRISelDAGToDAG.cpp 67 auto DL = CurDAG->getDataLayout();
72 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), PtrVT);
73 Disp = CurDAG->getTargetConstant(0, dl, MVT::i8);
80 !CurDAG->isBaseWithConstantOffset(N)) {
99 Base = CurDAG->getTargetFrameIndex(FI, PtrVT);
100 Disp = CurDAG->getTargetConstant(RHSC, dl, MVT::i16);
112 Disp = CurDAG->getTargetConstant(RHSC, dl, MVT::i8);
125 auto PtrVT = getTargetLowering()->getPointerTy(CurDAG->getDataLayout());
159 SDNode *ResNode = CurDAG->getMachineNode(Opcode, SDLoc(N), VT,
163 CurDAG->RemoveDeadNode(N);
213 auto DL = CurDAG->getDataLayout();
271 CurDAG->getCopyToReg(CopyFromRegOp, dl, VReg, CopyFromRegOp);
274 CurDAG->getCopyFromReg(CopyToReg, dl, VReg, TL.getPointerTy(DL));
282 Disp = CurDAG->getTargetConstant(ImmNode->getAPIntValue().getZExtValue(), dl, MVT::i8);
299 SDValue CopyToReg = CurDAG->getCopyToReg(Op, dl, VReg, Op);
301 CurDAG->getCopyFromReg(CopyToReg, dl, VReg, TL.getPointerTy(DL));
309 auto DL = CurDAG->getDataLayout();
315 CurDAG->getTargetFrameIndex(FI, getTargetLowering()->getPointerTy(DL));
317 CurDAG->SelectNodeTo(N, AVR::FRMIDX,
319 CurDAG->getTargetConstant(0, SDLoc(N), MVT::i16));
345 SDValue Offset = CurDAG->getTargetConstant(CST, DL, MVT::i16);
349 SDNode *ResNode = CurDAG->getMachineNode(Opc, DL, MVT::Other, Ops);
352 CurDAG->setNodeMemRefs(cast<MachineSDNode>(ResNode), {ST->getMemOperand()});
355 CurDAG->RemoveDeadNode(N);
377 Chain = CurDAG->getCopyToReg(Chain, DL, AVR::R31R30, Ptr, SDValue());
378 Ptr = CurDAG->getCopyFromReg(Chain, DL, AVR::R31R30, MVT::i16,
381 SDValue RegZ = CurDAG->getRegister(AVR::R31R30, MVT::i16);
386 ResNode = CurDAG->getMachineNode(LPMOpc, DL, VT, MVT::i16, MVT::Other, Ptr,
393 ResNode = CurDAG->getMachineNode(AVR::LPMRdZ, DL, MVT::i8, MVT::Other,
397 ResNode = CurDAG->getMachineNode(AVR::LPMWRdZ, DL, MVT::i16,
407 CurDAG->setNodeMemRefs(cast<MachineSDNode>(ResNode), {LD->getMemOperand()});
411 CurDAG->RemoveDeadNode(N);
434 Chain = CurDAG->getCopyToReg(Chain, DL, AVR::R31R30, Callee, InFlag);
436 Ops.push_back(CurDAG->getRegister(AVR::R31R30, MVT::i16));
447 CurDAG->getMachineNode(AVR::ICALL, DL, MVT::Other, MVT::Glue, Ops);
451 CurDAG->RemoveDeadNode(N);
462 Chain = CurDAG->getCopyToReg(Chain, DL, AVR::R31R30, JmpAddr);
463 SDNode *ResNode = CurDAG->getMachineNode(AVR::IJMP, DL, MVT::Other, Chain);
466 CurDAG->RemoveDeadNode(N);
482 SDNode *Mul = CurDAG->getMachineNode(MachineOp, DL, MVT::Glue, Lhs, Rhs);
483 SDValue InChain = CurDAG->getEntryNode();
489 CurDAG->getCopyFromReg(InChain, DL, AVR::R0, Type, InGlue);
500 CurDAG->getCopyFromReg(InChain, DL, AVR::R1, Type, InGlue);
508 CurDAG->RemoveDeadNode(N);
519 LLVM_DEBUG(errs() << "== "; N->dump(CurDAG); errs() << "\n");
lib/Target/BPF/BPFISelDAGToDAG.cpp 103 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i64);
104 Offset = CurDAG->getTargetConstant(0, DL, MVT::i64);
113 if (CurDAG->isBaseWithConstantOffset(Addr)) {
120 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i64);
124 Offset = CurDAG->getTargetConstant(CN->getSExtValue(), DL, MVT::i64);
130 Offset = CurDAG->getTargetConstant(0, DL, MVT::i64);
139 if (!CurDAG->isBaseWithConstantOffset(Addr))
148 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i64);
152 Offset = CurDAG->getTargetConstant(CN->getSExtValue(), DL, MVT::i64);
172 SDValue AluOp = CurDAG->getTargetConstant(ISD::ADD, DL, MVT::i32);;
184 LLVM_DEBUG(dbgs() << "== "; Node->dump(CurDAG); dbgs() << '\n');
200 Node->print(errs(), CurDAG);
216 SDValue R6Reg = CurDAG->getRegister(BPF::R6, MVT::i64);
217 Chain = CurDAG->getCopyToReg(Chain, DL, R6Reg, Skb, SDValue());
218 Node = CurDAG->UpdateNodeOperands(Node, Chain, N1, R6Reg, N3);
228 SDValue TFI = CurDAG->getTargetFrameIndex(FI, VT);
231 CurDAG->SelectNodeTo(Node, Opc, VT, TFI);
234 ReplaceNode(Node, CurDAG->getMachineNode(Opc, SDLoc(Node), VT, TFI));
306 SDValue NVal = CurDAG->getConstant(val, DL, MVT::i64);
313 CurDAG->ReplaceAllUsesOfValuesWith(From, To, 2);
316 CurDAG->DeleteNode(Node);
327 for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
328 E = CurDAG->allnodes_end();
348 const DataLayout &DL = CurDAG->getDataLayout();
493 CurDAG->ReplaceAllUsesWith(SDValue(Node, 0), BaseV);
495 CurDAG->DeleteNode(Node);
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp 128 SDValue IncV = CurDAG->getTargetConstant(Inc, dl, MVT::i32);
134 SDValue Zero = CurDAG->getTargetConstant(0, dl, MVT::i32);
135 return CurDAG->getMachineNode(Hexagon::A4_combineir, dl, MVT::i64,
139 return CurDAG->getMachineNode(Hexagon::A2_sxtw, dl, MVT::i64,
157 MachineSDNode *L = CurDAG->getMachineNode(Opcode, dl, ValueVT,
160 CurDAG->setNodeMemRefs(L, {MemOp});
168 SDValue Zero = CurDAG->getTargetConstant(0, dl, MVT::i32);
169 MachineSDNode *L = CurDAG->getMachineNode(Opcode, dl, ValueVT, MVT::Other,
171 CurDAG->setNodeMemRefs(L, {MemOp});
173 MachineSDNode *A = CurDAG->getMachineNode(Hexagon::A2_addi, dl, MVT::i32,
182 CurDAG->RemoveDeadNode(LD);
206 SDValue I = CurDAG->getTargetConstant(Inc->getSExtValue(), dl, MVT::i32);
207 MachineSDNode *Res = CurDAG->getMachineNode(FLC->second, dl, RTys,
232 TS = CurDAG->getStore(SDValue(LoadN, 2), dl, SDValue(LoadN, 0), Loc, PI,
235 TS = CurDAG->getTruncStore(SDValue(LoadN, 2), dl, SDValue(LoadN, 0), Loc,
311 CurDAG->RemoveDeadNode(C);
341 MachineSDNode *Res = CurDAG->getMachineNode(
346 CurDAG->setNodeMemRefs(Res, {MemOp});
351 CurDAG->RemoveDeadNode(IntN);
391 SDValue I = CurDAG->getTargetConstant(Inc->getSExtValue(), DL, MVT::i32);
400 MachineSDNode *Res = CurDAG->getMachineNode(FLI->second, DL, RTys, Ops);
404 CurDAG->RemoveDeadNode(IntN);
426 SDValue I = CurDAG->getTargetConstant(Inc->getSExtValue(), DL, MVT::i32);
435 MachineSDNode *Res = CurDAG->getMachineNode(FSI->second, DL, RTys, Ops);
438 CurDAG->RemoveDeadNode(IntN);
520 Value = CurDAG->getTargetExtractSubreg(Hexagon::isub_lo,
524 SDValue IncV = CurDAG->getTargetConstant(Inc, dl, MVT::i32);
534 MachineSDNode *S = CurDAG->getMachineNode(Opcode, dl, MVT::i32, MVT::Other,
536 CurDAG->setNodeMemRefs(S, {MemOp});
540 SDValue Zero = CurDAG->getTargetConstant(0, dl, MVT::i32);
542 MachineSDNode *S = CurDAG->getMachineNode(Opcode, dl, MVT::Other, Ops);
543 CurDAG->setNodeMemRefs(S, {MemOp});
545 MachineSDNode *A = CurDAG->getMachineNode(Hexagon::A2_addi, dl, MVT::i32,
551 CurDAG->RemoveDeadNode(ST);
588 SDValue Val = CurDAG->getTargetConstant(ValConst, dl, MVT::i32);
589 SDNode *Result = CurDAG->getMachineNode(Hexagon::M2_mpysmi, dl,
609 SDValue Val = CurDAG->getTargetConstant(-ValConst, dl, MVT::i32);
610 SDNode *Result = CurDAG->getMachineNode(Hexagon::M2_mpysmi, dl,
628 CurDAG->RemoveDeadNode(N);
686 SDValue R = CurDAG->getNode(N->getOpcode(), SDLoc(N), N->getValueType(0),
703 SDValue V = CurDAG->getTargetConstant(A.getZExtValue(), dl, MVT::i32);
704 ReplaceNode(N, CurDAG->getMachineNode(Hexagon::A2_tfrsi, dl, MVT::f32, V));
708 SDValue V = CurDAG->getTargetConstant(A.getZExtValue(), dl, MVT::i64);
709 ReplaceNode(N, CurDAG->getMachineNode(Hexagon::CONST64, dl, MVT::f64, V));
725 ReplaceNode(N, CurDAG->getMachineNode(Opc, SDLoc(N), MVT::i1));
738 SDValue FI = CurDAG->getTargetFrameIndex(FX, MVT::i32);
740 SDValue Zero = CurDAG->getTargetConstant(0, DL, MVT::i32);
749 R = CurDAG->getMachineNode(Hexagon::PS_fi, DL, MVT::i32, FI, Zero);
753 SDValue CH = CurDAG->getEntryNode();
754 SDValue Ops[] = { CurDAG->getCopyFromReg(CH, DL, AR, MVT::i32), FI, Zero };
755 R = CurDAG->getMachineNode(Hexagon::PS_fia, DL, MVT::i32, Ops);
764 SDNode *C = CurDAG->getMachineNode(OpcCarry, SDLoc(N), N->getVTList(),
779 CurDAG->getTargetConstant(Hexagon::DoubleRegsRegClassID, dl, MVT::i32),
781 CurDAG->getTargetConstant(Hexagon::isub_hi, dl, MVT::i32),
783 CurDAG->getTargetConstant(Hexagon::isub_lo, dl, MVT::i32)
785 SDNode *R = CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl,
789 SDValue M0 = CurDAG->getTargetConstant(0x18, dl, MVT::i32);
790 SDValue M1 = CurDAG->getTargetConstant(0x03, dl, MVT::i32);
791 SDNode *C = CurDAG->getMachineNode(Hexagon::S4_andi_asl_ri, dl, MVT::i32,
793 SDNode *S = CurDAG->getMachineNode(Hexagon::S2_lsr_r_p, dl, MVT::i64,
795 SDValue E = CurDAG->getTargetExtractSubreg(Hexagon::isub_lo, dl, ResTy,
800 SDNode *Pu = CurDAG->getMachineNode(Hexagon::C2_tfrrp, dl, MVT::v8i1,
802 SDNode *VA = CurDAG->getMachineNode(Hexagon::S2_valignrb, dl, ResTy,
815 SDValue M = CurDAG->getTargetConstant(Mask, dl, MVT::i32);
816 SDNode *AA = CurDAG->getMachineNode(Hexagon::A2_andir, dl, MVT::i32,
827 SDNode *T = CurDAG->MorphNodeTo(N, N->getOpcode(),
828 CurDAG->getVTList(OpTy), {Op});
834 SDNode *T = CurDAG->getMachineNode(Hexagon::C2_mask, SDLoc(N), ResTy,
842 SDValue Zero = CurDAG->getTargetConstant(0, dl, MVT::i32);
843 SDNode *T = CurDAG->getMachineNode(Hexagon::A4_vcmpbgtui, dl, ResTy,
855 SDValue C = CurDAG->getTargetConstant(-1, dl, MVT::i32);
856 SDNode *R = CurDAG->getMachineNode(Hexagon::A2_tfrsi, dl, MVT::i32, C);
857 SDNode *T = CurDAG->getMachineNode(Hexagon::V6_vandvrt, dl, ResTy,
868 SDValue C = CurDAG->getTargetConstant(-1, dl, MVT::i32);
869 SDNode *R = CurDAG->getMachineNode(Hexagon::A2_tfrsi, dl, MVT::i32, C);
870 SDNode *T = CurDAG->getMachineNode(Hexagon::V6_vandqrt, dl, ResTy,
929 OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));
978 SelectionDAG &DAG = *CurDAG;
1026 SelectionDAG &DAG = *CurDAG;
1090 SelectionDAG &DAG = *CurDAG;
1155 SelectionDAG &DAG = *CurDAG;
1211 T.reserve(CurDAG->allnodes_size());
1212 for (SDNode &N : CurDAG->allnodes())
1250 CurDAG->dump();
1258 CurDAG->dump();
1287 R = CurDAG->getTargetFrameIndex(FX, MVT::i32);
1337 R = CurDAG->getTargetConstant(V, SDLoc(N), N.getValueType());
1391 R = CurDAG->getTargetGlobalAddress(GA->getGlobal(), SDLoc(Const),
1485 CurDAG->getTargetConstant(Hexagon::DoubleRegsRegClassID, dl, MVT::i32),
1486 R, CurDAG->getTargetConstant(Hexagon::isub_hi, dl, MVT::i32),
1487 R, CurDAG->getTargetConstant(Hexagon::isub_lo, dl, MVT::i32)
1489 SDNode *T = CurDAG->getMachineNode(TargetOpcode::REG_SEQUENCE, dl,
1781 return CurDAG->getConstant(MulFactor, SDLoc(N),
1834 Ops[i] = CurDAG->getConstant(NewConst,
1843 Ops[1] = CurDAG->getConstant(ShiftAmount - Power,
1847 return CurDAG->getNode(V.getOpcode(), SDLoc(V), V.getValueType(), Ops);
1860 const Function &CurF = CurDAG->getMachineFunction().getFunction();
1915 LLVM_DEBUG(N->dump(CurDAG));
1921 LLVM_DEBUG(N->dump(CurDAG));
2053 SDValue Sum = CurDAG->getNode(ISD::ADD, SDLoc(N), Mul1.Value.getValueType(),
2055 SDValue Const = CurDAG->getConstant(MaxPowerOf2, SDLoc(N),
2057 SDValue New = CurDAG->getNode(ISD::SHL, SDLoc(N), Mul1.Value.getValueType(),
2084 LLVM_DEBUG(GANode->dump(CurDAG));
2087 CurDAG->getTargetGlobalAddress(GANode->getGlobal(), SDLoc(GA.Value),
2090 GA.Value = CurDAG->getNode(GA.Value.getOpcode(), SDLoc(GA.Value),
2114 GA.Value = CurDAG->getNode(ISD::ADD, SDLoc(GA.Value),
2132 const DataLayout &DL = CurDAG->getDataLayout();
2176 NewNode = CurDAG->getNode(
2178 CurDAG->getConstant(
2182 NewNode = CurDAG->getNode(NOpcode, SDLoc(N), VT, V0, V1);
2206 NewRoot = CurDAG->getNode(
2208 CurDAG->getConstant(
2219 CurDAG->ReplaceAllUsesWith(N, NewRoot.getNode());
2233 for (auto I = CurDAG->allnodes_begin(), E = CurDAG->allnodes_end(); I != E;) {
2233 for (auto I = CurDAG->allnodes_begin(), E = CurDAG->allnodes_end(); I != E;) {
2247 LLVM_DEBUG(N->dump(CurDAG));
2281 N = CurDAG->UpdateNodeOperands(N, N->getOperand(0),
2284 N = CurDAG->UpdateNodeOperands(N, N->getOperand(0), N->getOperand(1),
2288 LLVM_DEBUG(N->dump(CurDAG));
2291 CurDAG->RemoveDeadNodes();
lib/Target/Hexagon/HexagonISelDAGToDAG.h 127 SDNode *U = CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, dl, ResTy);
lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp 2112 HvxSelector(*this, *CurDAG).selectShuffle(N);
2116 HvxSelector(*this, *CurDAG).selectRor(N);
2120 HvxSelector(*this, *CurDAG).selectVAlign(N);
2151 SDVTList VTs = CurDAG->getVTList(MVT::Other);
2153 SDNode *Result = CurDAG->getMachineNode(Opcode, dl, VTs, Ops);
2156 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Result), {MemOp});
2188 SDVTList VTs = CurDAG->getVTList(MVT::Other);
2190 SDNode *Result = CurDAG->getMachineNode(Opcode, dl, VTs, Ops);
2193 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Result), {MemOp});
2205 SDVTList VTs = CurDAG->getVTList(MVT::v16i32, MVT::v512i1);
2206 Result = CurDAG->getMachineNode(Hexagon::V6_vaddcarry, SDLoc(N), VTs, Ops);
2212 SDVTList VTs = CurDAG->getVTList(MVT::v32i32, MVT::v1024i1);
2213 Result = CurDAG->getMachineNode(Hexagon::V6_vaddcarry, SDLoc(N), VTs, Ops);
2219 SDVTList VTs = CurDAG->getVTList(MVT::v16i32, MVT::v512i1);
2220 Result = CurDAG->getMachineNode(Hexagon::V6_vsubcarry, SDLoc(N), VTs, Ops);
2226 SDVTList VTs = CurDAG->getVTList(MVT::v32i32, MVT::v1024i1);
2227 Result = CurDAG->getMachineNode(Hexagon::V6_vsubcarry, SDLoc(N), VTs, Ops);
2236 CurDAG->RemoveDeadNode(N);
lib/Target/Lanai/LanaiISelDAGToDAG.cpp 86 return CurDAG->getTargetConstant(Imm, DL, MVT::i32);
109 Offset = CurDAG->getTargetConstant(Imm, DL, CN->getValueType(0));
131 Offset = CurDAG->getTargetConstant(Imm, DL, CN->getValueType(0));
132 Base = CurDAG->getRegister(Lanai::R0, CN->getValueType(0));
133 AluOp = CurDAG->getTargetConstant(LPAC::ADD, DL, MVT::i32);
144 Offset = CurDAG->getTargetConstant(Imm, DL, CN->getValueType(0));
145 Base = CurDAG->getRegister(Lanai::R0, CN->getValueType(0));
146 AluOp = CurDAG->getTargetConstant(LPAC::ADD, DL, MVT::i32);
154 Base = CurDAG->getTargetFrameIndex(
156 getTargetLowering()->getPointerTy(CurDAG->getDataLayout()));
157 Offset = CurDAG->getTargetConstant(0, DL, MVT::i32);
158 AluOp = CurDAG->getTargetConstant(LPAC::ADD, DL, MVT::i32);
170 AluOp = CurDAG->getTargetConstant(LPAC::ADD, DL, MVT::i32);
178 Base = CurDAG->getTargetFrameIndex(
180 getTargetLowering()->getPointerTy(CurDAG->getDataLayout()));
185 Offset = CurDAG->getTargetConstant(CN->getSExtValue(), DL, MVT::i32);
196 Offset = CurDAG->getTargetConstant(0, DL, MVT::i32);
197 AluOp = CurDAG->getTargetConstant(LPAC::ADD, DL, MVT::i32);
243 AluOp = CurDAG->getTargetConstant(AluCode, SDLoc(Addr), MVT::i32);
277 LLVM_DEBUG(errs() << "== "; Node->dump(CurDAG); errs() << "\n");
291 SDValue New = CurDAG->getCopyFromReg(CurDAG->getEntryNode(),
291 SDValue New = CurDAG->getCopyFromReg(CurDAG->getEntryNode(),
298 SDValue New = CurDAG->getCopyFromReg(CurDAG->getEntryNode(),
298 SDValue New = CurDAG->getCopyFromReg(CurDAG->getEntryNode(),
317 SDValue Imm = CurDAG->getTargetConstant(0, DL, MVT::i32);
320 SDValue TFI = CurDAG->getTargetFrameIndex(FI, VT);
323 CurDAG->SelectNodeTo(Node, Opc, VT, TFI, Imm);
326 ReplaceNode(Node, CurDAG->getMachineNode(Opc, DL, VT, TFI, Imm));
lib/Target/MSP430/MSP430ISelDAGToDAG.cpp 232 CurDAG->MaskedValueIsZero(N.getOperand(0), CN->getAPIntValue())) {
256 AM.Base.Reg = CurDAG->getRegister(MSP430::SR, MVT::i16);
259 ? CurDAG->getTargetFrameIndex(
261 getTargetLowering()->getPointerTy(CurDAG->getDataLayout()))
265 Disp = CurDAG->getTargetGlobalAddress(AM.GV, SDLoc(N),
269 Disp = CurDAG->getTargetConstantPool(AM.CP, MVT::i16,
272 Disp = CurDAG->getTargetExternalSymbol(AM.ES, MVT::i16, 0/*AM.SymbolFlags*/);
274 Disp = CurDAG->getTargetJumpTable(AM.JT, MVT::i16, 0/*AM.SymbolFlags*/);
276 Disp = CurDAG->getTargetBlockAddress(AM.BlockAddr, MVT::i32, 0,
279 Disp = CurDAG->getTargetConstant(AM.Disp, SDLoc(N), MVT::i16);
348 CurDAG->getMachineNode(Opcode, SDLoc(N), VT, MVT::i16, MVT::Other,
367 CurDAG->SelectNodeTo(Op, Opc, VT, MVT::i16, MVT::Other, Ops0);
368 CurDAG->setNodeMemRefs(cast<MachineSDNode>(ResNode), {MemRef});
385 LLVM_DEBUG(errs() << "== "; Node->dump(CurDAG); errs() << "\n");
396 SDValue TFI = CurDAG->getTargetFrameIndex(FI, MVT::i16);
398 CurDAG->SelectNodeTo(Node, MSP430::ADDframe, MVT::i16, TFI,
399 CurDAG->getTargetConstant(0, dl, MVT::i16));
402 ReplaceNode(Node, CurDAG->getMachineNode(
404 CurDAG->getTargetConstant(0, dl, MVT::i16)));
lib/Target/Mips/Mips16ISelDAGToDAG.cpp 48 SDNode *Mul = CurDAG->getMachineNode(Opc, DL, MVT::Glue, N->getOperand(0),
54 Lo = CurDAG->getMachineNode(Opcode, DL, Ty, MVT::Glue, InFlag);
59 Hi = CurDAG->getMachineNode(Opcode, DL, Ty, InFlag);
106 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), ValTy);
107 Offset = CurDAG->getTargetConstant(0, DL, ValTy);
123 if (CurDAG->isBaseWithConstantOffset(Addr)) {
130 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), ValTy);
131 Offset = CurDAG->getTargetConstant(CN->getZExtValue(), DL, ValTy);
137 Offset = CurDAG->getTargetConstant(CN->getZExtValue(), DL, ValTy);
163 Offset = CurDAG->getTargetConstant(0, DL, ValTy);
206 CurDAG->RemoveDeadNode(Node);
lib/Target/Mips/MipsISelDAGToDAG.cpp 69 return CurDAG->getRegister(GlobalBaseReg, getTargetLowering()->getPointerTy(
70 CurDAG->getDataLayout()))
255 SDValue NegC = CurDAG->FoldConstantArithmetic(
256 ISD::SUB, DL, VT, CurDAG->getConstant(0, DL, VT).getNode(), C.getNode());
258 SDValue NewNode = CurDAG->getNode(ISD::SUB, DL, VT, X, NegC);
272 LLVM_DEBUG(errs() << "== "; Node->dump(CurDAG); errs() << "\n");
lib/Target/Mips/MipsISelDAGToDAG.h 139 return CurDAG->getTargetConstant(Imm, SDLoc(Node), Node->getValueType(0));
lib/Target/Mips/MipsSEISelDAGToDAG.cpp 215 CurDAG->SelectNodeTo(Node, Mips::ADDWC, VT, MVT::Glue, Ops);
233 SDValue CstOne = CurDAG->getTargetConstant(1, DL, MVT::i32);
235 SDValue OuFlag = CurDAG->getTargetConstant(20, DL, MVT::i32);
238 CurDAG->getMachineNode(Mips::RDDSP, DL, MVT::i32, MVT::Glue, CstOne, InFlag);
240 SDNode *Carry = CurDAG->getMachineNode(
244 CurDAG->getTargetConstant(6, DL, MVT::i32), CstOne,
246 SDNode *DSPCFWithCarry = CurDAG->getMachineNode(Mips::INS, DL, MVT::i32, Ops);
253 SDValue Zero = CurDAG->getRegister(Mips::ZERO, MVT::i32);
256 SDNode *DSPCtrlFinal = CurDAG->getMachineNode(Mips::INS, DL, MVT::i32, InsOps);
258 SDNode *WrDSP = CurDAG->getMachineNode(Mips::WRDSP, DL, MVT::Glue,
262 CurDAG->SelectNodeTo(Node, Mips::ADDWC, VT, MVT::Glue, Operands);
271 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), ValTy);
272 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), ValTy);
282 if (CurDAG->isBaseWithConstantOffset(Addr)) {
290 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), ValTy);
300 Offset = CurDAG->getTargetConstant(CN->getZExtValue(), SDLoc(Addr),
363 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), Addr.getValueType());
562 Imm = CurDAG->getTargetConstant(ImmValue, SDLoc(N), EltTy);
638 Imm = CurDAG->getTargetConstant(Log2, SDLoc(N), EltTy);
671 Imm = CurDAG->getTargetConstant(ImmValue.countPopulation() - 1, SDLoc(N),
703 Imm = CurDAG->getTargetConstant(ImmValue.countPopulation() - 1, SDLoc(N),
725 Imm = CurDAG->getTargetConstant(Log2, SDLoc(N), EltTy);
755 ReplaceNode(Node, CurDAG->getMachineNode(Subtarget->isGP64bit()
771 SDValue Zero = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL,
771 SDValue Zero = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL,
774 CurDAG->getMachineNode(Mips::DMTC1, DL, MVT::f64, Zero));
776 SDValue Zero = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL,
776 SDValue Zero = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL,
778 ReplaceNode(Node, CurDAG->getMachineNode(Mips::BuildPairF64_64, DL,
781 SDValue Zero = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL,
781 SDValue Zero = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), DL,
783 ReplaceNode(Node, CurDAG->getMachineNode(Mips::BuildPairF64, DL,
807 SDValue ImmOpnd = CurDAG->getTargetConstant(SignExtend64<16>(Inst->ImmOpnd),
814 RegOpnd = CurDAG->getMachineNode(Inst->Opc, DL, MVT::i64, ImmOpnd);
817 CurDAG->getMachineNode(Inst->Opc, DL, MVT::i64,
818 CurDAG->getRegister(Mips::ZERO_64, MVT::i64),
823 ImmOpnd = CurDAG->getTargetConstant(SignExtend64<16>(Inst->ImmOpnd), DL,
825 RegOpnd = CurDAG->getMachineNode(Inst->Opc, DL, MVT::i64,
841 SDValue Reg = CurDAG->getCopyFromReg(ChainIn, DL,
858 ReplaceNode(Node, CurDAG->getMachineNode(Mips::MOVE_V, DL,
875 SDValue ChainOut = CurDAG->getCopyToReg(ChainIn, DL,
932 Node->getOperand(0), CurDAG->getTargetConstant(Pos, DL, MVT::i32),
933 CurDAG->getTargetConstant(Size, DL, MVT::i32), Node->getOperand(3)};
935 ReplaceNode(Node, CurDAG->getMachineNode(Opcode, DL, ResTy, Ops));
943 EVT PtrVT = getTargetLowering()->getPointerTy(CurDAG->getDataLayout());
955 CurDAG->getMachineNode(RdhwrOpc, DL, Node->getValueType(0),
956 CurDAG->getRegister(Mips::HWR29, MVT::i32),
957 CurDAG->getTargetConstant(0, DL, MVT::i32));
958 SDValue Chain = CurDAG->getCopyToReg(CurDAG->getEntryNode(), DL, DestReg,
958 SDValue Chain = CurDAG->getCopyToReg(CurDAG->getEntryNode(), DL, DestReg,
960 SDValue ResNode = CurDAG->getCopyFromReg(Chain, DL, DestReg, PtrVT);
1025 SDValue Imm = CurDAG->getTargetConstant(SplatValue, DL,
1028 Res = CurDAG->getMachineNode(LdiOp, DL, ViaVecTy, Imm);
1040 SDValue ZeroVal = CurDAG->getRegister(
1054 SDValue LoVal = CurDAG->getTargetConstant(Lo, DL, SplatMVT);
1056 Res = CurDAG->getMachineNode(ADDiuOp, DL, SplatMVT, ZeroVal, LoVal);
1057 Res = CurDAG->getMachineNode(FILLOp, DL, ViaVecTy, SDValue(Res, 0));
1064 SDValue ZeroVal = CurDAG->getRegister(Mips::ZERO, MVT::i32);
1066 SDValue LoVal = CurDAG->getTargetConstant(Lo, DL, MVT::i32);
1067 SDValue HiVal = CurDAG->getTargetConstant(Hi, DL, MVT::i32);
1070 Res = CurDAG->getMachineNode(Mips::LUi, DL, MVT::i32, HiVal);
1073 Res = CurDAG->getMachineNode(Mips::ORi, DL, MVT::i32,
1077 Res = CurDAG->getMachineNode(Mips::FILL_W, DL, MVT::v4i32, SDValue(Res, 0));
1086 SDValue ZeroVal = CurDAG->getRegister(Mips::ZERO, MVT::i32);
1088 SDValue LoVal = CurDAG->getTargetConstant(Lo, DL, MVT::i32);
1089 SDValue HiVal = CurDAG->getTargetConstant(Hi, DL, MVT::i32);
1092 Res = CurDAG->getMachineNode(Mips::LUi, DL, MVT::i32, HiVal);
1095 Res = CurDAG->getMachineNode(Mips::ORi, DL, MVT::i32,
1098 Res = CurDAG->getMachineNode(
1100 CurDAG->getTargetConstant(((Hi >> 15) & 0x1), DL, MVT::i64),
1102 CurDAG->getTargetConstant(Mips::sub_32, DL, MVT::i64));
1105 CurDAG->getMachineNode(Mips::FILL_D, DL, MVT::v2i64, SDValue(Res, 0));
1138 SDValue LoVal = CurDAG->getTargetConstant(Lo, DL, MVT::i32);
1139 SDValue HiVal = CurDAG->getTargetConstant(Hi, DL, MVT::i32);
1140 SDValue HigherVal = CurDAG->getTargetConstant(Higher, DL, MVT::i32);
1141 SDValue HighestVal = CurDAG->getTargetConstant(Highest, DL, MVT::i32);
1142 SDValue ZeroVal = CurDAG->getRegister(Mips::ZERO, MVT::i32);
1161 Res = CurDAG->getMachineNode(Mips::LUi, DL, MVT::i32, HiVal);
1164 Res = CurDAG->getMachineNode(Mips::ORi, DL, MVT::i32,
1169 HiRes = CurDAG->getMachineNode(Mips::LUi, DL, MVT::i32, HighestVal);
1172 HiRes = CurDAG->getMachineNode(Mips::ORi, DL, MVT::i32,
1178 Res = CurDAG->getMachineNode(Mips::FILL_W, DL, MVT::v4i32,
1181 Res = CurDAG->getMachineNode(
1184 CurDAG->getTargetConstant(1, DL, MVT::i32));
1190 Res = CurDAG->getMachineNode(
1192 CurDAG->getTargetConstant(RC->getID(), DL, MVT::i32));
1194 Res = CurDAG->getMachineNode(
1196 CurDAG->getTargetConstant(0, DL, MVT::i32));
1199 SDValue Zero64Val = CurDAG->getRegister(Mips::ZERO_64, MVT::i64);
1204 HiRes = CurDAG->getMachineNode(
1206 CurDAG->getTargetConstant(((Highest >> 15) & 0x1), DL, MVT::i64),
1208 CurDAG->getTargetConstant(Mips::sub_32, DL, MVT::i64));
1211 Res = CurDAG->getMachineNode(
1213 CurDAG->getTargetConstant(((Hi >> 15) & 0x1), DL, MVT::i64),
1215 CurDAG->getTargetConstant(Mips::sub_32, DL, MVT::i64));
1229 CurDAG->getConstant(*Const32, DL, MVT::i32),
1230 CurDAG->getConstant(*Const32, DL, MVT::i32),
1233 Res = CurDAG->getMachineNode(Mips::DINSU, DL, MVT::i64, Ops);
1235 Res = CurDAG->getMachineNode(
1237 CurDAG->getTargetConstant(0, DL, MVT::i32));
1242 Res = CurDAG->getMachineNode(Mips::FILL_D, DL, MVT::v2i64, SDValue(Res, 0));
1257 Res = CurDAG->getMachineNode(Mips::COPY_TO_REGCLASS, DL,
1259 CurDAG->getTargetConstant(RC->getID(), DL,
1283 OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));
1293 OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));
1307 OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));
1334 OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));
lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp 526 SDValue Val = CurDAG->getTargetConstantFP(
529 CurDAG->getMachineNode(NVPTX::LOAD_CONST_F16, SDLoc(N), MVT::f16, Val);
595 SDNode *SetP = CurDAG->getMachineNode(
597 N->getOperand(1), CurDAG->getTargetConstant(PTXCmpMode, DL, MVT::i32));
646 CurDAG->getMachineNode(Op, SDLoc(N), MVT::f16, MVT::f16, Source);
733 ReplaceNode(N, CurDAG->getMachineNode(NVPTX::texsurf_handles, SDLoc(N),
769 ReplaceNode(N, CurDAG->getMachineNode(Opc, SDLoc(N), N->getValueType(0),
803 ReplaceNode(N, CurDAG->getMachineNode(Opc, SDLoc(N), N->getValueType(0),
868 CurDAG->getDataLayout().getPointerSizeInBits(LD->getAddressSpace());
926 NVPTXLD = CurDAG->getMachineNode(Opcode.getValue(), dl, TargetVT,
939 NVPTXLD = CurDAG->getMachineNode(Opcode.getValue(), dl, TargetVT,
958 NVPTXLD = CurDAG->getMachineNode(Opcode.getValue(), dl, TargetVT,
977 NVPTXLD = CurDAG->getMachineNode(Opcode.getValue(), dl, TargetVT,
985 CurDAG->setNodeMemRefs(cast<MachineSDNode>(NVPTXLD), {MemRef});
1012 CurDAG->getDataLayout().getPointerSizeInBits(MemSD->getAddressSpace());
1095 LD = CurDAG->getMachineNode(Opcode.getValue(), DL, N->getVTList(), Ops);
1122 LD = CurDAG->getMachineNode(Opcode.getValue(), DL, N->getVTList(), Ops);
1172 LD = CurDAG->getMachineNode(Opcode.getValue(), DL, N->getVTList(), Ops);
1220 LD = CurDAG->getMachineNode(Opcode.getValue(), DL, N->getVTList(), Ops);
1224 CurDAG->setNodeMemRefs(cast<MachineSDNode>(LD), {MemRef});
1289 SDVTList InstVTList = CurDAG->getVTList(InstVTs);
1364 LD = CurDAG->getMachineNode(Opcode.getValue(), DL, InstVTList, Ops);
1511 LD = CurDAG->getMachineNode(Opcode.getValue(), DL, InstVTList, Ops);
1657 LD = CurDAG->getMachineNode(Opcode.getValue(), DL, InstVTList, Ops);
1661 CurDAG->setNodeMemRefs(cast<MachineSDNode>(LD), {MemRef});
1692 CurDAG->getMachineNode(CvtOpc, DL, OrigType, Res,
1693 CurDAG->getTargetConstant(NVPTX::PTXCvtMode::NONE,
1731 CurDAG->getDataLayout().getPointerSizeInBits(ST->getAddressSpace());
1790 NVPTXST = CurDAG->getMachineNode(Opcode.getValue(), dl, MVT::Other, Ops);
1809 NVPTXST = CurDAG->getMachineNode(Opcode.getValue(), dl, MVT::Other, Ops);
1835 NVPTXST = CurDAG->getMachineNode(Opcode.getValue(), dl, MVT::Other, Ops);
1858 NVPTXST = CurDAG->getMachineNode(Opcode.getValue(), dl, MVT::Other, Ops);
1865 CurDAG->setNodeMemRefs(cast<MachineSDNode>(NVPTXST), {MemRef});
1888 CurDAG->getDataLayout().getPointerSizeInBits(MemSD->getAddressSpace());
2085 ST = CurDAG->getMachineNode(Opcode.getValue(), DL, MVT::Other, StOps);
2088 CurDAG->setNodeMemRefs(cast<MachineSDNode>(ST), {MemRef});
2152 VTs = CurDAG->getVTList(EltVT, MVT::Other, MVT::Glue);
2154 VTs = CurDAG->getVTList(EltVT, EltVT, MVT::Other, MVT::Glue);
2157 VTs = CurDAG->getVTList(EVTs);
2163 Ops.push_back(CurDAG->getTargetConstant(OffsetVal, DL, MVT::i32));
2167 ReplaceNode(Node, CurDAG->getMachineNode(Opcode.getValue(), DL, VTs, Ops));
2198 Ops.push_back(CurDAG->getTargetConstant(OffsetVal, DL, MVT::i32));
2233 SDNode *Ret = CurDAG->getMachineNode(Opcode.getValue(), DL, MVT::Other, Ops);
2235 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Ret), {MemRef});
2273 Ops.push_back(CurDAG->getTargetConstant(ParamVal, DL, MVT::i32));
2274 Ops.push_back(CurDAG->getTargetConstant(OffsetVal, DL, MVT::i32));
2317 SDValue CvtNone = CurDAG->getTargetConstant(NVPTX::PTXCvtMode::NONE, DL,
2319 SDNode *Cvt = CurDAG->getMachineNode(NVPTX::CVT_u32_u16, DL,
2326 SDValue CvtNone = CurDAG->getTargetConstant(NVPTX::PTXCvtMode::NONE, DL,
2328 SDNode *Cvt = CurDAG->getMachineNode(NVPTX::CVT_s32_s16, DL,
2335 SDVTList RetVTs = CurDAG->getVTList(MVT::Other, MVT::Glue);
2337 CurDAG->getMachineNode(Opcode.getValue(), DL, RetVTs, Ops);
2339 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Ret), {MemRef});
2860 ReplaceNode(N, CurDAG->getMachineNode(Opc, SDLoc(N), N->getVTList(), Ops));
3369 ReplaceNode(N, CurDAG->getMachineNode(Opc, SDLoc(N), N->getVTList(), Ops));
3409 Len = CurDAG->getTargetConstant(NumBits, DL, MVT::i32);
3427 Start = CurDAG->getTargetConstant(StartVal, DL, MVT::i32);
3492 Start = CurDAG->getTargetConstant(ShiftAmt, DL, MVT::i32);
3493 Len = CurDAG->getTargetConstant(NumBits, DL, MVT::i32);
3532 Start = CurDAG->getTargetConstant(OuterShiftAmt - InnerShiftAmt, DL,
3534 Len = CurDAG->getTargetConstant(Val.getValueSizeInBits() - OuterShiftAmt,
3576 ReplaceNode(N, CurDAG->getMachineNode(Opc, DL, N->getVTList(), Ops));
3610 Offset = CurDAG->getTargetConstant(CN->getZExtValue(), SDLoc(OpNode),
3635 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), mvt);
3636 Offset = CurDAG->getTargetConstant(0, SDLoc(OpNode), mvt);
3651 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), mvt);
3654 Offset = CurDAG->getTargetConstant(CN->getZExtValue(), SDLoc(OpNode),
3700 OutOps.push_back(CurDAG->getTargetConstant(0, SDLoc(Op), MVT::i32));
lib/Target/NVPTX/NVPTXISelDAGToDAG.h 79 return CurDAG->getTargetConstant(Imm, DL, MVT::i32);
lib/Target/PowerPC/PPCISelDAGToDAG.cpp 168 return CurDAG->getTargetConstant(Imm, dl, MVT::i16);
174 return CurDAG->getTargetConstant(Imm, dl, MVT::i32);
180 return CurDAG->getTargetConstant(Imm, dl, MVT::i64);
185 return CurDAG->getTargetConstant(
186 Imm, dl, PPCLowering->getPointerTy(CurDAG->getDataLayout()));
241 return PPCLowering->SelectAddressRegReg(N, Base, Index, *CurDAG, 0);
251 return PPCLowering->SelectAddressRegReg(N, Base, Index, *CurDAG, 4);
261 return PPCLowering->SelectAddressRegReg(N, Base, Index, *CurDAG, 16);
267 return PPCLowering->SelectAddressRegRegOnly(N, Base, Index, *CurDAG);
276 return PPCLowering->SelectAddressRegImm(N, Disp, Base, *CurDAG, 0);
283 return PPCLowering->SelectAddressRegImm(N, Disp, Base, *CurDAG, 4);
290 return PPCLowering->SelectAddressRegImm(N, Disp, Base, *CurDAG, 16);
323 SDValue RC = CurDAG->getTargetConstant(TRC->getID(), dl, MVT::i32);
325 SDValue(CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
439 if (PPCLowering->getPointerTy(CurDAG->getDataLayout()) == MVT::i32) {
478 return CurDAG->getRegister(GlobalBaseReg,
479 PPCLowering->getPointerTy(CurDAG->getDataLayout()))
576 SDValue TFI = CurDAG->getTargetFrameIndex(FI, N->getValueType(0));
579 CurDAG->SelectNodeTo(SN, Opc, N->getValueType(0), TFI,
582 ReplaceNode(SN, CurDAG->getMachineNode(Opc, dl, N->getValueType(0), TFI,
665 SDNode *MN = CurDAG->getMachineNode(Opcode, dl, VTs, Ops);
706 SDNode *MN = CurDAG->getMachineNode(Opcode, dl, VTs, Ops);
719 KnownBits LKnown = CurDAG->computeKnownBits(Op0);
720 KnownBits RKnown = CurDAG->computeKnownBits(Op1);
764 KnownBits MKnown = CurDAG->computeKnownBits(Op1.getOperand(1));
780 ReplaceNode(N, CurDAG->getMachineNode(PPC::RLWIMI, dl, MVT::i32, Ops));
3639 IntegerCompareEliminator ICmpElim(CurDAG, this);
3664 BitPermutationSelector BPS(CurDAG);
3689 return SDValue(CurDAG->getMachineNode(PPC::CMPLWI, dl, MVT::i32, LHS,
3694 return SDValue(CurDAG->getMachineNode(PPC::CMPWI, dl, MVT::i32, LHS,
3707 SDValue Xor(CurDAG->getMachineNode(PPC::XORIS, dl, MVT::i32, LHS,
3709 return SDValue(CurDAG->getMachineNode(PPC::CMPLWI, dl, MVT::i32, Xor,
3715 return SDValue(CurDAG->getMachineNode(PPC::CMPLWI, dl, MVT::i32, LHS,
3721 return SDValue(CurDAG->getMachineNode(PPC::CMPWI, dl, MVT::i32, LHS,
3733 return SDValue(CurDAG->getMachineNode(PPC::CMPLDI, dl, MVT::i64, LHS,
3738 return SDValue(CurDAG->getMachineNode(PPC::CMPDI, dl, MVT::i64, LHS,
3752 SDValue Xor(CurDAG->getMachineNode(PPC::XORIS8, dl, MVT::i64, LHS,
3754 return SDValue(CurDAG->getMachineNode(PPC::CMPLDI, dl, MVT::i64, Xor,
3762 return SDValue(CurDAG->getMachineNode(PPC::CMPLDI, dl, MVT::i64, LHS,
3768 return SDValue(CurDAG->getMachineNode(PPC::CMPDI, dl, MVT::i64, LHS,
3832 return SDValue(CurDAG->getMachineNode(Opc, dl, MVT::i32, LHS, RHS), 0);
4011 CurDAG->getTargetLoweringInfo().getPointerTy(CurDAG->getDataLayout());
4011 CurDAG->getTargetLoweringInfo().getPointerTy(CurDAG->getDataLayout());
4024 Op = SDValue(CurDAG->getMachineNode(PPC::CNTLZW, dl, MVT::i32, Op), 0);
4027 CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops);
4033 SDValue(CurDAG->getMachineNode(PPC::ADDIC, dl, MVT::i32, MVT::Glue,
4035 CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, AD, Op, AD.getValue(1));
4041 CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops);
4046 SDValue(CurDAG->getMachineNode(PPC::NEG, dl, MVT::i32, Op), 0);
4047 T = SDValue(CurDAG->getMachineNode(PPC::ANDC, dl, MVT::i32, T, Op), 0);
4050 CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops);
4060 Op = SDValue(CurDAG->getMachineNode(PPC::ADDIC, dl, MVT::i32, MVT::Glue,
4062 CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32,
4063 SDValue(CurDAG->getMachineNode(PPC::LI, dl,
4070 Op = SDValue(CurDAG->getMachineNode(PPC::NOR, dl, MVT::i32, Op, Op), 0);
4071 SDNode *AD = CurDAG->getMachineNode(PPC::ADDIC, dl, MVT::i32, MVT::Glue,
4073 CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDValue(AD, 0), Op,
4078 SDValue AD = SDValue(CurDAG->getMachineNode(PPC::ADDI, dl, MVT::i32, Op,
4080 SDValue AN = SDValue(CurDAG->getMachineNode(PPC::AND, dl, MVT::i32, AD,
4084 CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops);
4090 Op = SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, Ops), 0);
4091 CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Op, getI32Imm(1, dl));
4116 SDValue VCmp(CurDAG->getMachineNode(VCmpInst, dl, ResVT, LHS, RHS), 0);
4117 CurDAG->SelectNodeTo(N, PPCSubTarget->hasVSX() ? PPC::XXLNOR : PPC::VNOR,
4122 CurDAG->SelectNodeTo(N, VCmpInst, ResVT, LHS, RHS);
4141 SDValue CR7Reg = CurDAG->getRegister(PPC::CR7, MVT::i32);
4144 CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, CR7Reg, CCReg,
4144 CCReg = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, CR7Reg, CCReg,
4147 IntCR = SDValue(CurDAG->getMachineNode(PPC::MFOCRF, dl, MVT::i32, CR7Reg,
4153 CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops);
4159 SDValue(CurDAG->getMachineNode(PPC::RLWINM, dl, MVT::i32, Ops), 0);
4160 CurDAG->SelectNodeTo(N, PPC::XORI, MVT::i32, Tmp, getI32Imm(1, dl));
4184 const MachineFrameInfo &MFI = CurDAG->getMachineFunction().getFrameInfo();
4204 CurDAG->setNodeMemRefs(cast<MachineSDNode>(Result), {MemOp});
4376 ReplaceNode(N, selectI64Imm(CurDAG, N));
4390 if (PPCLowering->getPointerTy(CurDAG->getDataLayout()) != MVT::i32 ||
4399 if (PPCLowering->getPointerTy(CurDAG->getDataLayout()) != MVT::i32 ||
4427 ReplaceNode(N, CurDAG->getMachineNode(PPC::MFOCRF, dl, MVT::i32,
4433 ReplaceNode(N, CurDAG->getMachineNode(PPC::ReadTB, dl, MVT::i32, MVT::i32,
4440 CurDAG->getTargetConstant(*cast<ConstantSDNode>(N->getOperand(1))->
4445 CurDAG->getMachineNode(PPC::SRADI, dl, MVT::i64, MVT::Glue,
4447 CurDAG->SelectNodeTo(N, PPC::ADDZE8, MVT::i64, SDValue(Op, 0),
4454 CurDAG->getMachineNode(PPC::SRAWI, dl, MVT::i32, MVT::Glue,
4456 CurDAG->SelectNodeTo(N, PPC::ADDZE, MVT::i32, SDValue(Op, 0),
4519 SDNode *MN = CurDAG->getMachineNode(
4521 PPCLowering->getPointerTy(CurDAG->getDataLayout()), MVT::Other, Ops);
4559 SDNode *MN = CurDAG->getMachineNode(
4561 PPCLowering->getPointerTy(CurDAG->getDataLayout()), MVT::Other, Ops);
4579 CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops);
4590 CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops);
4606 auto ImDef = CurDAG->getMachineNode(PPC::IMPLICIT_DEF, dl,
4610 Val = SDValue(CurDAG->getMachineNode(PPC::INSERT_SUBREG, dl,
4630 CurDAG->SelectNodeTo(N, PPC::RLDICL, MVT::i64, Ops);
4642 CurDAG->SelectNodeTo(N, PPC::RLDICR, MVT::i64, Ops);
4675 ReplaceNode(N, CurDAG->getMachineNode(PPC::RLWIMI, dl, MVT::i32, Ops));
4691 KnownBits LHSKnown = CurDAG->computeKnownBits(N->getOperand(0));
4711 SDNode *Lo = CurDAG->getMachineNode(PPC::ORI8, dl, MVT::i64,
4715 CurDAG->SelectNodeTo(N, PPC::ORIS8, MVT::i64, Ops1);
4734 SDNode *Lo = CurDAG->getMachineNode(PPC::XORI8, dl, MVT::i64,
4738 CurDAG->SelectNodeTo(N, PPC::XORIS8, MVT::i64, Ops1);
4762 CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops);
4776 CurDAG->SelectNodeTo(N, PPC::RLWINM, MVT::i32, Ops);
4794 SDValue AndI(CurDAG->getMachineNode(Opcode, dl, InVT, MVT::Glue,
4796 CurDAG->getTargetConstant(1, dl, InVT)),
4798 SDValue CR0Reg = CurDAG->getRegister(PPC::CR0, MVT::i32);
4800 CurDAG->getTargetConstant(N->getOpcode() == PPCISD::ANDIo_1_EQ_BIT ?
4803 CurDAG->SelectNodeTo(N, TargetOpcode::EXTRACT_SUBREG, MVT::i1, CR0Reg,
4810 CurDAG->getTargetLoweringInfo().getPointerTy(CurDAG->getDataLayout());
4810 CurDAG->getTargetLoweringInfo().getPointerTy(CurDAG->getDataLayout());
4821 if (mayUseP9Setb(N, CC, CurDAG, NeedSwapOps, IsUnCmp)) {
4835 CurDAG->SelectNodeTo(
4853 CurDAG->getMachineNode(PPC::ADDIC, dl, MVT::i32, MVT::Glue,
4855 CurDAG->SelectNodeTo(N, PPC::SUBFE, MVT::i32, SDValue(Tmp, 0),
4876 SDValue CCBit = CurDAG->getTargetExtractSubreg(SRI, dl, MVT::i1, CCReg);
4878 SDValue NotCCBit(CurDAG->getMachineNode(PPC::CRNOR, dl, MVT::i1,
4883 SDValue CAndT(CurDAG->getMachineNode(PPC::CRAND, dl, MVT::i1,
4885 SDValue NotCAndF(CurDAG->getMachineNode(PPC::CRAND, dl, MVT::i1,
4888 CurDAG->SelectNodeTo(N, PPC::CROR, MVT::i1, CAndT, NotCAndF);
4931 CurDAG->SelectNodeTo(N, SelectCCOp, N->getValueType(0), Ops);
4962 SDNode *NewN = CurDAG->SelectNodeTo(N, PPC::LXVDSX,
4964 CurDAG->setNodeMemRefs(cast<MachineSDNode>(NewN), {MemOp});
4978 SDValue DMV = CurDAG->getTargetConstant(DM[1] | (DM[0] << 1), dl,
4981 CurDAG->SelectNodeTo(N, PPC::XXPERMDI, N->getValueType(0), Ops);
4990 CurDAG->SelectNodeTo(N, N->getOpcode() == PPCISD::BDNZ
5010 CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops);
5039 SDValue BitComp(CurDAG->getMachineNode(Opc, dl, MVT::i1,
5042 CurDAG->SelectNodeTo(N, PPC::BC, MVT::Other, BitComp, N->getOperand(4),
5053 CurDAG->SelectNodeTo(N, PPC::BCC, MVT::Other, Ops);
5062 Chain = SDValue(CurDAG->getMachineNode(Opc, dl, MVT::Glue, Target,
5064 CurDAG->SelectNodeTo(N, Reg, MVT::Other, Chain);
5093 SDNode *MN = CurDAG->getMachineNode(PPC::LWZtoc, dl, MVT::i32, GA,
5134 SDNode *Tmp = CurDAG->getMachineNode(
5140 SDNode *MN = CurDAG->getMachineNode(
5149 ReplaceNode(N, CurDAG->getMachineNode(PPC::ADDItocL, dl, MVT::i64,
5157 CurDAG->SelectNodeTo(N, PPC::PPC32PICGOT,
5158 PPCLowering->getPointerTy(CurDAG->getDataLayout()),
5200 SDNode *Tmp = CurDAG->getMachineNode(Opc1, dl, VT, EltVal);
5202 ReplaceNode(N, CurDAG->getMachineNode(Opc2, dl, VT, TmpVal, TmpVal));
5212 SDNode *Tmp1 = CurDAG->getMachineNode(Opc1, dl, VT, EltVal);
5214 SDNode *Tmp2 = CurDAG->getMachineNode(Opc1, dl, VT, EltVal);
5215 ReplaceNode(N, CurDAG->getMachineNode(Opc3, dl, VT, SDValue(Tmp1, 0),
5226 SDNode *Tmp1 = CurDAG->getMachineNode(Opc1, dl, VT, EltVal);
5228 SDNode *Tmp2 = CurDAG->getMachineNode(Opc1, dl, VT, EltVal);
5229 ReplaceNode(N, CurDAG->getMachineNode(Opc2, dl, VT, SDValue(Tmp1, 0),
5330 if (!CurDAG->MaskedValueIsZero(
5428 LHS = CurDAG->getAnyExtOrTrunc(LHS, dl, VT);
5429 RHS = CurDAG->getAnyExtOrTrunc(RHS, dl, VT);
5432 Res = CurDAG->getNode(PPCISD::CMPB, dl, VT, LHS, RHS);
5437 Res = CurDAG->getNode(ISD::AND, dl, VT, Res,
5438 CurDAG->getConstant(Mask, dl, VT));
5446 Res = CurDAG->getNode(ISD::AND, dl, VT, Res,
5447 CurDAG->getConstant(Mask ^ Alt, dl, VT));
5448 Res = CurDAG->getNode(ISD::XOR, dl, VT, Res,
5449 CurDAG->getConstant(Alt, dl, VT));
5481 CurDAG->getConstant(N->getOpcode() == ISD::SIGN_EXTEND ? -1 : 1, dl, VT);
5482 SDValue ConstFalse = CurDAG->getConstant(0, dl, VT);
5494 return CurDAG->FoldConstantArithmetic(User->getOpcode(), dl,
5517 Res = CurDAG->getSelect(dl, User->getValueType(0), Cond, TrueRes, FalseRes);
5525 SelectionDAG::allnodes_iterator Position = CurDAG->allnodes_end();
5528 while (Position != CurDAG->allnodes_begin()) {
5546 LLVM_DEBUG(N->dump(CurDAG));
5548 LLVM_DEBUG(Res.getNode()->dump(CurDAG));
5551 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
5557 CurDAG->RemoveDeadNodes();
5621 CurDAG->getMachineNode(User->getMachineOpcode(), SDLoc(User),
5627 LLVM_DEBUG(User->dump(CurDAG));
5629 LLVM_DEBUG(ResNode->dump(CurDAG));
5640 for (SDNode &Node : CurDAG->allnodes()) {
5718 ResNode = CurDAG->getMachineNode(PPC::CRUNSET, SDLoc(MachineNode),
5722 ResNode = CurDAG->getMachineNode(PPC::CRANDC, SDLoc(MachineNode),
5728 ResNode = CurDAG->getMachineNode(PPC::CRANDC, SDLoc(MachineNode),
5733 ResNode = CurDAG->getMachineNode(PPC::CRNAND, SDLoc(MachineNode),
5742 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5747 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5752 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5757 ResNode = CurDAG->getMachineNode(PPC::CRSET, SDLoc(MachineNode),
5761 ResNode = CurDAG->getMachineNode(PPC::CRORC, SDLoc(MachineNode),
5767 ResNode = CurDAG->getMachineNode(PPC::CRORC, SDLoc(MachineNode),
5772 ResNode = CurDAG->getMachineNode(PPC::CRAND, SDLoc(MachineNode),
5784 ResNode = CurDAG->getMachineNode(PPC::CRSET, SDLoc(MachineNode),
5794 ResNode = CurDAG->getMachineNode(PPC::CRORC, SDLoc(MachineNode),
5800 ResNode = CurDAG->getMachineNode(PPC::CRORC, SDLoc(MachineNode),
5805 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5814 ResNode = CurDAG->getMachineNode(PPC::CRUNSET, SDLoc(MachineNode),
5818 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5823 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5834 ResNode = CurDAG->getMachineNode(PPC::CREQV, SDLoc(MachineNode),
5840 ResNode = CurDAG->getMachineNode(PPC::CREQV, SDLoc(MachineNode),
5845 ResNode = CurDAG->getMachineNode(PPC::CREQV, SDLoc(MachineNode),
5854 ResNode = CurDAG->getMachineNode(PPC::CRUNSET, SDLoc(MachineNode),
5858 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5863 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5868 ResNode = CurDAG->getMachineNode(PPC::CRANDC, SDLoc(MachineNode),
5874 ResNode = CurDAG->getMachineNode(PPC::CRANDC, SDLoc(MachineNode),
5879 ResNode = CurDAG->getMachineNode(PPC::CROR, SDLoc(MachineNode),
5888 ResNode = CurDAG->getMachineNode(PPC::CRSET, SDLoc(MachineNode),
5898 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5903 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5908 ResNode = CurDAG->getMachineNode(PPC::CRXOR, SDLoc(MachineNode),
5914 ResNode = CurDAG->getMachineNode(PPC::CRXOR, SDLoc(MachineNode),
5919 ResNode = CurDAG->getMachineNode(PPC::CRXOR, SDLoc(MachineNode),
5928 ResNode = CurDAG->getMachineNode(PPC::CRUNSET, SDLoc(MachineNode),
5932 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5937 ResNode = CurDAG->getMachineNode(PPC::CRUNSET, SDLoc(MachineNode),
5944 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5950 ResNode = CurDAG->getMachineNode(PPC::CRAND, SDLoc(MachineNode),
5955 ResNode = CurDAG->getMachineNode(PPC::CRORC, SDLoc(MachineNode),
5964 ResNode = CurDAG->getMachineNode(PPC::CRSET, SDLoc(MachineNode),
5968 ResNode = CurDAG->getMachineNode(PPC::CRSET, SDLoc(MachineNode),
5975 ResNode = CurDAG->getMachineNode(PPC::CRNOR, SDLoc(MachineNode),
5980 ResNode = CurDAG->getMachineNode(PPC::CRNAND, SDLoc(MachineNode),
5986 ResNode = CurDAG->getMachineNode(PPC::CROR, SDLoc(MachineNode),
5991 ResNode = CurDAG->getMachineNode(PPC::CRANDC, SDLoc(MachineNode),
6015 ResNode = CurDAG->getMachineNode(MachineNode->getMachineOpcode(),
6026 ResNode = CurDAG->getMachineNode(Opcode == PPC::BC ? PPC::BCn :
6045 LLVM_DEBUG(MachineNode->dump(CurDAG));
6047 LLVM_DEBUG(ResNode->dump(CurDAG));
6055 CurDAG->RemoveDeadNodes();
6217 SelectionDAG::allnodes_iterator Position = CurDAG->allnodes_end();
6220 while (Position != CurDAG->allnodes_begin()) {
6322 CurDAG->getMachineNode(TargetOpcode::INSERT_SUBREG, SDLoc(V),
6343 LLVM_DEBUG(PN->dump(CurDAG));
6345 CurDAG->SelectNodeTo(PN, NewOpcode, CurDAG->getVTList(NewVTs), Ops);
6345 CurDAG->SelectNodeTo(PN, NewOpcode, CurDAG->getVTList(NewVTs), Ops);
6348 LLVM_DEBUG(PN->dump(CurDAG));
6357 LLVM_DEBUG(N->dump(CurDAG));
6359 LLVM_DEBUG(Op32.getNode()->dump(CurDAG));
6366 CurDAG->RemoveDeadNodes();
6374 SelectionDAG::allnodes_iterator Position = CurDAG->allnodes_end();
6376 while (Position != CurDAG->allnodes_begin()) {
6529 ImmOpnd = CurDAG->getTargetConstant(Offset, SDLoc(ImmOpnd),
6541 LLVM_DEBUG(Base->dump(CurDAG));
6543 LLVM_DEBUG(N->dump(CurDAG));
6559 ImmOpnd = CurDAG->getTargetGlobalAddress(GV, dl, MVT::i64, Offset, Flags);
6563 ImmOpnd = CurDAG->getTargetConstantPool(C, MVT::i64,
6570 (void)CurDAG->UpdateNodeOperands(N, N->getOperand(0), ImmOpnd,
6573 (void)CurDAG->UpdateNodeOperands(N, ImmOpnd, Base.getOperand(0),
6577 (void)CurDAG->UpdateNodeOperands(HBase.getNode(), HBase.getOperand(0),
6582 CurDAG->RemoveDeadNode(Base.getNode());
lib/Target/RISCV/RISCVISelDAGToDAG.cpp 101 LLVM_DEBUG(dbgs() << "== "; Node->dump(CurDAG); dbgs() << "\n");
117 SDValue New = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), SDLoc(Node),
117 SDValue New = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), SDLoc(Node),
124 ReplaceNode(Node, selectImm(CurDAG, SDLoc(Node), Imm, XLenVT));
130 SDValue Imm = CurDAG->getTargetConstant(0, DL, XLenVT);
132 SDValue TFI = CurDAG->getTargetFrameIndex(FI, VT);
133 ReplaceNode(Node, CurDAG->getMachineNode(RISCV::ADDI, DL, VT, TFI, Imm));
152 CurDAG->getTargetConstant(ShAmt, SDLoc(Node), XLenVT);
153 CurDAG->SelectNodeTo(Node, RISCV::SRLIW, XLenVT, Op0.getOperand(0),
163 ReplaceNode(Node, CurDAG->getMachineNode(RISCV::ReadCycleWide, DL, MVT::i32,
194 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), Subtarget->getXLenVT());
204 SelectionDAG::allnodes_iterator Position(CurDAG->getRoot().getNode());
207 while (Position != CurDAG->allnodes_begin()) {
258 ImmOperand = CurDAG->getTargetConstant(
261 ImmOperand = CurDAG->getTargetGlobalAddress(
269 LLVM_DEBUG(Base->dump(CurDAG));
271 LLVM_DEBUG(N->dump(CurDAG));
276 CurDAG->UpdateNodeOperands(N, Base.getOperand(0), ImmOperand,
279 CurDAG->UpdateNodeOperands(N, N->getOperand(0), Base.getOperand(0),
284 CurDAG->RemoveDeadNode(Base.getNode());
lib/Target/Sparc/SparcISelDAGToDAG.cpp 70 return CurDAG->getRegister(GlobalBaseReg,
71 TLI->getPointerTy(CurDAG->getDataLayout()))
78 Base = CurDAG->getTargetFrameIndex(
79 FIN->getIndex(), TLI->getPointerTy(CurDAG->getDataLayout()));
80 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), MVT::i32);
94 Base = CurDAG->getTargetFrameIndex(
95 FIN->getIndex(), TLI->getPointerTy(CurDAG->getDataLayout()));
99 Offset = CurDAG->getTargetConstant(CN->getZExtValue(), SDLoc(Addr),
116 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), MVT::i32);
140 R2 = CurDAG->getRegister(SP::G0, TLI->getPointerTy(CurDAG->getDataLayout()));
140 R2 = CurDAG->getRegister(SP::G0, TLI->getPointerTy(CurDAG->getDataLayout()));
235 PairedReg = CurDAG->getRegister(GPVR, MVT::v2i32);
239 SDValue RegCopy = CurDAG->getCopyFromReg(Chain, dl, GPVR, MVT::v2i32,
243 SDValue Sub0 = CurDAG->getTargetExtractSubreg(SP::sub_even, dl, MVT::i32,
245 SDValue Sub1 = CurDAG->getTargetExtractSubreg(SP::sub_odd, dl, MVT::i32,
247 SDValue T0 = CurDAG->getCopyToReg(Sub0, dl, Reg0, Sub0,
249 SDValue T1 = CurDAG->getCopyToReg(Sub1, dl, Reg1, Sub1, T0.getValue(1));
254 CurDAG->UpdateNodeOperands(GU, Ops);
262 SDValue T0 = CurDAG->getCopyFromReg(Chain, dl, Reg0, MVT::i32,
264 SDValue T1 = CurDAG->getCopyFromReg(Chain, dl, Reg1, MVT::i32,
267 CurDAG->getMachineNode(
270 CurDAG->getTargetConstant(SP::IntPairRegClassID, dl,
273 CurDAG->getTargetConstant(SP::sub_even, dl, MVT::i32),
275 CurDAG->getTargetConstant(SP::sub_odd, dl, MVT::i32),
282 PairedReg = CurDAG->getRegister(GPVR, MVT::v2i32);
283 Chain = CurDAG->getCopyToReg(T1, dl, GPVR, Pair, T1.getValue(1));
299 AsmNodeOperands[AsmNodeOperands.size() -1] = CurDAG->getTargetConstant(
315 SDValue New = CurDAG->getNode(N->getOpcode(), SDLoc(N),
316 CurDAG->getVTList(MVT::Other, MVT::Glue), AsmNodeOperands);
353 TopPart = SDValue(CurDAG->getMachineNode(SP::SRAri, dl, MVT::i32, DivLHS,
354 CurDAG->getTargetConstant(31, dl, MVT::i32)),
357 TopPart = CurDAG->getRegister(SP::G0, MVT::i32);
359 TopPart = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, SP::Y, TopPart,
359 TopPart = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, SP::Y, TopPart,
365 CurDAG->SelectNodeTo(N, Opcode, MVT::i32, DivLHS, DivRHS, TopPart);
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp 139 return CurDAG->getTargetConstant(Imm, SDLoc(Node), Node->getValueType(0));
459 if (Opcode == ISD::ADD || CurDAG->isBaseWithConstantOffset(N)) {
600 LLVM_DEBUG(AM.dump(CurDAG));
629 Base = CurDAG->getRegister(0, VT);
633 Base = CurDAG->getTargetFrameIndex(FrameIndex, VT);
639 SDValue Trunc = CurDAG->getNode(ISD::TRUNCATE, DL, VT, Base);
640 insertDAGNode(CurDAG, Base.getNode(), Trunc);
645 Disp = CurDAG->getTargetConstant(AM.Disp, SDLoc(Base), VT);
657 Index = CurDAG->getRegister(0, VT);
739 KnownBits Known = CurDAG->computeKnownBits(Op.getOperand(0));
797 KnownBits Known = CurDAG->computeKnownBits(Input);
820 KnownBits Known = CurDAG->computeKnownBits(Input);
936 SDNode *N = CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, DL, VT);
943 return CurDAG->getTargetInsertSubreg(SystemZ::subreg_l32,
946 return CurDAG->getTargetExtractSubreg(SystemZ::subreg_l32, DL, VT, N);
1004 SDValue Mask = CurDAG->getConstant(RISBG.Mask, DL, VT);
1005 SDValue New = CurDAG->getNode(ISD::AND, DL, VT, In, Mask);
1007 insertDAGNode(CurDAG, N, Mask);
1008 insertDAGNode(CurDAG, N, New);
1041 CurDAG->getTargetConstant(RISBG.Start, DL, MVT::i32),
1042 CurDAG->getTargetConstant(RISBG.End | 128, DL, MVT::i32),
1043 CurDAG->getTargetConstant(RISBG.Rotate, DL, MVT::i32)
1046 DL, VT, SDValue(CurDAG->getMachineNode(Opcode, DL, OpcodeVT, Ops), 0));
1098 CurDAG->getTargetConstant(RxSBG[I].Start, DL, MVT::i32),
1099 CurDAG->getTargetConstant(RxSBG[I].End, DL, MVT::i32),
1100 CurDAG->getTargetConstant(RxSBG[I].Rotate, DL, MVT::i32)
1103 DL, VT, SDValue(CurDAG->getMachineNode(Opcode, DL, MVT::i64, Ops), 0));
1113 SDValue Upper = CurDAG->getConstant(UpperVal, DL, VT);
1115 Upper = CurDAG->getNode(Opcode, DL, VT, Op0, Upper);
1135 SDValue Lower = CurDAG->getConstant(LowerVal, DL, VT);
1136 SDValue Or = CurDAG->getNode(Opcode, DL, VT, Upper, Lower);
1154 Ops.push_back(CurDAG->getTargetConstant(OpVal, DL, MVT::i32));
1155 SDValue Op = CurDAG->getNode(VCI.Opcode, DL, VCI.VecVT, Ops);
1160 SDValue BitCast = CurDAG->getNode(ISD::BITCAST, DL, VT, Op);
1167 Node, CurDAG->getTargetExtractSubreg(SubRegIdx, DL, VT, Op).getNode());
1198 CurDAG->getTargetConstant(Elem, DL, MVT::i32), Load->getChain()
1200 SDNode *Res = CurDAG->getMachineNode(Opcode, DL, VT, MVT::Other, Ops);
1231 Vec, Base, Disp, Index, CurDAG->getTargetConstant(Elem, DL, MVT::i32),
1234 ReplaceNode(Store, CurDAG->getMachineNode(Opcode, DL, MVT::Other, Ops));
1370 if (!isFusableLoadOpStorePattern(StoreNode, StoredVal, CurDAG, LoadNode,
1383 Operand = CurDAG->getTargetConstant(OperandV, DL, MemVT);
1391 CurDAG->getMachineNode(NewOpc, DL, MVT::i32, MVT::Other, Ops);
1392 CurDAG->setNodeMemRefs(
1397 CurDAG->RemoveDeadNode(Node);
1462 LLVM_DEBUG(errs() << "== "; Node->dump(CurDAG); errs() << "\n");
1558 CCMask = CurDAG->getTargetConstant(ConstCCValid ^ ConstCCMask,
1562 CurDAG->UpdateNodeOperands(Node, Op1, Op0, CCValid, CCMask, Op4);
1668 SDValue RC = CurDAG->getTargetConstant(TRC->getID(), DL, MVT::i32);
1675 SDValue(CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
1683 SDValue(CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
1843 SDValue Result = CurDAG->getNode(SystemZISD::IPM, DL, MVT::i32, CCReg);
1846 Result = CurDAG->getNode(ISD::XOR, DL, MVT::i32, Result,
1847 CurDAG->getConstant(IPM.XORValue, DL, MVT::i32));
1850 Result = CurDAG->getNode(ISD::ADD, DL, MVT::i32, Result,
1851 CurDAG->getConstant(IPM.AddValue, DL, MVT::i32));
1856 Result = CurDAG->getNode(ShiftOp, DL, MVT::i32, Result,
1857 CurDAG->getConstant(IPM.Bit, DL, MVT::i32));
1860 Result = CurDAG->getNode(ISD::ANY_EXTEND, DL, VT, Result);
1864 Result = CurDAG->getNode(ISD::SRL, DL, VT, Result,
1865 CurDAG->getConstant(IPM.Bit, DL, MVT::i32));
1866 Result = CurDAG->getNode(ISD::AND, DL, VT, Result,
1867 CurDAG->getConstant(1, DL, VT));
1872 Result = CurDAG->getNode(ISD::SHL, DL, VT, Result,
1873 CurDAG->getConstant(ShlAmt, DL, MVT::i32));
1874 Result = CurDAG->getNode(ISD::SRA, DL, VT, Result,
1875 CurDAG->getConstant(SraAmt, DL, MVT::i32));
1890 for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
1891 E = CurDAG->allnodes_end();
1907 LLVM_DEBUG(N->dump(CurDAG));
1909 LLVM_DEBUG(Res.getNode()->dump(CurDAG));
1912 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
1918 CurDAG->RemoveDeadNodes();
lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp 82 LLVM_DEBUG(errs() << "== "; Node->dump(CurDAG); errs() << "\n");
89 MachineFunction &MF = CurDAG->getMachineFunction();
103 Fence = CurDAG->getMachineNode(WebAssembly::COMPILER_FENCE,
112 Fence = CurDAG->getMachineNode(
116 CurDAG->getTargetConstant(0, DL, MVT::i32), // order
125 CurDAG->RemoveDeadNode(Node);
150 MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
153 SDValue TLSBaseSym = CurDAG->getTargetExternalSymbol("__tls_base", PtrVT);
154 SDValue TLSOffsetSym = CurDAG->getTargetGlobalAddress(
157 MachineSDNode *TLSBase = CurDAG->getMachineNode(WebAssembly::GLOBAL_GET_I32,
159 MachineSDNode *TLSOffset = CurDAG->getMachineNode(
162 CurDAG->getMachineNode(WebAssembly::ADD_I32, DL, MVT::i32,
172 MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
175 MachineSDNode *TLSSize = CurDAG->getMachineNode(
177 CurDAG->getTargetExternalSymbol("__tls_size", MVT::i32));
182 MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
185 MachineSDNode *TLSAlign = CurDAG->getMachineNode(
187 CurDAG->getTargetExternalSymbol("__tls_align", MVT::i32));
198 MVT PtrVT = TLI->getPointerTy(CurDAG->getDataLayout());
201 MachineSDNode *TLSBase = CurDAG->getMachineNode(
203 CurDAG->getTargetExternalSymbol("__tls_base", PtrVT),
lib/Target/X86/X86ISelDAGToDAG.cpp 273 Base = CurDAG->getTargetFrameIndex(
274 AM.Base_FrameIndex, TLI->getPointerTy(CurDAG->getDataLayout()));
278 Base = CurDAG->getRegister(0, VT);
285 SDValue Neg = SDValue(CurDAG->getMachineNode(NegOpc, DL, VT, MVT::i32,
293 Index = CurDAG->getRegister(0, VT);
298 Disp = CurDAG->getTargetGlobalAddress(AM.GV, SDLoc(),
302 Disp = CurDAG->getTargetConstantPool(AM.CP, MVT::i32,
306 Disp = CurDAG->getTargetExternalSymbol(AM.ES, MVT::i32, AM.SymbolFlags);
310 Disp = CurDAG->getMCSymbol(AM.MCSym, MVT::i32);
313 Disp = CurDAG->getTargetJumpTable(AM.JT, MVT::i32, AM.SymbolFlags);
315 Disp = CurDAG->getTargetBlockAddress(AM.BlockAddr, MVT::i32, AM.Disp,
318 Disp = CurDAG->getTargetConstant(AM.Disp, DL, MVT::i32);
323 Segment = CurDAG->getRegister(0, MVT::i16);
409 return CurDAG->getTargetConstant(Imm, DL, MVT::i8);
414 return CurDAG->getTargetConstant(Imm, DL, MVT::i32);
419 return CurDAG->getTargetConstant(Imm, DL, MVT::i64);
447 APInt Mask = Val | CurDAG->computeKnownBits(N->getOperand(0)).Zero;
790 for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
791 E = CurDAG->allnodes_end(); I != E; ) {
797 SDValue Res = CurDAG->getNode(ISD::AND, SDLoc(N), N->getValueType(0),
800 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
802 CurDAG->DeleteNode(N);
820 SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
823 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
825 CurDAG->DeleteNode(N);
843 SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
846 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
848 CurDAG->DeleteNode(N);
863 SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
866 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
868 CurDAG->DeleteNode(N);
888 SDValue Res = CurDAG->getNode(
890 CurDAG->getTargetConstant(Imm, dl, MVT::i8));
892 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
894 CurDAG->DeleteNode(N);
909 SDValue Op0 = CurDAG->getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT,
911 SDValue Op1 = CurDAG->getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT,
917 Op0 = CurDAG->getNode(ISD::BITCAST, dl, IntVT, Op0);
918 Op1 = CurDAG->getNode(ISD::BITCAST, dl, IntVT, Op1);
927 Res = CurDAG->getNode(Opc, dl, IntVT, Op0, Op1);
928 Res = CurDAG->getNode(ISD::BITCAST, dl, VecVT, Res);
930 Res = CurDAG->getNode(N->getOpcode(), dl, VecVT, Op0, Op1);
932 Res = CurDAG->getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Res,
933 CurDAG->getIntPtrConstant(0, dl));
935 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Res);
937 CurDAG->DeleteNode(N);
974 moveBelowOrigChain(CurDAG, Load, SDValue(N, 0), Chain);
1026 SDValue MemTmp = CurDAG->CreateStackTemporary(MemVT);
1031 SDValue Store = CurDAG->getTruncStore(CurDAG->getEntryNode(), dl, N->getOperand(0),
1031 SDValue Store = CurDAG->getTruncStore(CurDAG->getEntryNode(), dl, N->getOperand(0),
1033 SDValue Result = CurDAG->getExtLoad(ISD::EXTLOAD, dl, DstVT, Store, MemTmp,
1041 CurDAG->ReplaceAllUsesOfValueWith(SDValue(N, 0), Result);
1084 SDValue MemTmp = CurDAG->CreateStackTemporary(MemVT);
1090 SDValue Store = CurDAG->getTruncStore(N->getOperand(0), dl, N->getOperand(1),
1092 SDValue Result = CurDAG->getExtLoad(ISD::EXTLOAD, dl, DstVT, Store, MemTmp,
1100 CurDAG->ReplaceAllUsesWith(N, Result.getNode());
1109 CurDAG->DeleteNode(N);
1115 CurDAG->RemoveDeadNodes();
1143 MachineSDNode *Extend = CurDAG->getMachineNode(X86::MOVSX64rr32, SDLoc(N),
1159 SelectionDAG::allnodes_iterator Position = CurDAG->allnodes_end();
1162 while (Position != CurDAG->allnodes_begin()) {
1185 MachineSDNode *Test = CurDAG->getMachineNode(Opc, SDLoc(N),
1211 MachineSDNode *Test = CurDAG->getMachineNode(NewOpc, SDLoc(N),
1244 MachineSDNode *KTest = CurDAG->getMachineNode(NewOpc, SDLoc(N),
1302 CurDAG->UpdateNodeOperands(N, N->getOperand(0), In, N->getOperand(2));
1307 CurDAG->RemoveDeadNodes();
1315 auto &DL = CurDAG->getDataLayout();
1317 TargetLowering::CallLoweringInfo CLI(*CurDAG);
1318 CLI.setChain(CurDAG->getRoot())
1319 .setCallee(CallingConv::C, Type::getVoidTy(*CurDAG->getContext()),
1320 CurDAG->getExternalSymbol("__main", TLI->getPointerTy(DL)),
1322 const TargetLowering &TLI = CurDAG->getTargetLoweringInfo();
1324 CurDAG->setRoot(Result.second);
1388 AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
1391 AM.Segment = CurDAG->getRegister(X86::FS, MVT::i16);
1467 AM.setBaseReg(CurDAG->getRegister(X86::RIP, MVT::i64));
1502 AM.Base_Reg = CurDAG->getRegister(X86::RIP, MVT::i64);
1850 AM.dump(CurDAG);
1928 if (CurDAG->isBaseWithConstantOffset(ShVal)) {
1965 if (!foldMaskAndShiftToScale(*CurDAG, N, Mask, N, X, AM))
2087 if (CurDAG->haveNoCommonBitsSet(N.getOperand(0), N.getOperand(1)) &&
2114 if (!foldMaskAndShiftToExtract(*CurDAG, N, Mask, Shift, X, AM))
2118 if (!foldMaskAndShiftToScale(*CurDAG, N, Mask, Shift, X, AM))
2122 if (!foldMaskedShiftToBEXTR(*CurDAG, N, Mask, Shift, X, AM, *Subtarget))
2128 if (!foldMaskedShiftToScaledMask(*CurDAG, N, AM))
2151 if (!CurDAG->MaskedValueIsZero(Shl.getOperand(0), HighZeros))
2157 SDValue Zext = CurDAG->getNode(ISD::ZERO_EXTEND, DL, VT, Shl.getOperand(0));
2158 SDValue NewShl = CurDAG->getNode(ISD::SHL, DL, VT, Zext, Shl.getOperand(1));
2164 insertDAGNode(*CurDAG, N, Zext);
2165 insertDAGNode(*CurDAG, N, NewShl);
2166 CurDAG->ReplaceAllUsesWith(N, NewShl);
2167 CurDAG->RemoveDeadNode(N.getNode());
2229 AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
2231 AM.Segment = CurDAG->getRegister(X86::FS, MVT::i16);
2233 AM.Segment = CurDAG->getRegister(X86::SS, MVT::i16);
2272 AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
2274 AM.Segment = CurDAG->getRegister(X86::FS, MVT::i16);
2276 AM.Segment = CurDAG->getRegister(X86::SS, MVT::i16);
2366 Imm = CurDAG->getTargetConstant(ImmVal, SDLoc(N), MVT::i64);
2405 Base = CurDAG->getRegister(0, MVT::i64);
2408 SDValue ImplDef = SDValue(CurDAG->getMachineNode(X86::IMPLICIT_DEF, DL,
2410 Base = CurDAG->getTargetInsertSubreg(X86::sub_32bit, DL, MVT::i64, ImplDef,
2416 Index = CurDAG->getRegister(0, MVT::i64);
2420 SDValue ImplDef = SDValue(CurDAG->getMachineNode(X86::IMPLICIT_DEF, DL,
2422 Index = CurDAG->getTargetInsertSubreg(X86::sub_32bit, DL, MVT::i64, ImplDef,
2444 SDValue T = CurDAG->getRegister(0, MVT::i32);
2535 AM.IndexReg = CurDAG->getRegister(X86::EBX, MVT::i32);
2544 Op = CurDAG->getTargetConstant(CN->getAPIntValue(), SDLoc(CN),
2580 Op = CurDAG->getTargetGlobalAddress(GA->getGlobal(), SDLoc(N), VT,
2619 return CurDAG->getRegister(GlobalBaseReg, TLI->getPointerTy(DL)).getNode();
2974 if (!isFusableLoadOpStorePattern(StoreNode, StoredVal, CurDAG, LoadOpNo,
2981 if (!isFusableLoadOpStorePattern(StoreNode, StoredVal, CurDAG, LoadOpNo,
3015 Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32,
3032 Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32,
3140 Operand = CurDAG->getTargetConstant(OperandV, SDLoc(Node), MemVT);
3143 Operand = CurDAG->getTargetConstant(OperandV, SDLoc(Node), MemVT);
3150 CurDAG->getCopyToReg(InputChain, SDLoc(Node), X86::EFLAGS,
3155 Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32, MVT::Other,
3160 Result = CurDAG->getMachineNode(NewOpc, SDLoc(Node), MVT::i32, MVT::Other,
3171 CurDAG->setNodeMemRefs(Result, MemOps);
3177 CurDAG->RemoveDeadNode(Node);
3245 return CurDAG->MaskedValueIsAllOnes(
3354 NBits = CurDAG->getNode(ISD::TRUNCATE, DL, MVT::i8, NBits);
3355 insertDAGNode(*CurDAG, SDValue(Node, 0), NBits);
3360 CurDAG->getMachineNode(TargetOpcode::IMPLICIT_DEF, DL, MVT::i32), 0);
3361 insertDAGNode(*CurDAG, SDValue(Node, 0), ImplDef);
3363 SDValue SRIdxVal = CurDAG->getTargetConstant(X86::sub_8bit, DL, MVT::i32);
3364 insertDAGNode(*CurDAG, SDValue(Node, 0), SRIdxVal);
3366 CurDAG->getMachineNode(TargetOpcode::INSERT_SUBREG, DL, MVT::i32, ImplDef,
3368 insertDAGNode(*CurDAG, SDValue(Node, 0), NBits);
3374 NBits = CurDAG->getNode(ISD::ANY_EXTEND, DL, NVT, NBits);
3375 insertDAGNode(*CurDAG, SDValue(Node, 0), NBits);
3378 SDValue Extract = CurDAG->getNode(X86ISD::BZHI, DL, NVT, X, NBits);
3405 SDValue C8 = CurDAG->getConstant(8, DL, MVT::i8);
3406 SDValue Control = CurDAG->getNode(ISD::SHL, DL, MVT::i32, NBits, C8);
3407 insertDAGNode(*CurDAG, SDValue(Node, 0), Control);
3421 ShiftAmt = CurDAG->getNode(ISD::ZERO_EXTEND, DL, MVT::i32, ShiftAmt);
3422 insertDAGNode(*CurDAG, OrigShiftAmt, ShiftAmt);
3425 Control = CurDAG->getNode(ISD::OR, DL, MVT::i32, Control, ShiftAmt);
3426 insertDAGNode(*CurDAG, SDValue(Node, 0), Control);
3431 Control = CurDAG->getNode(ISD::ANY_EXTEND, DL, XVT, Control);
3432 insertDAGNode(*CurDAG, SDValue(Node, 0), Control);
3436 SDValue Extract = CurDAG->getNode(X86ISD::BEXTR, DL, XVT, X, Control);
3440 insertDAGNode(*CurDAG, SDValue(Node, 0), Extract);
3441 Extract = CurDAG->getNode(ISD::TRUNCATE, DL, NVT, Extract);
3519 Control = CurDAG->getTargetConstant(Shift + MaskSize, dl, NVT);
3523 Control = SDValue(CurDAG->getMachineNode(NewOpc, dl, NVT, Control), 0);
3529 Control = CurDAG->getTargetConstant(Shift | (MaskSize << 8), dl, NVT);
3539 Control = SDValue(CurDAG->getMachineNode(NewOpc, dl, NVT, Control), 0);
3549 SDVTList VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
3550 NewNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
3554 CurDAG->setNodeMemRefs(NewNode, {cast<LoadSDNode>(Input)->getMemOperand()});
3556 NewNode = CurDAG->getMachineNode(ROpc, dl, NVT, MVT::i32, Input, Control);
3561 SDValue ShAmt = CurDAG->getTargetConstant(Shift, dl, NVT);
3564 CurDAG->getMachineNode(NewOpc, dl, NVT, SDValue(NewNode, 0), ShAmt);
3578 Imm = CurDAG->getTargetConstant(*Val, SDLoc(Node), Imm.getValueType());
3585 SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Other);
3586 MachineSDNode *CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
3590 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
3595 SDVTList VTs = CurDAG->getVTList(VT, MVT::i32);
3596 MachineSDNode *CNode = CurDAG->getMachineNode(ROpc, dl, VTs, Ops);
3611 Imm = CurDAG->getTargetConstant(*Val, SDLoc(Node), Imm.getValueType());
3618 SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Other, MVT::Glue);
3619 MachineSDNode *CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
3624 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N2)->getMemOperand()});
3629 SDVTList VTs = CurDAG->getVTList(VT, MVT::i32, MVT::Glue);
3630 MachineSDNode *CNode = CurDAG->getMachineNode(ROpc, dl, VTs, Ops);
3675 SDValue Zero = CurDAG->getConstant(0, DL, SubVT);
3676 SDValue Neg = CurDAG->getNode(ISD::SUB, DL, SubVT, Zero, Add1);
3681 insertDAGNode(*CurDAG, OrigShiftAmt, Zero);
3682 insertDAGNode(*CurDAG, OrigShiftAmt, Neg);
3690 NewShiftAmt = CurDAG->getNode(ISD::TRUNCATE, DL, MVT::i8, NewShiftAmt);
3692 insertDAGNode(*CurDAG, OrigShiftAmt, NewShiftAmt);
3697 NewShiftAmt = CurDAG->getNode(ISD::AND, DL, MVT::i8, NewShiftAmt,
3698 CurDAG->getConstant(Size - 1, DL, MVT::i8));
3700 insertDAGNode(*CurDAG, OrigShiftAmt, NewShiftAmt);
3702 SDNode *UpdatedNode = CurDAG->UpdateNodeOperands(N, N->getOperand(0),
3714 CurDAG->RemoveDeadNode(OrigShiftAmt.getNode());
3813 if (CurDAG->MaskedValueIsZero(N->getOperand(0), NeededMask))
3819 SDValue NewX = CurDAG->getNode(ISD::ANY_EXTEND, dl, NVT, X);
3820 insertDAGNode(*CurDAG, SDValue(N, 0), NewX);
3824 SDValue NewCst = CurDAG->getConstant(ShiftedVal, dl, NVT);
3825 insertDAGNode(*CurDAG, SDValue(N, 0), NewCst);
3826 SDValue NewBinOp = CurDAG->getNode(Opcode, dl, NVT, X, NewCst);
3827 insertDAGNode(*CurDAG, SDValue(N, 0), NewBinOp);
3828 SDValue NewSHL = CurDAG->getNode(ISD::SHL, dl, NVT, NewBinOp,
3861 OneConstant = CurDAG->getConstant(Ones, DL, MVT::i32);
3862 insertDAGNode(*CurDAG, X, OneConstant);
3866 AllOnesVec = CurDAG->getSplatBuildVector(MVT::getVectorVT(MVT::i32, NumElts),
3868 insertDAGNode(*CurDAG, X, AllOnesVec);
3870 AllOnesVec = CurDAG->getBitcast(VT, AllOnesVec);
3871 insertDAGNode(*CurDAG, X, AllOnesVec);
3874 SDValue NewNode = CurDAG->getNode(NewOpcode, DL, VT, X, AllOnesVec);
3933 if (!CurDAG->MaskedValueIsZero(And0, HighZeros))
3944 SDValue NewMask = CurDAG->getConstant(NegMaskVal, SDLoc(And), VT);
3945 SDValue NewAnd = CurDAG->getNode(ISD::AND, SDLoc(And), VT, And0, NewMask);
4241 SDValue ImplDef = SDValue(CurDAG->getMachineNode(X86::IMPLICIT_DEF, dl,
4243 Src0 = CurDAG->getTargetInsertSubreg(SubReg, dl, CmpVT, ImplDef, Src0);
4247 Src1 = CurDAG->getTargetInsertSubreg(SubReg, dl, CmpVT, ImplDef, Src1);
4252 SDValue RC = CurDAG->getTargetConstant(RegClass, dl, MVT::i32);
4253 InMask = SDValue(CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
4264 SDVTList VTs = CurDAG->getVTList(MaskVT, MVT::Other);
4269 CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
4273 CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
4279 CurDAG->setNodeMemRefs(CNode, {cast<MemSDNode>(Load)->getMemOperand()});
4282 CNode = CurDAG->getMachineNode(Opc, dl, MaskVT, InMask, Src0, Src1);
4284 CNode = CurDAG->getMachineNode(Opc, dl, MaskVT, Src0, Src1);
4290 SDValue RC = CurDAG->getTargetConstant(RegClass, dl, MVT::i32);
4291 CNode = CurDAG->getMachineNode(TargetOpcode::COPY_TO_REGCLASS,
4296 CurDAG->RemoveDeadNode(Root);
4342 SDValue Imm = CurDAG->getTargetConstant(0xCA, dl, MVT::i8);
4343 SDValue Ternlog = CurDAG->getNode(X86ISD::VPTERNLOG, dl, NVT, A, B, C, Imm);
4355 LLVM_DEBUG(dbgs() << "== "; Node->dump(CurDAG); dbgs() << '\n');
4393 SDValue Chain = CurDAG->getCopyToReg(Node->getOperand(0), dl, PtrReg,
4400 Chain = CurDAG->getCopyToReg(Chain, dl, X86::ECX, Node->getOperand(3),
4403 Chain = CurDAG->getCopyToReg(Chain, dl, X86::EDX, Node->getOperand(4),
4408 MachineSDNode *CNode = CurDAG->getMachineNode(Opc, dl, MVT::Other,
4429 SDValue ZextTarget = CurDAG->getZExtOrTrunc(Target, dl, EVT(MVT::i64));
4430 SDValue Brind = CurDAG->getNode(ISD::BRIND, dl, MVT::Other,
4448 CurDAG->RemoveDeadNode(Node);
4459 SDValue Blendv = CurDAG->getNode(
4493 CurDAG->RemoveDeadNode(Node);
4605 SDVTList VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
4606 MachineSDNode *CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
4610 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N0)->getMemOperand()});
4612 CurDAG->RemoveDeadNode(Node);
4617 CurDAG->SelectNodeTo(Node, ROpc, NVT, MVT::i32, N0, N1);
4664 SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, LoReg,
4664 SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, LoReg,
4673 VTs = CurDAG->getVTList(NVT, MVT::i32, MVT::Other);
4675 VTs = CurDAG->getVTList(NVT, NVT, MVT::i32, MVT::Other);
4679 CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
4684 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
4690 VTs = CurDAG->getVTList(NVT, MVT::i32);
4692 VTs = CurDAG->getVTList(NVT, NVT, MVT::i32);
4694 CNode = CurDAG->getMachineNode(ROpc, dl, VTs, {N1, InFlag});
4699 CurDAG->RemoveDeadNode(Node);
4746 SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, SrcReg,
4746 SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, SrcReg,
4753 SDVTList VTs = CurDAG->getVTList(MVT::Other, MVT::Glue);
4754 CNode = CurDAG->getMachineNode(MOpc, dl, VTs, Ops);
4761 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
4764 SDVTList VTs = CurDAG->getVTList(MVT::Glue);
4765 SDNode *CNode = CurDAG->getMachineNode(Opc, dl, VTs, Ops);
4772 SDValue ResLo = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl, LoReg,
4772 SDValue ResLo = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl, LoReg,
4776 LLVM_DEBUG(dbgs() << "=> "; ResLo.getNode()->dump(CurDAG);
4782 SDValue ResHi = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl, HiReg,
4782 SDValue ResHi = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl, HiReg,
4786 LLVM_DEBUG(dbgs() << "=> "; ResHi.getNode()->dump(CurDAG);
4790 CurDAG->RemoveDeadNode(Node);
4844 bool signBitIsZero = CurDAG->SignBitIsZero(N0);
4856 Move = CurDAG->getMachineNode(Opc, dl, MVT::i16, MVT::Other, Ops);
4860 CurDAG->setNodeMemRefs(Move, {cast<LoadSDNode>(N0)->getMemOperand()});
4864 Move = CurDAG->getMachineNode(Opc, dl, MVT::i16, N0);
4865 Chain = CurDAG->getEntryNode();
4867 Chain = CurDAG->getCopyToReg(Chain, dl, X86::AX, SDValue(Move, 0),
4872 CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl,
4872 CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl,
4877 SDValue(CurDAG->getMachineNode(SExtOpcode, dl, MVT::Glue, InFlag),0);
4880 SDValue ClrNode = SDValue(CurDAG->getMachineNode(X86::MOV32r0, dl, NVT), 0);
4884 SDValue(CurDAG->getMachineNode(
4886 CurDAG->getTargetConstant(X86::sub_16bit, dl,
4894 SDValue(CurDAG->getMachineNode(
4896 CurDAG->getTargetConstant(0, dl, MVT::i64), ClrNode,
4897 CurDAG->getTargetConstant(X86::sub_32bit, dl,
4905 InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, ClrReg,
4905 InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, ClrReg,
4914 CurDAG->getMachineNode(MOpc, dl, MVT::Other, MVT::Glue, Ops);
4919 CurDAG->setNodeMemRefs(CNode, {cast<LoadSDNode>(N1)->getMemOperand()});
4922 SDValue(CurDAG->getMachineNode(Opc, dl, MVT::Glue, N1, InFlag), 0);
4933 SDValue AHCopy = CurDAG->getRegister(X86::AH, MVT::i8);
4937 SDNode *RNode = CurDAG->getMachineNode(AHExtOpcode, dl, MVT::i32,
4943 CurDAG->getTargetExtractSubreg(X86::sub_8bit, dl, MVT::i8, Result);
4946 LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
4951 SDValue Result = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl,
4951 SDValue Result = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl,
4955 LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
4960 SDValue Result = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl,
4960 SDValue Result = CurDAG->getCopyFromReg(CurDAG->getEntryNode(), dl,
4964 LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
4967 CurDAG->RemoveDeadNode(Node);
4991 NewNode = CurDAG->getMachineNode(TestOpc, dl, MVT::i32, BEXTR, BEXTR);
4993 CurDAG->RemoveDeadNode(Node);
5019 SDValue Imm = CurDAG->getTargetConstant(TrailingZeros, dl, MVT::i64);
5021 SDValue(CurDAG->getMachineNode(X86::SHR64ri, dl, MVT::i64, MVT::i32,
5023 MachineSDNode *Test = CurDAG->getMachineNode(X86::TEST64rr, dl,
5030 SDValue Imm = CurDAG->getTargetConstant(LeadingZeros, dl, MVT::i64);
5032 SDValue(CurDAG->getMachineNode(X86::SHL64ri, dl, MVT::i64, MVT::i32,
5034 MachineSDNode *Test = CurDAG->getMachineNode(X86::TEST64rr, dl,
5090 SDValue Imm = CurDAG->getTargetConstant(Mask, dl, VT);
5099 NewNode = CurDAG->getMachineNode(MOpc, dl, MVT::i32, MVT::Other, Ops);
5103 CurDAG->setNodeMemRefs(NewNode,
5108 Reg = CurDAG->getTargetExtractSubreg(SubRegOp, dl, VT, Reg);
5110 NewNode = CurDAG->getMachineNode(ROpc, dl, MVT::i32, Reg, Imm);
5143 CurDAG->RemoveDeadNode(Node);
5151 SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EAX,
5151 SDValue InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EAX,
5154 InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EDX,
5154 InFlag = CurDAG->getCopyToReg(CurDAG->getEntryNode(), dl, X86::EDX,
5178 CurDAG->RemoveDeadNode(Node);
5214 SDValue Res = CurDAG->getNode(X86ISD::VRNDSCALE, dl, Node->getValueType(0),
5216 CurDAG->getTargetConstant(Imm, dl, MVT::i8));
lib/Target/XCore/XCoreISelDAGToDAG.cpp 49 return CurDAG->getTargetConstant(Imm, dl, MVT::i32);
90 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i32);
91 Offset = CurDAG->getTargetConstant(0, SDLoc(Addr), MVT::i32);
100 Base = CurDAG->getTargetFrameIndex(FIN->getIndex(), MVT::i32);
101 Offset = CurDAG->getTargetConstant(CN->getSExtValue(), SDLoc(Addr),
119 Reg = CurDAG->getRegister(XCore::CP, MVT::i32);
122 Reg = CurDAG->getRegister(XCore::DP, MVT::i32);
141 ReplaceNode(N, CurDAG->getMachineNode(XCore::MKMSK_rus, dl,
146 SDValue CPIdx = CurDAG->getTargetConstantPool(
147 ConstantInt::get(Type::getInt32Ty(*CurDAG->getContext()), Val),
148 getTargetLowering()->getPointerTy(CurDAG->getDataLayout()));
149 SDNode *node = CurDAG->getMachineNode(XCore::LDWCP_lru6, dl, MVT::i32,
151 CurDAG->getEntryNode());
155 CurDAG->setNodeMemRefs(cast<MachineSDNode>(node), {MemOp});
164 ReplaceNode(N, CurDAG->getMachineNode(XCore::LADD_l5r, dl, MVT::i32,
171 ReplaceNode(N, CurDAG->getMachineNode(XCore::LSUB_l5r, dl, MVT::i32,
178 ReplaceNode(N, CurDAG->getMachineNode(XCore::MACCU_l4r, dl, MVT::i32,
185 ReplaceNode(N, CurDAG->getMachineNode(XCore::MACCS_l4r, dl, MVT::i32,
192 ReplaceNode(N, CurDAG->getMachineNode(XCore::LMUL_l6r, dl, MVT::i32,
198 ReplaceNode(N, CurDAG->getMachineNode(XCore::CRC8_l4r, dl, MVT::i32,
255 SDValue NewChain = replaceInChain(CurDAG, Chain, CheckEventChainOut,
267 SDValue(CurDAG->getMachineNode(XCore::SETSR_branch_u6, dl, MVT::Glue,
270 SDValue(CurDAG->getMachineNode(XCore::CLRSR_branch_u6, dl, MVT::Glue,
274 CurDAG->SelectNodeTo(N, XCore::BRFU_lu6, MVT::Other,
278 CurDAG->SelectNodeTo(N, XCore::BAU_1r, MVT::Other, nextAddr, Glue);