|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
gen/lib/Target/AArch64/AArch64GenDAGISel.inc115638 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115644 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115651 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115658 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115666 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115673 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115681 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115688 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115696 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115704 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115712 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115720 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115727 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115734 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
115742 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
115750 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
115757 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
115765 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
115775 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
115782 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115788 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115794 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
115800 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
gen/lib/Target/AMDGPU/AMDGPUGenDAGISel.inc78721 return isNegInlineImmediate(Src0.getNode());
78723 return (isNullConstantOrUndef(Src0) && isNegInlineImmediate(Src1.getNode())) ||
78724 (isNullConstantOrUndef(Src1) && isNegInlineImmediate(Src0.getNode()));
79639 !isInlineImmediate(Operands[i].getNode())) {
79786 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79792 SDNode *N = V.getNode();
79798 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79804 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79810 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79816 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79822 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79828 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79834 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79840 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79846 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79853 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
79860 CondCodeSDNode *N = cast<CondCodeSDNode>(V.getNode());
79866 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
79872 FrameIndexSDNode *N = cast<FrameIndexSDNode>(V.getNode());
79879 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
gen/lib/Target/AMDGPU/R600GenDAGISel.inc12620 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
gen/lib/Target/ARM/ARMGenDAGISel.inc55023 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55030 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55037 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55049 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55055 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55062 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55070 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55076 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55084 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55090 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55096 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55104 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55111 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55118 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55125 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55133 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55141 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55147 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55155 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55163 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55171 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55178 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55185 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
55191 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
55199 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
55207 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
gen/lib/Target/AVR/AVRGenDAGISel.inc 1752 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
1758 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
1765 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
1772 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
1778 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
gen/lib/Target/Hexagon/HexagonGenDAGISel.inc72953 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72957 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72964 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72971 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72978 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72985 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72992 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72999 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73006 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73013 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73020 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73027 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73036 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73045 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73056 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73063 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73071 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73078 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73086 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73093 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73100 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73107 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73114 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73121 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73128 ConstantFPSDNode *N = cast<ConstantFPSDNode>(V.getNode());
73136 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73143 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73147 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73153 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73157 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73163 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73172 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
73180 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
gen/lib/Target/Lanai/LanaiGenDAGISel.inc 1549 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
1556 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
1563 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
1569 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
gen/lib/Target/Mips/MipsGenDAGISel.inc30308 SDNode *BV = N->getOperand(0).getNode();
30321 SDNode *BV = N->getOperand(0).getNode();
30621 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30627 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30633 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30637 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30643 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30649 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
gen/lib/Target/NVPTX/NVPTXGenDAGISel.inc72353 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72359 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72365 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72371 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
72379 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
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;
44879 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
44886 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
44893 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
44901 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
44910 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
44919 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
44925 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
44932 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
44939 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
44947 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
44955 SDNode *N = V.getNode();
44961 SDNode *N = V.getNode();
44967 SDNode *N = V.getNode();
44973 SDNode *N = V.getNode();
44979 SDNode *N = V.getNode();
44985 SDNode *N = V.getNode();
44991 SDNode *N = V.getNode();
44997 SDNode *N = V.getNode();
45003 SDNode *N = V.getNode();
gen/lib/Target/RISCV/RISCVGenDAGISel.inc14187 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
14194 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
gen/lib/Target/Sparc/SparcGenDAGISel.inc 3633 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
3640 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
3646 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
3654 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
3661 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
3668 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
3675 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
3682 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
gen/lib/Target/SystemZ/SystemZGenDAGISel.inc30511 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30518 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30525 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30532 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30539 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30546 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30553 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30560 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30567 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30574 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30581 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30588 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30595 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30602 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30609 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30616 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30623 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30630 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
30637 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
gen/lib/Target/X86/X86GenDAGISel.inc254731 SDNode *N = V.getNode();
254737 SDNode *N = V.getNode();
254743 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254750 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254757 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254764 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254771 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254778 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254785 SDNode *N = V.getNode();
254793 SDNode *N = V.getNode();
254802 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254810 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254817 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254824 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254831 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254837 SDNode *N = V.getNode();
254843 SDNode *N = V.getNode();
254849 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254855 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254861 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254875 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254889 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254903 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254919 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254935 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254943 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254950 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254957 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254969 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254981 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
254993 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
255005 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
255017 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
255029 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
255036 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
gen/lib/Target/XCore/XCoreGenDAGISel.inc 2474 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
2482 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
2490 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
2499 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
2507 ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());
include/llvm/CodeGen/SelectionDAG.h 484 assert((!N.getNode() || N.getValueType() == MVT::Other) &&
486 if (N.getNode())
487 checkForCycles(N.getNode(), this);
489 if (N.getNode())
709 makeArrayRef(Ops, Glue.getNode() ? 4 : 3));
718 makeArrayRef(Ops, Glue.getNode() ? 4 : 3));
735 makeArrayRef(Ops, Glue.getNode() ? 3 : 2));
883 if (InGlue.getNode())
1780 ID.AddPointer(Op.getNode());
include/llvm/CodeGen/SelectionDAGISel.h 213 EnforceNodeIdInvariant(T.getNode());
221 EnforceNodeIdInvariant(T[i].getNode());
include/llvm/CodeGen/SelectionDAGNodes.h 227 return ((unsigned)((uintptr_t)Val.getNode() >> 4) ^
228 (unsigned)((uintptr_t)Val.getNode() >> 9)) + Val.getResNo();
242 return Val.getNode();
249 return Val.getNode();
287 SDNode *getNode() const { return Val.getNode(); }
914 SDNode *Op = OpV.getNode();
989 return getOperand(getNumOperands()-1).getNode();
1135 SDLoc(const SDValue V) : SDLoc(V.getNode()) {}
1233 if (Val.getNode()) removeFromList();
1235 if (V.getNode()) V.getNode()->addUse(*this);
1235 if (V.getNode()) V.getNode()->addUse(*this);
1240 V.getNode()->addUse(*this);
1244 if (Val.getNode()) removeFromList();
2536 return Node->getOperand(Operand).getNode();
lib/CodeGen/SelectionDAG/DAGCombiner.cpp 788 AddToWorklist(Op.getNode());
817 !TLI.isConstTrueVal(N.getOperand(2).getNode()) ||
818 !TLI.isConstFalseVal(N.getOperand(3).getNode()))
836 if (isSetCCEquivalent(N, N0, N1, N2) && N.getNode()->hasOneUse())
845 return N.getNode();
846 if (ISD::isBuildVectorOfConstantFPSDNodes(N.getNode()))
847 return N.getNode();
877 ISD::isBuildVectorOfConstantFPSDNodes(V.getNode());
960 if (!OpNode.getNode())
994 To[0].getNode()->dump(&DAG);
997 assert((!To[i].getNode() ||
1006 if (To[i].getNode()) {
1007 AddToWorklist(To[i].getNode());
1008 AddUsersToWorklist(To[i].getNode());
1029 AddToWorklist(TLO.New.getNode());
1030 AddUsersToWorklist(TLO.New.getNode());
1035 if (TLO.Old.getNode()->use_empty())
1036 deleteAndRecombine(TLO.Old.getNode());
1049 AddToWorklist(Op.getNode());
1053 LLVM_DEBUG(dbgs() << "\nReplacing.2 "; TLO.Old.getNode()->dump(&DAG);
1054 dbgs() << "\nWith: "; TLO.New.getNode()->dump(&DAG);
1074 AddToWorklist(Op.getNode());
1078 LLVM_DEBUG(dbgs() << "\nReplacing.2 "; TLO.Old.getNode()->dump(&DAG);
1079 dbgs() << "\nWith: "; TLO.New.getNode()->dump(&DAG);
1092 Trunc.getNode()->dump(&DAG); dbgs() << '\n');
1097 AddToWorklist(Trunc.getNode());
1103 if (ISD::isUNINDEXEDLoad(Op.getNode())) {
1144 if (!NewOp.getNode())
1146 AddToWorklist(NewOp.getNode());
1149 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
1149 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
1159 if (!NewOp.getNode())
1161 AddToWorklist(NewOp.getNode());
1164 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
1164 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
1191 LLVM_DEBUG(dbgs() << "\nPromoting "; Op.getNode()->dump(&DAG));
1211 CombineTo(Op.getNode(), RV);
1215 if (Replace0 && Replace1 && N0.getNode()->isPredecessorOf(N1.getNode())) {
1215 if (Replace0 && Replace1 && N0.getNode()->isPredecessorOf(N1.getNode())) {
1221 AddToWorklist(NN0.getNode());
1222 ReplaceLoadWithPromotedLoad(N0.getNode(), NN0.getNode());
1222 ReplaceLoadWithPromotedLoad(N0.getNode(), NN0.getNode());
1225 AddToWorklist(NN1.getNode());
1226 ReplaceLoadWithPromotedLoad(N1.getNode(), NN1.getNode());
1226 ReplaceLoadWithPromotedLoad(N1.getNode(), NN1.getNode());
1256 LLVM_DEBUG(dbgs() << "\nPromoting "; Op.getNode()->dump(&DAG));
1268 if (!N0.getNode())
1276 ReplaceLoadWithPromotedLoad(Op.getOperand(0).getNode(), N0.getNode());
1276 ReplaceLoadWithPromotedLoad(Op.getOperand(0).getNode(), N0.getNode());
1307 LLVM_DEBUG(dbgs() << "\nPromoting "; Op.getNode()->dump(&DAG));
1317 if (!ISD::isUNINDEXEDLoad(Op.getNode()))
1337 SDNode *N = Op.getNode();
1348 Result.getNode()->dump(&DAG); dbgs() << '\n');
1353 AddToWorklist(Result.getNode());
1378 Nodes.insert(ChildN.getNode());
1441 if (!CombinedNodes.count(ChildN.getNode()))
1442 AddToWorklist(ChildN.getNode());
1446 if (!RV.getNode())
1455 if (RV.getNode() == N)
1462 LLVM_DEBUG(dbgs() << " ... into: "; RV.getNode()->dump(&DAG));
1464 if (N->getNumValues() == RV.getNode()->getNumValues())
1465 DAG.ReplaceAllUsesWith(N, RV.getNode());
1473 AddToWorklist(RV.getNode());
1474 AddUsersToWorklist(RV.getNode());
1626 if (!RV.getNode()) {
1642 if (!RV.getNode()) {
1672 if (!RV.getNode() && TLI.isCommutativeBinOp(N->getOpcode()) &&
1709 if (getInputChainForNode(N->getOperand(0).getNode()) == N->getOperand(1))
1711 if (getInputChainForNode(N->getOperand(1).getNode()) == N->getOperand(0))
1759 if (Op.hasOneUse() && !is_contained(TFs, Op.getNode())) {
1761 TFs.push_back(Op.getNode());
1769 if (SeenOps.insert(Op.getNode()).second)
1797 Worklist.push_back(std::make_pair(Op.getNode(), NumLeftToConsider++));
1808 while (OrigOpNumber < Ops.size() && Ops[OrigOpNumber].getNode() != Op)
1847 AddToWorklist(i, Op.getNode(), CurOpNumber);
1853 AddToWorklist(i, CurNode->getOperand(0).getNode(), CurOpNumber);
1857 AddToWorklist(i, MemNode->getChain().getNode(), CurOpNumber);
1876 if (SeenChains.count(Op.getNode()) == 0)
2086 if (ISD::isBuildVectorAllZeros(N1.getNode()))
2088 if (ISD::isBuildVectorAllZeros(N0.getNode()))
2104 return DAG.FoldConstantArithmetic(ISD::ADD, DL, VT, N0.getNode(),
2105 N1.getNode());
2116 SDValue Sub = DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, N1.getNode(),
2117 N0.getOperand(1).getNode());
2125 SDValue Add = DAG.FoldConstantArithmetic(ISD::ADD, DL, VT, N1.getNode(),
2126 N0.getOperand(0).getNode());
2327 if (ISD::isBuildVectorAllZeros(N1.getNode()))
2329 if (ISD::isBuildVectorAllZeros(N0.getNode()))
2342 return DAG.FoldConstantArithmetic(Opcode, DL, VT, N0.getNode(),
2343 N1.getNode());
2385 EVT VT = V.getNode()->getValueType(0);
2701 AddToWorklist(CarryExt.getNode());
2768 Combiner.AddToWorklist(NewY.getNode());
2865 if (ISD::isBuildVectorAllZeros(N1.getNode()))
2876 return DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, N0.getNode(),
2877 N1.getNode());
2946 ISD::SUB, DL, VT, N0.getOperand(1).getNode(), N1.getNode());
2946 ISD::SUB, DL, VT, N0.getOperand(1).getNode(), N1.getNode());
2956 SDValue NewC = DAG.FoldConstantArithmetic(ISD::SUB, DL, VT, N0.getNode(),
2957 N11.getNode());
2968 ISD::ADD, DL, VT, N0.getOperand(1).getNode(), N1.getNode());
2968 ISD::ADD, DL, VT, N0.getOperand(1).getNode(), N1.getNode());
2978 ISD::SUB, DL, VT, N0.getOperand(0).getNode(), N1.getNode());
2978 ISD::SUB, DL, VT, N0.getOperand(0).getNode(), N1.getNode());
3173 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3188 return DAG.FoldConstantArithmetic(N->getOpcode(), DL, VT, N0.getNode(),
3189 N1.getNode());
3336 N0IsConst = ISD::isConstantSplatVector(N0.getNode(), ConstValue0);
3337 N1IsConst = ISD::isConstantSplatVector(N1.getNode(), ConstValue1);
3360 N0.getNode(), N1.getNode());
3360 N0.getNode(), N1.getNode());
3455 N0.getNode()->hasOneUse()) {
3459 N1.getNode()->hasOneUse()) {
3463 if (Sh.getNode()) {
3544 for (SDNode::use_iterator UI = Op0.getNode()->use_begin(),
3545 UE = Op0.getNode()->use_end(); UI != UE; ++UI) {
3668 AddToWorklist(Mul.getNode());
3669 AddToWorklist(Sub.getNode());
3725 AddToWorklist(Sign.getNode());
3729 AddToWorklist(Srl.getNode());
3731 AddToWorklist(Add.getNode());
3733 AddToWorklist(Sra.getNode());
3806 AddToWorklist(Mul.getNode());
3807 AddToWorklist(Sub.getNode());
3832 AddToWorklist(LogBase2.getNode());
3836 AddToWorklist(Trunc.getNode());
3846 AddToWorklist(LogBase2.getNode());
3850 AddToWorklist(Trunc.getNode());
3852 AddToWorklist(Add.getNode());
3905 AddToWorklist(Add.getNode());
3912 AddToWorklist(Add.getNode());
3929 if (OptimizedDiv.getNode()) {
3937 AddToWorklist(OptimizedDiv.getNode());
3938 AddToWorklist(Mul.getNode());
3959 if (ISD::isBuildVectorAllZeros(N0.getNode()) ||
3960 ISD::isBuildVectorAllZeros(N1.getNode()))
4006 if (ISD::isBuildVectorAllZeros(N0.getNode()) ||
4007 ISD::isBuildVectorAllZeros(N1.getNode()))
4081 AddToWorklist(Lo.getNode());
4082 SDValue LoOpt = combine(Lo.getNode());
4083 if (LoOpt.getNode() && LoOpt.getNode() != Lo.getNode() &&
4083 if (LoOpt.getNode() && LoOpt.getNode() != Lo.getNode() &&
4083 if (LoOpt.getNode() && LoOpt.getNode() != Lo.getNode() &&
4091 AddToWorklist(Hi.getNode());
4092 SDValue HiOpt = combine(Hi.getNode());
4093 if (HiOpt.getNode() && HiOpt != Hi &&
4388 if (N0.getOperand(1) == N1.getOperand(1) && ShOp.getNode()) {
4401 if (N0.getOperand(0) == N1.getOperand(0) && ShOp.getNode()) {
4458 AddToWorklist(Or.getNode());
4477 AddToWorklist(And.getNode());
4491 AddToWorklist(Add.getNode());
4595 CombineTo(N0.getNode(), NewAdd);
4829 if (!SearchForAndLoads(Op.getNode(), Loads, NodesWithConsts, Mask,
4840 NodeToMask = Op.getNode();
4890 DAG.UpdateNodeOperands(And.getNode(), SDValue(FixupNode, 0), MaskOp);
4915 DAG.UpdateNodeOperands(And.getNode(), SDValue(Load, 0), MaskOp), 0);
4916 SDValue NewLoad = ReduceLoadWidth(And.getNode());
4921 DAG.ReplaceAllUsesWith(N, N->getOperand(0).getNode());
5049 if (ISD::isBuildVectorAllZeros(N0.getNode()))
5053 if (ISD::isBuildVectorAllZeros(N1.getNode()))
5059 if (ISD::isBuildVectorAllOnes(N0.getNode()))
5061 if (ISD::isBuildVectorAllOnes(N1.getNode()))
5117 CombineTo(N0.getNode(), Zext);
5203 CombineTo(N, (N0.getNode() == Load) ? NewLoad : N0);
5285 if (ISD::isUNINDEXEDLoad(N0.getNode()) &&
5286 (ISD::isEXTLoad(N0.getNode()) ||
5287 (ISD::isSEXTLoad(N0.getNode()) && N0.hasOneUse()))) {
5302 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
5309 if (SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
5344 if (!N0.getNode()->hasOneUse())
5357 if (!N1.getNode()->hasOneUse())
5370 if (!N0.getNode()->hasOneUse() || !N1.getNode()->hasOneUse())
5370 if (!N0.getNode()->hasOneUse() || !N1.getNode()->hasOneUse())
5383 if (!N00.getNode()->hasOneUse())
5394 if (!N10.getNode()->hasOneUse())
5444 if (!N.getNode()->hasOneUse())
5523 Parts[MaskByteOffset] = N0.getOperand(0).getNode();
5537 Parts[0] = Parts[1] = N.getOperand(0).getOperand(0).getNode();
5618 (N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
5618 (N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
5646 (N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
5646 (N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
5687 if (ISD::isBuildVectorAllZeros(N0.getNode()))
5689 if (ISD::isBuildVectorAllZeros(N1.getNode()))
5693 if (ISD::isBuildVectorAllOnes(N0.getNode()))
5696 if (ISD::isBuildVectorAllOnes(N1.getNode()))
5706 bool ZeroN00 = ISD::isBuildVectorAllZeros(N0.getOperand(0).getNode());
5707 bool ZeroN01 = ISD::isBuildVectorAllZeros(N0.getOperand(1).getNode());
5708 bool ZeroN10 = ISD::isBuildVectorAllZeros(N1.getOperand(0).getNode());
5709 bool ZeroN11 = ISD::isBuildVectorAllZeros(N1.getOperand(1).getNode());
5805 if (N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() &&
5808 ISD::OR, SDLoc(N1), VT, N1.getNode(), N0.getOperand(1).getNode())) {
5808 ISD::OR, SDLoc(N1), VT, N1.getNode(), N0.getOperand(1).getNode())) {
5810 AddToWorklist(IOR.getNode());
6225 if (LHSMask.getNode() || RHSMask.getNode()) {
6225 if (LHSMask.getNode() || RHSMask.getNode()) {
6229 if (LHSMask.getNode()) {
6234 if (RHSMask.getNode()) {
6248 if (LHSMask.getNode() || RHSMask.getNode())
6248 if (LHSMask.getNode() || RHSMask.getNode())
6390 auto L = cast<LoadSDNode>(Op.getNode());
6614 DAG.ReplaceAllUsesWith(N, NewStore.getNode());
6769 DAG.ReplaceAllUsesOfValueWith(SDValue(L, 1), SDValue(NewLoad.getNode(), 1));
6829 if (isa<ConstantSDNode>(M.getNode()))
6867 if (ISD::isBuildVectorAllZeros(N0.getNode()))
6869 if (ISD::isBuildVectorAllZeros(N1.getNode()))
6905 if (TLI.isConstTrueVal(N1.getNode()) && isSetCCEquivalent(N0, LHS, RHS, CC)) {
6929 AddToWorklist(V.getNode());
6941 AddToWorklist(N00.getNode()); AddToWorklist(N01.getNode());
6941 AddToWorklist(N00.getNode()); AddToWorklist(N01.getNode());
6953 AddToWorklist(N00.getNode()); AddToWorklist(N01.getNode());
6953 AddToWorklist(N00.getNode()); AddToWorklist(N01.getNode());
6971 AddToWorklist(NotX.getNode());
7214 AddToWorklist(Trunc00.getNode());
7215 AddToWorklist(Trunc01.getNode());
7254 if (SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode()))
7271 ISD::SREM, dl, ShiftVT, CombinedShift.getNode(),
7272 BitsizeC.getNode());
7335 if (SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode()))
7436 AddToWorklist(NewSHL.getNode());
7504 N0.getNode()->hasOneUse() &&
7510 AddToWorklist(Shl0.getNode());
7511 AddToWorklist(Shl1.getNode());
7516 if (N0.getOpcode() == ISD::MUL && N0.getNode()->hasOneUse() &&
7678 if (SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode()))
7810 AddToWorklist(Mask.getNode());
7830 AddToWorklist(SmallShift.getNode());
7874 AddToWorklist(Op.getNode());
7886 if (SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode()))
8346 AddToWorklist(NOTNode.getNode());
8352 AddToWorklist(NOTNode.getNode());
8387 recursivelyDeleteUnusedNodes(InnerSelect.getNode());
8400 recursivelyDeleteUnusedNodes(InnerSelect.getNode());
8497 Flags = N0.getNode()->getFlags();
8540 else if (Cond->getOperand(i).getNode() != BottomHalf)
8552 else if (Cond->getOperand(i).getNode() != TopHalf)
8572 if (ISD::isBuildVectorAllZeros(Mask.getNode()))
8585 if (ISD::isBuildVectorAllZeros(Mask.getNode()))
8597 if (ISD::isBuildVectorAllZeros(Mask.getNode()))
8609 if (ISD::isBuildVectorAllZeros(Mask.getNode()))
8624 !ISD::isBuildVectorOfConstantSDNodes(N1.getNode()) ||
8625 !ISD::isBuildVectorOfConstantSDNodes(N2.getNode()))
8661 if (ISD::isConstantSplatVector(N1.getNode(), Pow2C) && Pow2C.isPowerOf2() &&
8701 bool RHSIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
8704 (ISD::isBuildVectorAllOnes(RHS.getNode()) && CC == ISD::SETGT)) &&
8706 isAbs = ISD::isBuildVectorAllZeros(N2.getOperand(0).getNode());
8709 isAbs = ISD::isBuildVectorAllZeros(N1.getOperand(0).getNode());
8719 AddToWorklist(Shift.getNode());
8720 AddToWorklist(Add.getNode());
8771 if (ISD::isBuildVectorAllOnes(N0.getNode()))
8774 if (ISD::isBuildVectorAllZeros(N0.getNode()))
8782 ISD::isBuildVectorOfConstantSDNodes(N0.getNode())) {
8808 AddToWorklist(SCC.getNode());
8810 if (ConstantSDNode *SCCC = dyn_cast<ConstantSDNode>(SCC.getNode())) {
8857 if (NewSetCC.getNode() == N)
8935 ISD::isBuildVectorOfConstantSDNodes(N0.getNode())))
8979 for (SDNode::use_iterator UI = N0.getNode()->use_begin(),
8980 UE = N0.getNode()->use_end();
9141 AddToWorklist(NewChain.getNode());
9150 CombineTo(N0.getNode(), Trunc, NewChain);
9197 if (!ExtendUsesToFormExtLoad(VT, N1.getNode(), N1.getOperand(0),
9227 recursivelyDeleteUnusedNodes(N0.getNode());
9283 SDNode *N0Node = N0.getNode();
9315 if (!ISD::isNON_EXTLoad(N0.getNode()) ||
9316 !ISD::isUNINDEXEDLoad(N0.getNode()) ||
9375 DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), SDValue(NewLoad.getNode(), 1));
9426 if (SDValue NarrowLoad = ReduceLoadWidth(N0.getNode())) {
9427 SDNode *oye = N0.getOperand(0).getNode();
9428 if (NarrowLoad.getNode() != N0.getNode()) {
9428 if (NarrowLoad.getNode() != N0.getNode()) {
9429 CombineTo(N0.getNode(), NarrowLoad);
9506 bool DoXform = ExtendUsesToFormExtLoad(VT, N0.getNode(), N0.getOperand(0),
9525 CombineTo(N0.getNode(), TruncAnd);
9733 if (SDValue NarrowLoad = ReduceLoadWidth(N0.getNode())) {
9734 SDNode *oye = N0.getOperand(0).getNode();
9735 if (NarrowLoad.getNode() != N0.getNode()) {
9735 if (NarrowLoad.getNode() != N0.getNode()) {
9736 CombineTo(N0.getNode(), NarrowLoad);
9753 AddToWorklist(Op.getNode());
9763 AddToWorklist(Op.getNode());
9830 DoXform = ExtendUsesToFormExtLoad(VT, N0.getNode(), N0.getOperand(0),
9850 CombineTo(N0.getNode(), TruncAnd);
9973 if (SDValue NarrowLoad = ReduceLoadWidth(N0.getNode())) {
9974 SDNode *oye = N0.getOperand(0).getNode();
9975 if (NarrowLoad.getNode() != N0.getNode()) {
9975 if (NarrowLoad.getNode() != N0.getNode()) {
9976 CombineTo(N0.getNode(), NarrowLoad);
10008 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
10009 ISD::isUNINDEXEDLoad(N0.getNode()) &&
10041 if (N0.getOpcode() == ISD::LOAD && !ISD::isNON_EXTLoad(N0.getNode()) &&
10042 ISD::isUNINDEXEDLoad(N0.getNode()) && N0.hasOneUse()) {
10318 AddToWorklist(NewPtr.getNode());
10462 if (ISD::isEXTLoad(N0.getNode()) &&
10463 ISD::isUNINDEXEDLoad(N0.getNode()) &&
10474 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
10475 AddToWorklist(ExtLoad.getNode());
10479 if (ISD::isZEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
10479 if (ISD::isZEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
10490 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
10496 if (SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
10554 if (C.getNode() != N)
10638 AddToWorklist(Amt.getNode());
10707 if (N0.hasOneUse() && ISD::isUNINDEXEDLoad(N0.getNode())) {
10748 assert(V.getNode() && "The single defined operand is empty!");
10756 AddToWorklist(NV.getNode());
10791 N0.hasOneUse() && !N0.getNode()->hasAnyUseOfValue(1) &&
10853 return Elt.getNode();
10854 return Elt.getOperand(Elt.getResNo()).getNode();
10967 N0.getOpcode() == ISD::BUILD_VECTOR && N0.getNode()->hasOneUse() &&
10969 return ConstantFoldBITCASTofBUILD_VECTOR(N0.getNode(),
10983 if (C.getNode() != N)
10994 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
11035 N0.getNode()->hasOneUse() && VT.isInteger() &&
11038 AddToWorklist(NewConv.getNode());
11048 AddToWorklist(FlipBit.getNode());
11055 AddToWorklist(Hi.getNode());
11057 AddToWorklist(FlipBit.getNode());
11061 AddToWorklist(FlipBits.getNode());
11084 if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse() &&
11091 AddToWorklist(X.getNode());
11097 AddToWorklist(X.getNode());
11106 AddToWorklist(X.getNode());
11108 AddToWorklist(X.getNode());
11114 AddToWorklist(Cst.getNode());
11116 AddToWorklist(X.getNode());
11118 AddToWorklist(XorResult.getNode());
11123 AddToWorklist(XorResult64.getNode());
11127 AddToWorklist(FlipBit.getNode());
11130 AddToWorklist(FlipBits.getNode());
11136 AddToWorklist(X.getNode());
11141 AddToWorklist(Cst.getNode());
11149 if (SDValue CombineLD = CombineConsecutiveLoads(N0.getNode(), VT))
11168 if (Op.isUndef() || ISD::isBuildVectorOfConstantSDNodes(Op.getNode()) ||
11169 ISD::isBuildVectorOfConstantFPSDNodes(Op.getNode()))
11225 AddToWorklist(Ops.back().getNode());
11239 BV = ConstantFoldBITCASTofBUILD_VECTOR(BV, IntVT).getNode();
11247 SDNode *Tmp = ConstantFoldBITCASTofBUILD_VECTOR(BV, TmpVT).getNode();
11365 return AllowFusionGlobally || isContractable(N.getNode());
11370 if (N0.getNode()->use_size() > N1.getNode()->use_size())
11370 if (N0.getNode()->use_size() > N1.getNode()->use_size())
11577 return AllowFusionGlobally || isContractable(N.getNode());
12092 AddToWorklist(Fused.getNode());
12168 AddToWorklist(Fused.getNode());
12317 AddToWorklist(Fused.getNode());
12403 AddToWorklist(RHSNeg.getNode());
12504 } else if (U != Reciprocal.getNode()) {
12568 AddToWorklist(RV.getNode());
12576 AddToWorklist(RV.getNode());
12591 if (SqrtOp.getNode()) {
12596 AddToWorklist(RV.getNode());
13044 if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse()) {
13047 AddToWorklist(Tmp.getNode());
13089 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
13097 CombineTo(N0.getNode(),
13173 N0.getNode()->hasOneUse()) {
13190 AddToWorklist(Int.getNode());
13197 (N0.getNode()->hasOneUse() || !TLI.isFNegFree(VT))) {
13288 AddToWorklist(Int.getNode());
13381 SDValue Tmp = visitXOR(N.getNode());
13383 if (!Tmp.getNode())
13387 if (Tmp.getNode() == N.getNode())
13387 if (Tmp.getNode() == N.getNode())
13396 SDNode *TheXor = N.getNode();
13405 TheXor = Op0.getNode();
13437 if (Simp.getNode()) AddToWorklist(Simp.getNode());
13437 if (Simp.getNode()) AddToWorklist(Simp.getNode());
13440 if (Simp.getNode() && Simp.getOpcode() == ISD::SETCC)
13458 if (LD->isIndexed() || LD->getBasePtr().getNode() != N)
13463 if (ST->isIndexed() || ST->getBasePtr().getNode() != N)
13532 Ptr.getNode()->hasOneUse())
13577 if (Val == Ptr || Ptr->isPredecessorOf(Val.getNode()))
13591 for (SDNode::use_iterator UI = BasePtr.getNode()->use_begin(),
13592 UE = BasePtr.getNode()->use_end();
13597 if (Use.getUser() == Ptr.getNode() || Use != BasePtr)
13630 for (SDNode *Use : Ptr.getNode()->uses()) {
13638 if (!canFoldInAddressingMode(Ptr.getNode(), Use, DAG, TLI))
13655 Result.getNode()->dump(&DAG); dbgs() << '\n');
13673 if (OtherUses[i]->getOperand(OffsetIdx).getNode() == BasePtr.getNode())
13673 if (OtherUses[i]->getOperand(OffsetIdx).getNode() == BasePtr.getNode())
13675 assert(OtherUses[i]->getOperand(!OffsetIdx).getNode() ==
13676 BasePtr.getNode() && "Expected BasePtr operand");
13722 deleteAndRecombine(Ptr.getNode());
13723 AddToWorklist(Result.getNode());
13760 if (Ptr.getNode()->hasOneUse())
13763 for (SDNode *Op : Ptr.getNode()->uses()) {
13788 for (SDNode *Use : BasePtr.getNode()->uses()) {
13789 if (Use == Ptr.getNode())
13815 Visited.insert(Ptr.getNode());
13828 dbgs() << "\nWith: "; Result.getNode()->dump(&DAG);
13936 StoreSDNode *ST = dyn_cast<StoreSDNode>(Chain.getNode());
14025 deleteAndRecombine(Val.getNode());
14049 dbgs() << "\nWith chain: "; Chain.getNode()->dump(&DAG);
14053 AddUsersToWorklist(Chain.getNode());
14082 dbgs() << "\nWith: "; Undef.getNode()->dump(&DAG);
14108 assert(NewLoad.getNode() == N);
14696 AddToWorklist(Chain.getNode());
14710 !ISD::isNormalLoad(V->getOperand(0).getNode()))
14755 if (LD == Chain.getNode())
14760 if (!LD->isOperandOf(Chain.getNode()))
14879 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
14880 Chain == SDValue(N0.getNode(), 1)) {
14947 AddToWorklist(NewPtr.getNode());
14948 AddToWorklist(NewLD.getNode());
14949 AddToWorklist(NewVal.getNode());
14966 if (ISD::isNormalStore(ST) && ISD::isNormalLoad(Value.getNode()) &&
15000 AddToWorklist(NewLD.getNode());
15001 AddToWorklist(NewST.getNode());
15030 if (AddNode.getNode()->hasOneUse())
15040 SDNode *MulVar = AddNode.getOperand(0).getNode();
15044 OtherOp = Use->getOperand(1).getNode();
15046 OtherOp = Use->getOperand(0).getNode();
15076 OtherOp->getOperand(0).getNode() == MulVar)
15097 if (Visited.insert(StoreNodes[i].MemNode->getChain().getNode()).second)
15258 AddToWorklist(NewChain.getNode());
15272 if (!BasePtr.getBase().getNode())
15386 RootNode = St->getChain().getNode();
15390 RootNode = Ldn->getChain().getNode();
15443 Worklist.push_back(Op.getNode());
15464 Worklist.push_back(N->getOperand(j).getNode());
15786 if (LdBasePtr.getBase().getNode()) {
15959 AddToWorklist(NewStoreChain.getNode());
15998 SDValue(NewLoad.getNode(), 1));
16006 if (Val.getNode()->use_empty())
16007 recursivelyDeleteUnusedNodes(Val.getNode());
16038 AddToWorklist(Token.getNode());
16163 assert(NewStore.getNode() == N);
16201 AddToWorklist(Value.getNode());
16292 && Value.getNode()->hasOneUse() && ST->isUnindexed() &&
16360 if (!isAlias(Chain.getNode(), N))
16506 ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Vec.getNode());
16584 AddToWorklist(PaddedSubV.getNode());
16585 AddToWorklist(DestVecBC.getNode());
16586 AddToWorklist(Shuf.getNode());
16635 AddToWorklist(NewOp.getNode());
16636 return DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(InVec.getNode()),
16652 Ops.append(InVec.getNode()->op_begin(),
16653 InVec.getNode()->op_end());
16753 AddUsersToWorklist(Load.getNode()); // Add users too
16754 AddToWorklist(Load.getNode());
16768 Vec.getNode()->getNumValues() != 1)
16981 ISD::isNormalLoad(VecOp.getNode()) &&
16982 !Index->hasPredecessor(VecOp.getNode())) {
16998 if (ISD::isNormalLoad(VecOp.getNode())) {
17002 ISD::isNormalLoad(VecOp.getOperand(0).getNode())) {
17034 if (ISD::isNormalLoad(VecOp.getNode())) {
17161 AddToWorklist(BV.getNode());
17175 EVT InVT2 = VecIn2.getNode() ? VecIn2.getValueType() : InVT1;
17201 if (!VecIn2.getNode()) {
17272 VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(InVT1);
17987 if (SingleSource.getNode()) {
18011 if (SingleSource.getNode())
18039 if (!TLI.isBinOp(BinOpcode) || BinOp.getNode()->getNumValues() != 1)
18087 if (!TLI.isBinOp(BOpcode) || BinOp.getNode()->getNumValues() != 1)
18136 BinOp.getNode()->getFlags());
18508 if (N0AnyConst && !N1AnyConst && !ISD::isBuildVectorAllZeros(N0.getNode()))
18510 if (!N0AnyConst && N1AnyConst && !ISD::isBuildVectorAllZeros(N1.getNode()))
18902 TLI.isBinOp(N0.getOpcode()) && N0.getNode()->getNumValues() == 1) {
18912 N0.getNode()->getFlags());
18921 SDNode *V = N0.getNode();
18926 V = ConvInput.getNode();
18941 if (!Base.getNode())
19091 if (N0.getOpcode() == ISD::VECTOR_SHUFFLE && N->isOnlyUserOf(N0.getNode()) &&
19144 if (!SV0.getNode() || SV0 == CurrentVec) {
19153 if (SV1.getNode() && SV1 != CurrentVec)
19170 if (!SV0.getNode())
19172 if (!SV1.getNode())
19361 AddToWorklist(NewOp.getNode());
19362 return DAG.getNode(ISD::INSERT_SUBVECTOR, SDLoc(N0.getNode()),
19647 ISD::isBuildVectorOfConstantSDNodes(Op.getNode());
19690 if (SCC.getNode()) {
19694 const SDNodeFlags Flags = N0.getNode()->getFlags();
19699 AddToWorklist(SETCC.getNode());
19827 SDNode *CondNode = TheSelect->getOperand(0).getNode();
19847 SDNode *CondLHS = TheSelect->getOperand(0).getNode();
19848 SDNode *CondRHS = TheSelect->getOperand(1).getNode();
19895 CombineTo(LHS.getNode(), Load.getValue(0), Load.getValue(1));
19896 CombineTo(RHS.getNode(), Load.getValue(0), Load.getValue(1));
19937 auto *N2C = dyn_cast<ConstantSDNode>(N2.getNode());
19942 AddToWorklist(Shift.getNode());
19946 AddToWorklist(Shift.getNode());
19957 AddToWorklist(Shift.getNode());
19961 AddToWorklist(Shift.getNode());
20017 AddToWorklist(Cond.getNode());
20019 AddToWorklist(CstOffset.getNode());
20021 AddToWorklist(CPIdx.getNode());
20038 auto *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
20039 auto *N2C = dyn_cast<ConstantSDNode>(N2.getNode());
20040 auto *N3C = dyn_cast<ConstantSDNode>(N3.getNode());
20044 AddToWorklist(SCC.getNode());
20125 AddToWorklist(SCC.getNode());
20126 AddToWorklist(Temp.getNode());
20285 AddToWorklist(Est.getNode());
20298 AddToWorklist(MulEst.getNode());
20302 AddToWorklist(NewEst.getNode());
20306 AddToWorklist(NewEst.getNode());
20309 AddToWorklist(NewEst.getNode());
20312 AddToWorklist(Est.getNode());
20317 AddToWorklist(Est.getNode());
20428 AddToWorklist(Est.getNode());
20516 if (MUC0.BasePtr.getNode() && MUC0.BasePtr == MUC1.BasePtr &&
20628 bool IsOpLoad = isa<LoadSDNode>(C.getNode()) &&
20629 cast<LSBaseSDNode>(C.getNode())->isSimple();
20630 if ((IsLoad && IsOpLoad) || !isAlias(N, C.getNode())) {
20648 if (!isAlias(N, C.getNode())) {
20667 if (!Visited.insert(Chain.getNode()).second)
20699 if (Chain.getNode())
20770 if (!BasePtr.getBase().getNode())
20854 AddToWorklist(TF.getNode());
20856 AddToWorklist(Op.getNode());
20868 if (!BasePtr.getBase().getNode())
lib/CodeGen/SelectionDAG/InstrEmitter.cpp 114 User->getOperand(2).getNode() == Node &&
125 if (Op.getNode() != Node || Op.getResNo() != ResNo)
229 User->getOperand(2).getNode() == Node &&
274 Op.getSimpleValueType(), Op.getNode()->isDivergent());
323 BuildMI(*MBB, InsertPos, Op.getNode()->getDebugLoc(),
341 Op.getNode()->getOpcode() != ISD::CopyFromReg &&
384 Op.getNode()->isDivergent() ||
390 BuildMI(*MBB, InsertPos, Op.getNode()->getDebugLoc(),
485 User->getOperand(2).getNode() == Node) {
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp 225 UpdatedNodes->insert(New.getNode());
226 ReplacedNode(Old.getNode());
237 UpdatedNodes->insert(New[i].getNode());
248 UpdatedNodes->insert(New.getNode());
249 ReplacedNode(Old.getNode());
380 int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
494 if (SDNode *OptStore = OptimizeFloatStore(ST).getNode()) {
708 if (RChain.getNode() != Node) {
709 assert(RVal.getNode() != Node && "Load must be completely replaced");
713 UpdatedNodes->insert(RVal.getNode());
714 UpdatedNodes->insert(RChain.getNode());
950 if (Chain.getNode() != Node) {
951 assert(Value.getNode() != Node && "Load must be completely replaced");
955 UpdatedNodes->insert(Value.getNode());
956 UpdatedNodes->insert(Chain.getNode());
1103 ReplaceNode(Node, NewVal.getNode());
1104 LegalizeOp(NewVal.getNode());
1227 if (!(Res.getNode() != Node || Res.getResNo() != 0))
1293 Visited.insert(Op.getNode());
1294 Worklist.push_back(Idx.getNode());
1296 for (SDNode::use_iterator UI = Vec.getNode()->use_begin(),
1297 UE = Vec.getNode()->use_end(); UI != UE; ++UI) {
1315 ST->hasPredecessor(Op.getNode()))
1326 if (!Ch.getNode()) {
1346 DAG.ReplaceAllUsesOfValueWith(Ch, SDValue(NewLoad.getNode(), 1));
1354 SDValue(DAG.UpdateNodeOperands(NewLoad.getNode(), NewLoadOperands), 0);
1369 int FI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
1395 int FI = cast<FrameIndexSDNode>(FIPtr.getNode())->getIndex();
1457 int FI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
1920 if (!Value1.getNode()) {
1922 } else if (!Value2.getNode()) {
1930 if (!Value1.getNode())
1991 if (Value2.getNode())
2070 if (!CallInfo.second.getNode()) {
2266 for (SDNode::use_iterator UI = Op0.getNode()->use_begin(),
2267 UE = Op0.getNode()->use_end(); UI != UE; ++UI) {
2447 LegalizeOp(Load.getNode());
2824 ReplaceNode(Node, Tmp1.getNode());
2844 ReplaceNode(Node, Tmp1.getNode());
2902 ReplaceNode(Node, Tmp1.getNode());
3516 if (Tmp3.getNode())
3611 if (CC.getNode()) {
3640 if (Tmp4.getNode()) {
4216 UpdatedNodes->insert(Tmp2.getNode());
4217 UpdatedNodes->insert(Chain.getNode());
4610 if (N->use_empty() && N != getRoot().getNode()) {
4620 if (N->use_empty() && N != getRoot().getNode()) {
lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp 109 if (R.getNode()) {
110 assert(R.getNode() != N);
514 AddToWorklist(Op.getNode());
734 if (N != NewL.getValue(1).getNode())
784 if (N != NewVAARG.getValue(1).getNode())
856 if (!Res.getNode()) return false;
860 if (Res.getNode() == N)
926 if (!NewRHS.getNode()) {
982 if (!NewRHS.getNode()) {
1005 if (!NewRHS.getNode()) {
1175 if (Lo.getNode())
1662 if (!Res.getNode()) return false;
1666 if (Res.getNode() == N)
1715 if (!NewRHS.getNode()) {
1775 if (!NewRHS.getNode()) {
1792 if (!NewRHS.getNode()) {
1927 if (R.getNode())
2101 if (R.getNode())
2310 TrueVal.getNode()->getValueType(0), N->getOperand(0),
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp 199 if (Res.getNode())
1023 return SDValue(Res.getNode(), 0);
1077 SDValue(Mul.getNode(), 1));
1227 if (!Res.getNode()) return false;
1231 if (Res.getNode() == N)
1808 if (Lo.getNode())
3628 if (!Res.getNode()) return false;
3632 if (Res.getNode() == N)
3709 if (!LoCmp.getNode())
3716 if (!HiCmp.getNode())
3721 ConstantSDNode *LoCmpC = dyn_cast<ConstantSDNode>(LoCmp.getNode());
3722 ConstantSDNode *HiCmpC = dyn_cast<ConstantSDNode>(HiCmp.getNode());
3783 if (!NewLHS.getNode())
3797 if (!NewRHS.getNode()) {
3815 if (!NewRHS.getNode()) {
3832 if (!NewRHS.getNode()) {
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp 108 assert(NewVal.getNode()->getNodeId() != NewNode &&
289 if (IgnoreNodeResults(N->getOperand(i).getNode()))
443 if (!IgnoreNodeResults(Node.getOperand(i).getNode()) &&
500 if (Op.getNode()->getNodeId() == Processed)
545 Val.setNode(AnalyzeNewNode(Val.getNode()));
546 if (Val.getNode()->getNodeId() == Processed)
623 assert(From.getNode() != To.getNode() && "Potential legalization loop!");
623 assert(From.getNode() != To.getNode() && "Potential legalization loop!");
800 assert(Lo.getNode() && "Operand isn't split");
lib/CodeGen/SelectionDAG/LegalizeTypes.h 137 assert(V.getNode() && "Getting TableId on SDValue()");
252 assert(PromotedOp.getNode() && "Operand wasn't promoted?");
482 assert(SoftenedOp.getNode() && "Unconverted op in SoftenedFloats?");
620 assert(PromotedOp.getNode() && "Operand wasn't promoted?");
661 assert(ScalarizedOp.getNode() && "Operand wasn't scalarized?");
787 assert(WidenedOp.getNode() && "Operand wasn't widened?");
lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp 160 int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
534 SplitVecRes_SETCC(Cond.getNode(), CL, CH);
lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp 224 for (unsigned i = 0, e = Op.getNode()->getNumValues(); i != e; ++i)
235 SDNode* Node = Op.getNode();
242 SDValue Result = SDValue(DAG.UpdateNodeOperands(Op.getNode(), Ops),
246 LoadSDNode *LD = cast<LoadSDNode>(Op.getNode());
274 StoreSDNode *ST = cast<StoreSDNode>(Op.getNode());
540 assert(Op.getNode()->getNumValues() == 1 &&
560 Op = DAG.getNode(Op.getOpcode(), dl, NVT, Operands, Op.getNode()->getFlags());
623 LoadSDNode *LD = cast<LoadSDNode>(Op.getNode());
744 Value = DAG.getBuildVector(Op.getNode()->getValueType(0), dl, Vals);
764 StoreSDNode *ST = cast<StoreSDNode>(Op.getNode());
840 return DAG.UnrollVectorOp(Op.getNode());
881 return TLI.expandVecReduce(Op.getNode(), DAG);
883 return DAG.UnrollVectorOp(Op.getNode());
910 return DAG.UnrollVectorOp(Op.getNode());
948 return DAG.UnrollVectorOp(Op.getNode());
1081 return DAG.UnrollVectorOp(Op.getNode());
1094 return DAG.UnrollVectorOp(Op.getNode());
1126 return DAG.UnrollVectorOp(Op.getNode());
1155 return DAG.UnrollVectorOp(Op.getNode());
1161 return DAG.UnrollVectorOp(Op.getNode());
1182 if (TLI.expandABS(Op.getNode(), Result, DAG))
1186 return DAG.UnrollVectorOp(Op.getNode());
1192 if (TLI.expandFP_TO_UINT(Op.getNode(), Result, Chain, DAG)) {
1193 if (Op.getNode()->isStrictFPOpcode())
1200 return DAG.UnrollVectorOp(Op.getNode());
1209 if (TLI.expandUINT_TO_FP(Op.getNode(), Result, DAG))
1215 return DAG.UnrollVectorOp(Op.getNode());
1255 return DAG.UnrollVectorOp(Op.getNode());
1267 return DAG.UnrollVectorOp(Op.getNode());
1272 if (TLI.expandCTPOP(Op.getNode(), Result, DAG))
1275 return DAG.UnrollVectorOp(Op.getNode());
1280 if (TLI.expandCTLZ(Op.getNode(), Result, DAG))
1283 return DAG.UnrollVectorOp(Op.getNode());
1288 if (TLI.expandCTTZ(Op.getNode(), Result, DAG))
1291 return DAG.UnrollVectorOp(Op.getNode());
1296 if (TLI.expandFunnelShift(Op.getNode(), Result, DAG))
1299 return DAG.UnrollVectorOp(Op.getNode());
1304 if (TLI.expandROT(Op.getNode(), Result, DAG))
1307 return DAG.UnrollVectorOp(Op.getNode());
1311 if (SDValue Expanded = TLI.expandFMINNUM_FMAXNUM(Op.getNode(), DAG))
1313 return DAG.UnrollVectorOp(Op.getNode());
1318 TLI.expandUADDSUBO(Op.getNode(), Result, Overflow, DAG);
1331 TLI.expandSADDSUBO(Op.getNode(), Result, Overflow, DAG);
1344 if (!TLI.expandMULO(Op.getNode(), Result, Overflow, DAG))
1345 std::tie(Result, Overflow) = DAG.UnrollVectorOverflowOp(Op.getNode());
1357 if (SDValue Expanded = TLI.expandAddSubSat(Op.getNode(), DAG))
1359 return DAG.UnrollVectorOp(Op.getNode());
1363 if (SDValue Expanded = TLI.expandFixedPointMul(Op.getNode(), DAG))
1365 return DAG.UnrollVectorOp(Op.getNode());
lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp 195 if (R.getNode())
273 N->getOpcode(), DL, ScalarVTs, ScalarLHS, ScalarRHS).getNode();
586 if (!Res.getNode()) {
653 if (!Res.getNode()) return false;
657 if (Res.getNode() == N)
1010 if (Lo.getNode())
1386 Scalar.getNode()->setFlags(N->getFlags());
1427 SDNode *LoNode = DAG.getNode(Opcode, dl, LoVTs, LoLHS, LoRHS).getNode();
1428 SDNode *HiNode = DAG.getNode(Opcode, dl, HiVTs, HiLHS, HiRHS).getNode();
1489 auto FrameIndex = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
1589 SplitVecRes_SETCC(Mask.getNode(), MaskLo, MaskHi);
1655 SplitVecRes_SETCC(Mask.getNode(), MaskLo, MaskHi);
1969 if (!Res.getNode()) {
2055 if (!Res.getNode()) return false;
2059 if (Res.getNode() == N)
2257 auto FrameIndex = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
2381 SplitVecRes_SETCC(Mask.getNode(), MaskLo, MaskHi);
2442 SplitVecRes_SETCC(Mask.getNode(), MaskLo, MaskHi);
2903 if (Res.getNode())
3239 N->getOpcode(), DL, WideVTs, WideLHS, WideRHS).getNode();
3835 ISD::isBuildVectorOfConstantSDNodes(N.getNode()));
4192 if (!Res.getNode()) return false;
4196 if (Res.getNode() == N)
lib/CodeGen/SelectionDAG/ResourcePriorityQueue.cpp 131 MVT VT = Op.getNode()->getSimpleValueType(Op.getResNo());
336 MVT VT = Op.getNode()->getSimpleValueType(Op.getResNo());
337 if (isa<ConstantSDNode>(Op.getNode()))
486 MVT VT = Op.getNode()->getSimpleValueType(Op.getResNo());
lib/CodeGen/SelectionDAG/ScheduleDAGFast.cpp 228 MVT VT = Op.getNode()->getSimpleValueType(Op.getResNo());
532 SUnit *RootSU = &SUnits[DAG->getRoot().getNode()->getNodeId()];
678 SDNode *OpN = Op.getNode();
758 ScheduleNode(DAG->getRoot().getNode());
lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp 452 if (IsChainDependent(Op.getNode(), Inner, NestLevel, TII))
469 N = Op.getNode();
501 if (SDNode *New = FindCallSeqStart(Op.getNode(),
527 N = Op.getNode();
1162 MVT VT = Op.getNode()->getSimpleValueType(Op.getResNo());
1336 if (const auto *RegOp = dyn_cast<RegisterMaskSDNode>(Op.getNode()))
1603 SUnit *RootSU = &SUnits[DAG->getRoot().getNode()->getNodeId()];
2824 SDNode *DU = SU->getNode()->getOperand(i).getNode();
3070 SDNode *DU = SU.getNode()->getOperand(j).getNode();
lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp 143 if (ExtraOper.getNode())
162 SDNode *GlueDestNode = Glue.getNode();
204 Chain = Node->getOperand(NumOps-1).getNode();
301 else if (!OutGlue && InGlue.getNode())
302 RemoveUnusedGlue(InGlue.getNode(), DAG);
342 Worklist.push_back(DAG->getRoot().getNode());
343 Visited.insert(DAG->getRoot().getNode());
351 if (Visited.insert(Op.getNode()).second)
352 Worklist.push_back(Op.getNode());
370 N = N->getOperand(N->getNumOperands()-1).getNode();
428 SDNode *SrcN = SUNode->getOperand(2).getNode();
473 SDNode *OpN = N->getOperand(i).getNode();
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 103 LLVM_DEBUG(dbgs() << Msg; V.getNode()->dump(G););
155 N = N->getOperand(0).getNode();
199 N = N->getOperand(0).getNode();
450 ID.AddPointer(Op.getNode());
2146 auto *CV = cast<ConstantSDNode>(V.getNode());
2161 if (!V.getNode()->hasOneUse())
2972 } else if (ISD::isZEXTLoad(Op.getNode()) && Op.getResNo() == 0) {
4458 unsigned OpOpcode = Operand.getNode()->getOpcode();
4782 return ISD::isBuildVectorOfConstantSDNodes(Divisor.getNode()) &&
4984 auto *N1CFP = dyn_cast<ConstantFPSDNode>(N1.getNode());
4985 auto *N2CFP = dyn_cast<ConstantFPSDNode>(N2.getNode());
5211 if (ISD::isBuildVectorOfConstantSDNodes(N1.getNode())) {
5363 FoldConstantArithmetic(Opcode, DL, VT, N1.getNode(), N2.getNode()))
5363 FoldConstantArithmetic(Opcode, DL, VT, N1.getNode(), N2.getNode()))
5614 for (SDNode::use_iterator U = getEntryNode().getNode()->use_begin(),
5615 UE = getEntryNode().getNode()->use_end(); U != UE; ++U)
5869 if (Value.getNode()) {
5877 if (!Store.getNode()) {
6177 if (Result.getNode())
6187 if (Result.getNode())
6294 if (Result.getNode())
6303 if (Result.getNode())
6397 if (Result.getNode())
6406 if (Result.getNode())
7134 return getConstant(0, SDLoc(X.getNode()), X.getValueType());
8024 SDNode *FromNode = From.getNode();
8025 SDNode *ToNode = To.getNode();
8106 getDbgValue(DV->getVariable(), DIExpr, N0.getNode(), N0.getResNo(),
8112 N0.getNode()->dumprFull(this);
8161 SDNode *From = FromN.getNode();
8164 assert(From != To.getNode() && "Cannot replace uses of with self");
8258 if (From == getRoot().getNode())
8307 if (From == getRoot().getNode())
8319 if (From.getNode()->getNumValues() == 1) {
8329 SDNode::use_iterator UI = From.getNode()->use_begin(),
8330 UE = From.getNode()->use_end();
8476 SDNode *FromNode = From[i].getNode();
8623 assert(isa<MemSDNode>(NewMemOp.getNode()) && "Expected a memop node");
8629 SDValue NewChain = SDValue(NewMemOp.getNode(), 1);
8636 UpdateNodeOperands(TokenFactor.getNode(), OldChain, NewChain);
8952 [this](SDValue Op) { return this == Op.getNode(); });
9261 if (TLI->isGAPlusOffset(Ptr.getNode(), GV, GVOffset)) {
9540 return N.getNode();
9541 if (ISD::isBuildVectorOfConstantSDNodes(N.getNode()))
9542 return N.getNode();
9554 return N.getNode();
9556 if (ISD::isBuildVectorOfConstantFPSDNodes(N.getNode()))
9557 return N.getNode();
9616 checkForCyclesHelper(Op.getNode(), Visited, Checked, DAG);
9641 checkForCycles(DAG->getRoot().getNode(), DAG, force);
lib/CodeGen/SelectionDAG/SelectionDAGAddressAnalysis.cpp 26 if (!Base.getNode() || !Other.Base.getNode())
26 if (!Base.getNode() || !Other.Base.getNode())
94 if (!(BasePtr0.getBase().getNode() && BasePtr1.getBase().getNode()))
94 if (!(BasePtr0.getBase().getNode() && BasePtr1.getBase().getNode()))
211 auto *LSBase = cast<LSBaseSDNode>(Base.getNode());
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 1062 assert(PendingExports[i].getNode()->getNumOperands() > 1);
1063 if (PendingExports[i].getNode()->getOperand(0) == Root)
1170 unsigned ValSDNodeOrder = Val.getNode()->getIROrder();
1177 if (Val.getNode()) {
1197 DAG.AddDbgValue(SDV, Val.getNode(), false);
1298 if (!N.getNode() && isa<Argument>(V)) // Check unused arguments map.
1300 if (N.getNode()) {
1304 DAG.AddDbgValue(SDV, N.getNode(), false);
1395 if (N.getNode()) return N;
1420 if (N.getNode()) {
1467 assert(N1.getNode() && "visit didn't populate the NodeMap!");
1475 SDNode *Val = getValue(*OI).getNode();
1491 SDNode *Val = getValue(CDS->getElementAsConstant(i)).getNode();
1859 SDValue(RetOp.getNode(), RetOp.getResNo() + j),
1921 assert(Chain.getNode() && Chain.getValueType() == MVT::Other &&
3360 LHSVal.getNode()->getValueType(LHSVal.getResNo() + i),
3361 SDValue(LHSVal.getNode(), LHSVal.getResNo() + i));
3366 Ops.push_back(SDValue(LHSVal.getNode(), LHSVal.getResNo() + i));
3367 Ops.push_back(SDValue(RHSVal.getNode(), RHSVal.getResNo() + i));
3370 LHSVal.getNode()->getValueType(LHSVal.getResNo() + i), Ops);
3777 SDValue(Agg.getNode(), Agg.getResNo() + i);
3783 SDValue(Val.getNode(), Val.getResNo() + i - LinearIndex);
3788 SDValue(Agg.getNode(), Agg.getResNo() + i);
3827 DAG.getUNDEF(Agg.getNode()->getValueType(Agg.getResNo() + i)) :
3828 SDValue(Agg.getNode(), Agg.getResNo() + i);
4145 SDValue(Src.getNode(), Src.getResNo()));
4251 SDValue Val = SDValue(Src.getNode(), Src.getResNo() + i);
4840 SDValue Chain = Result.getValue(Result.getNode()->getNumValues()-1);
5366 if (Res.getNode())
5504 if (!Op && N.getNode()) {
5522 if (!Op && N.getNode()) {
5525 if (LoadSDNode *LNode = dyn_cast<LoadSDNode>(LCandidate.getNode()))
5527 dyn_cast<FrameIndexSDNode>(LNode->getBasePtr().getNode()))
5592 if (auto *FISDN = dyn_cast<FrameIndexSDNode>(N.getNode())) {
5606 return DAG.getDbgValue(Variable, Expr, N.getNode(), N.getResNo(),
5845 DAG.AddDbgValue(SDV, getRoot().getNode(), isParameter);
5851 if (!N.getNode() && isa<Argument>(Address))
5855 if (N.getNode()) {
5859 auto FINode = dyn_cast<FrameIndexSDNode>(N.getNode());
5871 SDV = DAG.getDbgValue(Variable, Expression, N.getNode(), N.getResNo(),
5874 DAG.AddDbgValue(SDV, N.getNode(), isParameter);
6472 FrameIndexSDNode *FI = cast<FrameIndexSDNode>(getValue(Alloca).getNode());
7016 assert(Result.getNode()->getNumValues() == 2);
7056 assert((CLI.IsTailCall || Result.second.getNode()) &&
7058 assert((Result.second.getNode() || !Result.first.getNode()) &&
7058 assert((Result.second.getNode() || !Result.first.getNode()) &&
7061 if (!Result.second.getNode()) {
7179 if (Result.first.getNode()) {
7275 if (Res.first.getNode()) {
7362 if (Res.first.getNode()) {
7397 assert(MC.getNode() != nullptr &&
7425 if (Res.first.getNode()) {
7448 if (Res.first.getNode()) {
7469 if (Res.first.getNode()) {
7491 if (Res.first.getNode()) {
8402 if (Flag.getNode()) AsmNodeOperands.push_back(Flag);
8601 unsigned NumVals = Op.getNode()->getNumValues();
8793 SDNode *CallEnd = Result.second.getNode();
8795 CallEnd = CallEnd->getOperand(0).getNode();
8801 SDNode *Call = CallEnd->getOperand(0).getNode();
9124 SDValue Op = SDValue(Args[i].Node.getNode(),
9265 assert(CLI.Chain.getNode() && CLI.Chain.getValueType() == MVT::Other &&
9283 assert(InVals[i].getNode() && "LowerCall emitted a null value!");
9520 auto *FINode = dyn_cast<FrameIndexSDNode>(LNode->getBasePtr().getNode());
9733 assert(NewRoot.getNode() && NewRoot.getValueType() == MVT::Other &&
9739 assert(InVals[i].getNode() &&
9808 dyn_cast<FrameIndexSDNode>(InVals[i].getNode()))
9843 dyn_cast<FrameIndexSDNode>(ArgValues[0].getNode()))
9860 dyn_cast<LoadSDNode>(Res.getOperand(LowAddressOp).getNode()))
9862 dyn_cast<FrameIndexSDNode>(LNode->getBasePtr().getNode()))
10036 if (MaybeTC.getNode() != nullptr)
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 507 return NodeMap[V].getNode();
515 assert(!N.getNode() && "Already set a value for this node!");
521 assert(!N.getNode() && "Already set a value for this node!");
lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp 805 if (shouldPrintInline(*Op.getNode(), G))
807 if (Op.getNode()->hasOneUse())
808 DumpNodes(Op.getNode(), indent+2, G);
821 if (!N->hasOneUse() && N != getRoot().getNode() &&
826 if (getRoot().getNode()) DumpNodes(getRoot().getNode(), 2, this);
826 if (getRoot().getNode()) DumpNodes(getRoot().getNode(), 2, this);
852 if (!Value.getNode()) {
855 } else if (shouldPrintInline(*Value.getNode(), G)) {
861 OS << PrintNodeId(*Value.getNode());
888 once.insert(Op.getNode());
895 DumpNodesr(OS, Op.getNode(), indent+2, G, once);
927 printrWithDepthHelper(OS, Op.getNode(), G, depth-1, indent+2);
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp 741 Worklist.push_back(CurDAG->getRoot().getNode());
755 Worklist.push_back(Op.getNode());
1110 SelectionDAG::allnodes_iterator ISelPosition (CurDAG->getRoot().getNode());
1139 Nodes.push_back(Op.getNode());
2115 SDNode *N = Op.getNode();
2128 SDNode *N = Op.getNode();
2215 return !findNonImmUse(Root, N.getNode(), U, IgnoreChains);
2227 ReplaceUses(N, New.getNode());
2241 ReplaceUses(Op, New.getNode());
2255 ReplaceUses(Op, New.getNode());
2290 assert(InputChain.getNode() &&
2360 if (!Visited.insert(V.getNode()).second)
2386 Worklist.push_back(V.getNode());
2625 Result = !::CheckNodePredicate(Table, Index, SDISel, N.getNode());
2628 Result = !::CheckOpcode(Table, Index, N.getNode());
2736 if (I.first.getNode() == N)
2741 if (J.getNode() == N)
2942 Parent = NodeStack[NodeStack.size()-2].getNode();
2956 N.getNode()));
3020 N.getNode()))
3031 if (!CheckNodePredicateWithOperands(N.getNode(), PredNo, Operands))
3054 if (!::CheckOpcode(MatcherTable, MatcherIndex, N.getNode())) break;
3170 if (!ISD::isBuildVectorAllOnes(N.getNode())) break;
3173 if (!ISD::isBuildVectorAllZeros(N.getNode())) break;
3182 if (!NodeStack[i].getNode()->hasOneUse()) {
3190 if (!IsProfitableToFold(N, NodeStack[NodeStack.size()-2].getNode(),
3192 !IsLegalToFold(N, NodeStack[NodeStack.size()-2].getNode(),
3255 assert(!InputChain.getNode() &&
3263 ChainNodesMatched.push_back(RecordedNodes[RecNo].first.getNode());
3276 if (!InputChain.getNode())
3282 assert(!InputChain.getNode() &&
3300 ChainNodesMatched.push_back(RecordedNodes[RecNo].first.getNode());
3318 if (!InputChain.getNode())
3332 if (!InputChain.getNode())
3433 if ((EmitNodeInfo & OPFL_GlueInput) && InputGlue.getNode() != nullptr)
3558 InputGlue.getNode())
lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp 134 if (G->getRoot().getNode())
135 GW.emitEdge(nullptr, -1, G->getRoot().getNode(), G->getRoot().getResNo(),
299 const SDNode *N = DAG->getRoot().getNode();
lib/CodeGen/SelectionDAG/StatepointLowering.cpp 234 if (OldLocation.getNode())
319 SDNode *CallEnd = CallEndVal.getNode();
340 CallEnd = CallEnd->getOperand(0).getNode();
343 CallEnd = CallEnd->getOperand(0).getNode();
347 return std::make_pair(ReturnValue, CallEnd->getOperand(0).getNode());
374 if (!Loc.getNode()) {
407 assert(Loc.getNode());
559 if (!Incoming.getNode())
611 if (Loc.getNode()) {
742 SDValue CallTarget = SDValue(CallNode->getOperand(1).getNode(), 0);
773 if (Glue.getNode())
811 SinkNode = GCTransitionStart.getNode();
983 assert(CopyFromReg.getNode());
1043 assert(SpillLoad.getNode());
lib/CodeGen/SelectionDAG/TargetLowering.cpp 475 return TLO.New.getNode();
515 assert(Op.getNode()->getNumValues() == 1 &&
527 if (!Op.getNode()->hasOneUse())
563 DCI.AddToWorklist(Op.getNode());
787 if (!Op.getNode()->hasOneUse() && !AssumeSingleUse) {
1261 (isNullConstant(Op1) || ISD::isBuildVectorAllZeros(Op1.getNode())))
1744 if (Src.getNode()->hasOneUse()) {
1924 SDNodeFlags Flags = Op.getNode()->getFlags();
1999 const SDNode *N = Op.getNode();
2028 DCI.AddToWorklist(Op.getNode());
2103 if (!Op.getNode()->hasOneUse() && !AssumeSingleUse)
3044 DCI.AddToWorklist(YShl1.getNode());
3080 if (auto *N1C = dyn_cast<ConstantSDNode>(N1.getNode())) {
3240 N0.getNode()->hasOneUse() &&
3242 N0.getOperand(0).getNode()->hasOneUse() &&
3370 DCI.AddToWorklist(ZextOp.getNode());
3608 if (auto *N1C = dyn_cast<ConstantSDNode>(N1.getNode())) {
3804 if (N0.getOpcode() == ISD::ADD && N0.getNode()->hasOneUse()) {
3826 if (N0.getOpcode() == ISD::SUB && N0.getNode()->hasOneUse()) {
3886 DCI.AddToWorklist(Temp.getNode());
3896 DCI.AddToWorklist(Temp.getNode());
3903 DCI.AddToWorklist(Temp.getNode());
3910 DCI.AddToWorklist(Temp.getNode());
3920 DCI.AddToWorklist(N0.getNode());
3937 SDNode *N = unwrapAddress(SDValue(WN, 0)).getNode();
3948 if (isGAPlusOffset(N1.getNode(), GA, Offset)) {
3953 } else if (isGAPlusOffset(N2.getNode(), GA, Offset)) {
4491 CType == TargetLowering::C_Immediate) && Op.getNode()) {
4548 if (Op.getNode() && Op.getOpcode() == ISD::TargetBlockAddress)
4615 Created.push_back(Res.getNode());
4716 Q = SDValue(LoHi.getNode(), 1);
4719 Created.push_back(Q.getNode());
4723 Created.push_back(Factor.getNode());
4725 Created.push_back(Q.getNode());
4729 Created.push_back(Q.getNode());
4734 Created.push_back(T.getNode());
4736 Created.push_back(T.getNode());
4825 Created.push_back(Q.getNode());
4836 return SDValue(LoHi.getNode(), 1);
4846 Created.push_back(Q.getNode());
4850 Created.push_back(NPQ.getNode());
4859 Created.push_back(NPQ.getNode());
4862 Created.push_back(Q.getNode());
4866 Created.push_back(Q.getNode());
5048 Created.push_back(Op0.getNode());
5060 Created.push_back(Op0.getNode());
5257 Created.push_back(Op0.getNode());
5266 Created.push_back(Op0.getNode());
5279 Created.push_back(Op0.getNode());
5302 Created.push_back(Fold.getNode());
5313 Created.push_back(DivisorIsIntMin.getNode());
5317 Created.push_back(Masked.getNode());
5319 Created.push_back(MaskedIsZero.getNode());
5613 assert((LL.getNode() && LH.getNode() && RL.getNode() && RH.getNode()) ||
5613 assert((LL.getNode() && LH.getNode() && RL.getNode() && RH.getNode()) ||
5613 assert((LL.getNode() && LH.getNode() && RL.getNode() && RH.getNode()) ||
5613 assert((LL.getNode() && LH.getNode() && RL.getNode() && RH.getNode()) ||
5614 (!LL.getNode() && !LH.getNode() && !RL.getNode() && !RH.getNode()));
5614 (!LL.getNode() && !LH.getNode() && !RL.getNode() && !RH.getNode()));
5614 (!LL.getNode() && !LH.getNode() && !RL.getNode() && !RH.getNode()));
5614 (!LL.getNode() && !LH.getNode() && !RL.getNode() && !RH.getNode()));
5621 Hi = SDValue(Lo.getNode(), 1);
5634 if (!LL.getNode() && !RL.getNode() &&
5634 if (!LL.getNode() && !RL.getNode() &&
5640 if (!LL.getNode())
5680 if (!LH.getNode() && !RH.getNode() &&
5680 if (!LH.getNode() && !RH.getNode() &&
5689 if (!LH.getNode())
6504 auto FrameIndex = cast<FrameIndexSDNode>(StackBase.getNode())->getIndex();
6657 auto FrameIndex = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
7115 Result = SDValue(NodeCarry.getNode(), 0);
7116 Overflow = SDValue(NodeCarry.getNode(), 1);
lib/Target/AArch64/AArch64ISelDAGToDAG.cpp 257 return isIntImmediate(N.getNode(), Imm);
266 isIntImmediate(N->getOperand(1).getNode(), Imm);
303 if (!isa<ConstantSDNode>(N.getNode()))
306 uint64_t Immed = cast<ConstantSDNode>(N.getNode())->getZExtValue();
333 if (!isa<ConstantSDNode>(N.getNode()))
337 uint64_t Immed = cast<ConstantSDNode>(N.getNode())->getZExtValue();
389 const SDNode *Node = V.getNode();
516 ConstantSDNode *DLidx = cast<ConstantSDNode>(DL->getOperand(1).getNode());
517 ConstantSDNode *EVidx = cast<ConstantSDNode>(EV.getOperand(1).getNode());
529 if (!checkHighLaneIndex(Op0.getNode(), LaneOp, LaneIdx)) {
531 if (!checkHighLaneIndex(Op0.getNode(), LaneOp, LaneIdx))
676 Reg->getValueType(0).getSizeInBits() == 32 && isDef32(*Reg.getNode()))
793 dyn_cast<GlobalAddressSDNode>(N.getOperand(1).getNode());
934 const SDNode *Node = N.getNode();
1018 const SDNode *Node = N.getNode();
1562 const SDNode *Op0 = N->getOperand(0).getNode();
1576 isOpcWithIntImmediate(Op0->getOperand(0).getNode(), ISD::SRL, SrlImm)) {
1583 isOpcWithIntImmediate(Op0->getOperand(0).getNode(), ISD::SRL,
1644 if (!isOpcWithIntImmediate(Op.getNode(), ISD::SRL, ShiftImm) &&
1645 !isOpcWithIntImmediate(Op.getNode(), ISD::SRA, ShiftImm))
1680 if (!isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::AND, AndMask))
1726 if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::SHL, ShlImm)) {
1729 N->getOperand(0).getNode()->getOpcode() == ISD::TRUNCATE) {
1782 if (!isOpcWithIntImmediate(Op.getNode(), ISD::SRA, ShiftImm))
1829 Immr = cast<ConstantSDNode>(N->getOperand(1).getNode())->getZExtValue();
1830 Imms = cast<ConstantSDNode>(N->getOperand(2).getNode())->getZExtValue();
1902 cast<const ConstantSDNode>(Op.getOperand(1).getNode())->getZExtValue();
1938 cast<const ConstantSDNode>(Op.getOperand(1).getNode())->getZExtValue();
1940 cast<const ConstantSDNode>(Op.getOperand(2).getNode())->getZExtValue();
1948 cast<const ConstantSDNode>(Op.getOperand(2).getNode())->getZExtValue();
1976 cast<const ConstantSDNode>(Op.getOperand(2).getNode())->getZExtValue();
1978 cast<const ConstantSDNode>(Op.getOperand(3).getNode())->getZExtValue();
2088 for (SDNode *Node : Op.getNode()->uses()) {
2151 if (isOpcWithIntImmediate(Op.getNode(), ISD::AND, AndImm)) {
2162 if (!isOpcWithIntImmediate(Op.getNode(), ISD::SHL, ShlImm))
2216 !isOpcWithIntImmediate(And.getNode(), ISD::AND, MaskImm))
2321 SDNode *OrOpd0 = OrOpd0Val.getNode();
2323 SDNode *OrOpd1 = OrOpd1Val.getNode();
2399 isOpcWithIntImmediate(And0.getNode(), ISD::AND, Mask0Imm) &&
2400 isOpcWithIntImmediate(And1.getNode(), ISD::AND, Mask1Imm) &&
2570 if (!isOpcWithIntImmediate(ShiftAmt.getNode(), ISD::AND, MaskImm))
2945 ReplaceNode(Node, New.getNode());
2950 ReplaceNode(Node, New.getNode());
lib/Target/AArch64/AArch64ISelLowering.cpp 1834 if (!CCOp.getNode())
1973 if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS.getNode())) {
2072 LHS.getNode()->hasNUsesOfValue(1, 0)) {
2711 SDNode *N0 = N->getOperand(0).getNode();
2712 SDNode *N1 = N->getOperand(1).getNode();
2722 SDNode *N0 = N->getOperand(0).getNode();
2723 SDNode *N1 = N->getOperand(1).getNode();
2756 SDNode *N0 = Op.getOperand(0).getNode();
2757 SDNode *N1 = Op.getOperand(1).getNode();
2809 SDValue N00 = skipExtensionForVectorMULL(N0->getOperand(0).getNode(), DAG);
2810 SDValue N01 = skipExtensionForVectorMULL(N0->getOperand(1).getNode(), DAG);
3689 for (SDNode::use_iterator U = DAG.getEntryNode().getNode()->use_begin(),
3690 UE = DAG.getEntryNode().getNode()->use_end();
4113 if (InFlag.getNode())
4123 DAG.addCallSiteInfo(Ret.getNode(), std::move(CSInfo));
4130 DAG.addCallSiteInfo(Chain.getNode(), std::move(CSInfo));
4268 if (Flag.getNode())
4699 if (!RHS.getNode()) {
4964 if (!RHS.getNode()) {
5027 if (!RHS.getNode()) {
5275 int JTI = cast<JumpTableSDNode>(JT.getNode())->getIndex();
6207 if (Result.getNode()) {
6878 if (V2.getNode()->isUndef()) {
6929 ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Op.getNode());
7428 if (SDValue Res = tryLowerToSLI(Op.getNode(), DAG))
7436 dyn_cast<BuildVectorSDNode>(Op.getOperand(1).getNode());
7440 BVN = dyn_cast<BuildVectorSDNode>(Op.getOperand(0).getNode());
7489 } else if (Lane.getNode()->isUndef()) {
7505 BuildVectorSDNode *BVN = cast<BuildVectorSDNode>(Op.getNode());
7552 BuildVectorSDNode *BVN = cast<BuildVectorSDNode>(Op.getNode());
7601 if (!ConstantValue.getNode())
7607 if (!Value.getNode())
7613 if (!Value.getNode()) {
7636 const SDNode *N = V.getNode();
7643 Vector = N0.getNode();
7649 } else if (Vector != N0.getNode()) {
7731 if (Val.getNode())
7747 DAG.ReplaceAllUsesWith(Vec.getNode(), &Val);
7966 BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(Op.getNode());
8057 BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(RHS.getNode());
8189 if (!Cmp.getNode())
8195 if (!Cmp2.getNode())
8260 AtomicSDNode *AN = cast<AtomicSDNode>(Op.getNode());
8277 AtomicSDNode *AN = cast<AtomicSDNode>(Op.getNode());
8319 SDNode *Node = Op.getNode();
9219 N = N->getOperand(0).getNode();
9280 !ISD::isBuildVectorAllOnes(Ones.getNode()))
9315 SDValue(Cmp.getNode(), 1));
9358 Created.push_back(Cmp.getNode());
9359 Created.push_back(Add.getNode());
9360 Created.push_back(CSel.getNode());
9371 Created.push_back(SRA.getNode());
9405 if (N0->hasOneUse() && (isSignExtended(N0.getNode(), DAG) ||
9406 isZeroExtended(N0.getNode(), DAG)))
9540 if (Subtarget->hasNEON() && ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
9842 dyn_cast<BuildVectorSDNode>(N->getOperand(1).getNode());
10323 if (!RHS.getNode())
10329 if (!LHS.getNode())
10362 if (!RHS.getNode())
10366 if (!LHS.getNode())
10535 SDNode *ABDNode = N->getOperand(0).getNode();
10540 if (!NewABD.getNode())
10877 SDNode *LD = N->getOperand(LoadIdx).getNode();
10910 for (SDNode::use_iterator UI = Addr.getNode()->use_begin(), UE =
10911 Addr.getNode()->use_end(); UI != UE; ++UI) {
10919 if (ConstantSDNode *CInc = dyn_cast<ConstantSDNode>(Inc.getNode())) {
10931 Visited.insert(Addr.getNode());
10934 Worklist.push_back(Vector.getNode());
10958 SDValue(UpdN.getNode(), 2) // Chain
10961 DCI.CombineTo(N, SDValue(UpdN.getNode(), 0)); // Dup/Inserted Result
10962 DCI.CombineTo(User, SDValue(UpdN.getNode(), 1)); // Write back register
11013 for (SDNode::use_iterator UI = Addr.getNode()->use_begin(),
11014 UE = Addr.getNode()->use_end(); UI != UE; ++UI) {
11024 Visited.insert(Addr.getNode());
11092 if (ConstantSDNode *CInc = dyn_cast<ConstantSDNode>(Inc.getNode())) {
11128 NewResults.push_back(SDValue(UpdN.getNode(), i));
11130 NewResults.push_back(SDValue(UpdN.getNode(), NumResultVecs + 1));
11132 DCI.CombineTo(User, SDValue(UpdN.getNode(), NumResultVecs));
11144 switch(V.getNode()->getOpcode()) {
11148 LoadSDNode *LoadNode = cast<LoadSDNode>(V.getNode());
11157 VTSDNode *TypeNode = cast<VTSDNode>(V.getNode()->getOperand(1));
11166 VTSDNode *TypeNode = cast<VTSDNode>(V.getNode()->getOperand(1));
11176 return std::abs(cast<ConstantSDNode>(V.getNode())->getSExtValue()) <
11326 SDNode *SubsNode = N->getOperand(CmpIndex).getNode();
11335 SDNode *AndNode = SubsNode->getOperand(0).getNode();
11359 SDValue AddInputValue1 = AddValue.getNode()->getOperand(0);
11360 SDValue AddInputValue2 = AddValue.getNode()->getOperand(1);
11366 if (!isa<ConstantSDNode>(AddInputValue2.getNode()) ||
11367 !isa<ConstantSDNode>(SubsInputValue.getNode()))
11378 cast<ConstantSDNode>(AddInputValue2.getNode())->getSExtValue(),
11379 cast<ConstantSDNode>(SubsInputValue.getNode())->getSExtValue()))
11389 DAG.ReplaceAllUsesWith(SubsNode, NewValue.getNode());
11406 N = NV.getNode();
11896 if (!getIndexedAddressParts(Ptr.getNode(), Base, Offset, AM, IsInc, DAG))
11969 SDLoc dl(V.getNode());
lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp 415 if (LdHi && Hi.hasOneUse() && !LdHi->isPredecessorOf(Lo.getNode())) {
447 if (!TiedIn || LdLo->isPredecessorOf(TiedIn.getNode()))
1333 if (!GLC.getNode())
1335 if (!SLC.getNode())
1620 N = AMDGPUTargetLowering::stripBitcast(SDValue(N,0)).getNode();
2494 if (Lo == Hi && !isInlineImmediate(Lo.getNode())) {
lib/Target/AMDGPU/AMDGPUISelLowering.cpp 1060 for (SDNode::use_iterator U = DAG.getEntryNode().getNode()->use_begin(),
1061 UE = DAG.getEntryNode().getNode()->use_end();
3006 DCI.AddToWorklist(Lo.getNode());
3007 DCI.AddToWorklist(Hi.getNode());
3233 DCI.AddToWorklist(Trunc.getNode());
3237 DCI.AddToWorklist(Amt.getNode());
3341 DCI.AddToWorklist(Mulhi.getNode());
3365 DCI.AddToWorklist(Mulhi.getNode());
3471 DCI.AddToWorklist(NewSelect.getNode());
3533 DCI.AddToWorklist(NewSelect.getNode());
3650 (allUsesHaveSourceMods(N) || !allUsesHaveSourceMods(N0.getNode())))
4508 auto GA = cast<GlobalAddressSDNode>(Op.getOperand(0).getNode());
lib/Target/AMDGPU/AMDGPUISelLowering.h 153 const auto Flags = Op.getNode()->getFlags();
lib/Target/AMDGPU/R600ISelLowering.cpp 491 assert((!Result.getNode() ||
492 Result.getNode()->getNumValues() == 2) &&
1923 Ops.append(InVec.getNode()->op_begin(),
1924 InVec.getNode()->op_end());
1991 if (LHS.getOperand(2).getNode() != True.getNode() ||
1991 if (LHS.getOperand(2).getNode() != True.getNode() ||
1992 LHS.getOperand(3).getNode() != False.getNode() ||
1992 LHS.getOperand(3).getNode() != False.getNode() ||
1993 RHS.getNode() != False.getNode()) {
1993 RHS.getNode() != False.getNode()) {
2091 if (!Neg.getNode())
2097 if (!Abs.getNode())
2106 if (!Sel.getNode())
2196 if (!Imm.getNode())
lib/Target/AMDGPU/SIISelLowering.cpp 2359 if (Flag.getNode())
2538 InputReg = InputReg.getNode() ?
2546 InputReg = InputReg.getNode() ?
2550 if (!InputReg.getNode()) {
2951 if (InFlag.getNode())
3955 std::tie(Lo, Hi) = DAG.SplitVectorOperand(Op.getNode(), 0);
3975 std::tie(Lo0, Hi0) = DAG.SplitVectorOperand(Op.getNode(), 0);
3977 std::tie(Lo1, Hi1) = DAG.SplitVectorOperand(Op.getNode(), 1);
3996 std::tie(Lo0, Hi0) = DAG.SplitVectorOperand(Op.getNode(), 0);
3998 std::tie(Lo1, Hi1) = DAG.SplitVectorOperand(Op.getNode(), 1);
4000 std::tie(Lo2, Hi2) = DAG.SplitVectorOperand(Op.getNode(), 2);
4020 assert((!Result.getNode() ||
4021 Result.getNode()->getNumValues() == 2) &&
4376 SDNode *Parent = Value.getNode();
4438 SDNode *Intr = BRCOND.getOperand(1).getNode();
4446 Intr = SetCC->getOperand(0).getNode();
4472 cast<CondCodeSDNode>(SetCC->getOperand(2).getNode())->get() ==
4486 SDNode *Result = DAG.getNode(CFNode, DL, DAG.getVTList(Res), Ops).getNode();
4494 Result = DAG.getMergeValues(Ops, DL).getNode();
4504 DAG.ReplaceAllUsesWith(BR, NewBR.getNode());
4505 BR = NewBR.getNode();
4553 unsigned Reg = MF.addLiveIn(TRI->getReturnAddressReg(MF), getRegClassFor(VT, Op.getNode()->isDivergent()));
4595 return expandFMINNUM_FMAXNUM(Op.getNode(), DAG);
4879 if (SDValue Combined = performExtractVectorEltCombine(Op.getNode(), DCI))
5194 auto CachePolicyConst = cast<ConstantSDNode>(CachePolicy.getNode());
5299 auto TexFailCtrlConst = cast<ConstantSDNode>(TexFailCtrl.getNode());
5997 return lowerICMPIntrinsic(*this, Op.getNode(), DAG);
6000 return lowerFCMPIntrinsic(*this, Op.getNode(), DAG);
6735 NewOp = DAG.getMergeValues({ Extract, SDValue(NewOp.getNode(), 1) }, DL);
6759 return DAG.UnrollVectorOp(ZExt.getNode());
7307 DCI.AddToWorklist(Cvt.getNode());
7312 DCI.AddToWorklist(Cvt.getNode());
8023 DCI.AddToWorklist(Cvt.getNode());
8100 SDValue NewPtr = performSHLPtrCombine(Ptr.getNode(), N->getAddressSpace(),
8521 DCI.AddToWorklist(LowOr.getNode());
8522 DCI.AddToWorklist(HiBits.getNode());
8981 DCI.AddToWorklist(Canon0.getNode());
9300 DCI.AddToWorklist(Elt0.getNode());
9301 DCI.AddToWorklist(Elt1.getNode());
9353 DCI.AddToWorklist(Cast.getNode());
9357 DCI.AddToWorklist(Elt.getNode());
9360 DCI.AddToWorklist(Srl.getNode());
9363 DCI.AddToWorklist(Trunc.getNode());
9624 unsigned FusedOp = getFusedOpcode(DAG, N, LHS.getNode());
9636 unsigned FusedOp = getFusedOpcode(DAG, N, RHS.getNode());
9668 unsigned FusedOp = getFusedOpcode(DAG, N, LHS.getNode());
9683 unsigned FusedOp = getFusedOpcode(DAG, N, RHS.getNode());
10269 DAG.ReplaceAllUsesWith(Node, ToResultReg.getNode());
10271 return ToResultReg.getNode();
10326 getRegClassFor(VT, Src0.getNode()->isDivergent());
10817 N = N->getOperand(0).getNode();
lib/Target/ARC/ARCISelLowering.cpp 289 if (!StackPtr.getNode())
350 if (Glue.getNode())
675 if (Flag.getNode())
lib/Target/ARM/ARMISelDAGToDAG.cpp 313 return isInt32Immediate(N.getNode(), Imm);
321 isInt32Immediate(N->getOperand(1).getNode(), Imm);
370 if (!isOpcWithIntImmediate(N1.getNode(), ISD::AND, And_imm)) {
371 if (isOpcWithIntImmediate(N0.getNode(), ISD::AND, And_imm))
397 if (!isOpcWithIntImmediate(Srl.getNode(), ISD::SRL, Srl_imm) ||
521 CurDAG->RepositionNode(N.getNode()->getIterator(), M.getNode());
521 CurDAG->RepositionNode(N.getNode()->getIterator(), M.getNode());
1690 SDLoc dl(V0.getNode());
1701 SDLoc dl(V0.getNode());
1712 SDLoc dl(V0.getNode());
1723 SDLoc dl(V0.getNode());
1735 SDLoc dl(V0.getNode());
1750 SDLoc dl(V0.getNode());
1765 SDLoc dl(V0.getNode());
2024 assert(isa<ConstantSDNode>(Inc.getNode()) &&
2196 assert(isa<ConstantSDNode>(Inc.getNode()) &&
2652 if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::SRL,
2703 if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::SHL, Shl_imm)) {
2725 if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::AND, And_imm) &&
2749 if (!isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::SRL, LSB) &&
2750 !isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::SRA, LSB))
2894 ReplaceNode(And.getNode(), NewN);
2898 ReplaceNode(And.getNode(), NewN);
2903 ReplaceNode(And.getNode(), NewN);
2912 ReplaceNode(And.getNode(), NewN);
3137 CurDAG->RepositionNode(N->getIterator(), NewImm.getNode());
3173 if (N0.getOpcode() == ISD::OR && N0.getNode()->hasOneUse()) {
3352 ReplaceUses(Int.getNode(), LoopDec);
3360 CurDAG->RemoveDeadNode(InFlag.getNode());
3361 CurDAG->RemoveDeadNode(Int.getNode());
3367 SelectCMPZ(InFlag.getNode(), SwitchEQNEToPLMI);
3393 SDValue(Chain.getNode(), Chain.getResNo()));
3404 auto *C = dyn_cast<ConstantSDNode>(N->getOperand(1).getNode());
3441 SelectCMPZ(InFlag.getNode(), SwitchEQNEToPLMI);
4765 if(PairedReg.getNode()) {
4782 if (Glue.getNode())
4790 ReplaceNode(N, New.getNode());
lib/Target/ARM/ARMISelLowering.cpp 2036 if (!StackPtr.getNode())
2422 if (InFlag.getNode())
2429 DAG.addCallSiteInfo(Ret.getNode(), std::move(CSInfo));
2436 DAG.addCallSiteInfo(Chain.getNode(), std::move(CSInfo));
2568 (!isa<GlobalAddressSDNode>(Callee.getNode()) || isIndirect))
2849 if (Flag.getNode())
2898 if (Copies.count(UseChain.getNode()))
4159 else if (ISD::isEXTLoad(Op.getNode()) || ISD::isNON_EXTLoad(Op.getNode())) {
4159 else if (ISD::isEXTLoad(Op.getNode()) || ISD::isNON_EXTLoad(Op.getNode())) {
4184 if (ConstantSDNode *RHSC = dyn_cast<ConstantSDNode>(RHS.getNode())) {
4254 auto *RHSC = cast<ConstantSDNode>(RHS.getNode());
4589 if (True.getNode() && False.getNode()) {
4589 if (True.getNode() && False.getNode()) {
4980 if (!RHS.getNode()) {
5059 SDNode *N = Op.getNode();
5223 if (!RHS.getNode()) {
5335 return DAG.UnrollVectorOp(Op.getNode());
5353 return DAG.UnrollVectorOp(Op.getNode());
5386 return DAG.UnrollVectorOp(Op.getNode());
5404 return DAG.UnrollVectorOp(Op.getNode());
5985 BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(Op.getNode());
6126 Hi = SDValue(Lo.getNode(), 1);
6283 if (ISD::isBuildVectorAllZeros(Op1.getNode()))
6285 else if (ISD::isBuildVectorAllZeros(Op0.getNode()))
6289 if (AndOp.getNode() && AndOp.getOpcode() == ISD::BITCAST)
6292 if (AndOp.getNode() && AndOp.getOpcode() == ISD::AND) {
6309 if (ISD::isBuildVectorAllZeros(Op1.getNode()))
6311 else if (ISD::isBuildVectorAllZeros(Op0.getNode())) {
6320 if (SingleOp.getNode()) {
7095 BuildVectorSDNode *BVN = cast<BuildVectorSDNode>(Op.getNode());
7118 if (Val.getNode()) {
7129 if (Val.getNode()) {
7182 if (!Value.getNode() && !ValueCounts.empty())
7190 if (isOnlyLowElement && !ISD::isNormalLoad(Value.getNode()))
7252 if (Val.getNode())
7257 if (isConstant && Val.getNode())
7685 if (V2.getNode()->isUndef())
7761 ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Op.getNode());
7804 ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Op.getNode());
8219 SDNode *BVN = N->getOperand(0).getNode();
8246 SDNode *Elt = N->getOperand(i).getNode();
8375 SDNode *BVN = N->getOperand(0).getNode();
8404 SDNode *N0 = N->getOperand(0).getNode();
8405 SDNode *N1 = N->getOperand(1).getNode();
8415 SDNode *N0 = N->getOperand(0).getNode();
8416 SDNode *N1 = N->getOperand(1).getNode();
8429 SDNode *N0 = Op.getOperand(0).getNode();
8430 SDNode *N1 = Op.getOperand(1).getNode();
8488 SDValue N00 = SkipExtensionForVMULL(N0->getOperand(0).getNode(), DAG);
8489 SDValue N01 = SkipExtensionForVMULL(N0->getOperand(1).getNode(), DAG);
8682 SDNode *N = Op.getNode();
8915 SDValue DBZCHK = WinDBZCheckDenominator(DAG, Op.getNode(), DAG.getEntryNode());
8929 LoadSDNode *LD = cast<LoadSDNode>(Op.getNode());
8959 StoreSDNode *ST = cast<StoreSDNode>(Op.getNode());
8988 MaskedLoadSDNode *N = cast<MaskedLoadSDNode>(Op.getNode());
8995 return (ISD::isBuildVectorAllZeros(PassThru.getNode()) ||
9052 SDLoc dl(V.getNode());
9132 bool IsTC = TLI.isInTailCallPosition(DAG, Op.getNode(), TCChain) &&
9145 return !CI.second.getNode() ? DAG.getRoot() : CI.first;
9178 case ISD::BITCAST: return ExpandBITCAST(Op.getNode(), DAG, Subtarget);
9181 case ISD::SRA: return LowerShift(Op.getNode(), DAG, Subtarget);
9182 case ISD::SREM: return LowerREM(Op.getNode(), DAG);
9183 case ISD::UREM: return LowerREM(Op.getNode(), DAG);
9188 case ISD::CTTZ_ZERO_UNDEF: return LowerCTTZ(Op.getNode(), DAG, Subtarget);
9189 case ISD::CTPOP: return LowerCTPOP(Op.getNode(), DAG, Subtarget);
9326 if (Res.getNode())
10916 if (!isConditionalZeroOrAllOnes(Slct.getNode(), AllOnes, CCOp, SwapSelectOps,
10938 if (N0.getNode()->hasOneUse())
10941 if (N1.getNode()->hasOneUse())
10963 if (!IsVUZPShuffleNode(N0.getNode()) || N0.getNode() != N1.getNode() ||
10963 if (!IsVUZPShuffleNode(N0.getNode()) || N0.getNode() != N1.getNode() ||
10963 if (!IsVUZPShuffleNode(N0.getNode()) || N0.getNode() != N1.getNode() ||
10975 SDNode *Unzip = N0.getNode();
11001 if (!IsVUZPShuffleNode(N00.getNode()) || N00.getNode() != N10.getNode() ||
11001 if (!IsVUZPShuffleNode(N00.getNode()) || N00.getNode() != N10.getNode() ||
11001 if (!IsVUZPShuffleNode(N00.getNode()) || N00.getNode() != N10.getNode() ||
11065 SDNode *V = Vec.getNode();
11079 if (V != ExtVec0->getOperand(0).getNode() ||
11080 V != ExtVec1->getOperand(0).getNode())
11210 SDValue HiMLALResult(SMLAL.getNode(), 1);
11211 SDValue LoMLALResult(SMLAL.getNode(), 0);
11253 SDNode *AddcSubcNode = AddeSubeNode->getOperand(2).getNode();
11264 if (AddcSubcOp0.getNode() == AddcSubcOp1.getNode())
11264 if (AddcSubcOp0.getNode() == AddcSubcOp1.getNode())
11285 if (AddeSubeOp0.getNode() == AddeSubeOp1.getNode())
11285 if (AddeSubeOp0.getNode() == AddeSubeOp1.getNode())
11333 if (AddcSubcNode == HiAddSub->getNode() ||
11334 AddcSubcNode->isPredecessorOf(HiAddSub->getNode()))
11351 LowAddSub->getNode()->getOpcode() == ISD::Constant &&
11352 static_cast<ConstantSDNode *>(LowAddSub->getNode())->getZExtValue() ==
11377 SDValue HiMLALResult(MLALNode.getNode(), 1);
11380 SDValue LoMLALResult(MLALNode.getNode(), 0);
11400 SDNode* AddcNode = AddeNode->getOperand(2).getNode();
11408 UmlalNode = AddcNode->getOperand(0).getNode();
11411 UmlalNode = AddcNode->getOperand(1).getNode();
11423 AddeNode->getOperand(1).getNode() == UmlalNode) ||
11424 (AddeNode->getOperand(0).getNode() == UmlalNode &&
11433 DAG.ReplaceAllUsesOfValueWith(SDValue(AddeNode, 0), SDValue(UMAAL.getNode(), 1));
11434 DAG.ReplaceAllUsesOfValueWith(SDValue(AddcNode, 0), SDValue(UMAAL.getNode(), 0));
11449 SDNode* AddcNode = N->getOperand(2).getNode();
11450 SDNode* AddeNode = N->getOperand(3).getNode();
11455 (AddeNode->getOperand(2).getNode() == AddcNode))
11576 if (N0.getNode()->hasOneUse())
11769 if (N1.getNode()->hasOneUse())
11924 SDNode *N0 = N->getOperand(0).getNode();
12032 if (Val.getNode()) {
12078 if ((SRL.getOperand(0).getNode() != SHL.getOperand(0).getNode()) ||
12078 if ((SRL.getOperand(0).getNode() != SHL.getOperand(0).getNode()) ||
12082 SDNode *SMULLOHI = SRL.getOperand(0).getNode();
12339 if (Val.getNode()) {
12483 SDValue NewFrom = ParseBFI(V.getNode(), NewToMask, NewFromMask);
12547 SDValue From2 = ParseBFI(CombineBFI.getNode(), ToMask2, FromMask2);
12581 SDNode *InNode = InDouble.getNode();
12625 Op0.getNode() == Op1.getNode() &&
12625 Op0.getNode() == Op1.getNode() &&
12639 SDNode *Elt = N->getOperand(i).getNode();
12672 DCI.AddToWorklist(V.getNode());
12760 DCI.AddToWorklist(V.getNode());
12767 DCI.AddToWorklist(Vec.getNode());
12796 SDNode *Elt = N->getOperand(1).getNode();
12808 DCI.AddToWorklist(Vec.getNode());
12809 DCI.AddToWorklist(V.getNode());
12884 for (SDNode::use_iterator UI = Addr.getNode()->use_begin(),
12885 UE = Addr.getNode()->use_end(); UI != UE; ++UI) {
12896 Visited.insert(Addr.getNode());
12979 ConstantSDNode *CInc = dyn_cast<ConstantSDNode>(Inc.getNode());
13070 NewResults.push_back(SDValue(UpdN.getNode(), i));
13079 NewResults.push_back(SDValue(UpdN.getNode(), NumResultVecs+1)); // chain
13081 DCI.CombineTo(User, SDValue(UpdN.getNode(), NumResultVecs));
13108 SDNode *VLD = N->getOperand(0).getNode();
13163 DCI.CombineTo(User, SDValue(VLDDup.getNode(), ResNo));
13170 VLDDupResults.push_back(SDValue(VLDDup.getNode(), n));
13171 VLDDupResults.push_back(SDValue(VLDDup.getNode(), NumVecs));
13222 LoadSDNode *LD = dyn_cast<LoadSDNode>(Op.getNode());
13413 if (StVal.getNode()->getOpcode() == ARMISD::VMOVDRR &&
13414 StVal.getNode()->hasOneUse()) {
13420 St->getChain(), DL, StVal.getNode()->getOperand(isBigEndian ? 1 : 0),
13427 StVal.getNode()->getOperand(isBigEndian ? 0 : 1),
13434 StVal.getNode()->getOpcode() == ISD::EXTRACT_VECTOR_ELT) {
13449 DCI.AddToWorklist(Vec.getNode());
13450 DCI.AddToWorklist(ExtElt.getNode());
13451 DCI.AddToWorklist(V.getNode());
13537 unsigned OpOpcode = Op.getNode()->getOpcode();
13833 LoadSDNode *LD = cast<LoadSDNode>(N0.getNode());
13885 SDValue(NewLoad1.getNode(), 1),
13886 SDValue(NewLoad2.getNode(), 1));
14179 DAG.ReplaceAllUsesWith(Int.getNode(), LoopDec.getNode());
14179 DAG.ReplaceAllUsesWith(Int.getNode(), LoopDec.getNode());
14190 SDValue(LoopDec.getNode(), 1), Chain);
14192 SDValue EndArgs[] = { Chain, SDValue(LoopDec.getNode(), 0), Target };
14399 if (Res.getNode()) {
14825 !ExtVal->use_begin()->isOnlyUserOf(ExtVal.getNode()))
15284 getMVEIndexedAddressParts(Ptr.getNode(), VT, Align, isSEXTLoad,
15289 isLegal = getT2IndexedAddressParts(Ptr.getNode(), VT, isSEXTLoad, Base,
15292 isLegal = getARMIndexedAddressParts(Ptr.getNode(), VT, isSEXTLoad, Base,
15447 ConstantSDNode *Pos = cast<ConstantSDNode>(Op.getOperand(1).getNode());
15909 if (Result.getNode()) {
15990 RTLIB::Libcall LC = getDivRemLibcall(Op.getNode(),
15994 TargetLowering::ArgListTy Args = getDivRemArgList(Op.getNode(),
16004 InChain = WinDBZCheckDenominator(DAG, Op.getNode(), InChain);
16055 SDNode *ResNode = CallResult.first.getNode();
16198 SDValue(Lo.getNode(), 1));
lib/Target/AVR/AVRISelDAGToDAG.cpp 227 if (SelectAddr(Op.getNode(), Op, Base, Disp)) {
lib/Target/AVR/AVRISelLowering.cpp 282 const SDNode *N = Op.getNode();
782 Op = LD->getBasePtr().getNode();
790 Op = ST->getBasePtr().getNode();
1287 if (InFlag.getNode()) {
1425 if (Flag.getNode()) {
2001 if (Result.getNode()) {
lib/Target/BPF/BPFISelDAGToDAG.cpp 259 SDNode *LDAddrNode = LD->getOperand(1).getNode();
267 SDNode *OP1N = OP1.getNode();
274 dyn_cast<GlobalAddressSDNode>(OP1N->getOperand(0).getNode());
275 const ConstantSDNode *CDN = dyn_cast<ConstantSDNode>(OP2.getNode());
285 dyn_cast<GlobalAddressSDNode>(OP1.getNode()))
lib/Target/BPF/BPFISelLowering.cpp 388 if (InFlag.getNode())
448 if (Flag.getNode())
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp 70 int32_t Inc = cast<ConstantSDNode>(Offset.getNode())->getSExtValue();
241 SelectStore(TS.getNode());
242 StoreN = Handle.getValue().getNode();
272 SDNode *C = Ch.getNode();
300 if (C->getNumOperands() < 4 || Loc.getNode() != C->getOperand(3).getNode())
300 if (C->getNumOperands() < 4 || Loc.getNode() != C->getOperand(3).getNode())
469 int32_t Inc = cast<ConstantSDNode>(Offset.getNode())->getSExtValue();
688 ReplaceNode(N, R.getNode());
689 SelectCode(R.getNode());
797 ReplaceNode(N, E.getNode());
812 int Mask = -cast<ConstantSDNode>(A.getNode())->getSExtValue();
829 ReplaceNode(T, Op.getNode());
954 SDValue SY = (S0.getNode() == I) ? S1 : S0;
964 SDNode *SYNode = SY.getNode();
985 if (ConstantSDNode *SC = dyn_cast<ConstantSDNode>(V.getNode()))
1001 if (SOp.getOpcode() == ISD::SELECT && SOp.getNode()->hasOneUse()) {
1009 DAG.ReplaceAllUsesWith(I, NewSel.getNode());
1013 DAG.ReplaceAllUsesWith(I, NewSel.getNode());
1049 ConstantSDNode *CN = dyn_cast<ConstantSDNode>(C.getNode());
1056 ConstantSDNode *EN = dyn_cast<ConstantSDNode>(T2.getNode());
1072 ReplaceNode(T0.getNode(), NewShl.getNode());
1072 ReplaceNode(T0.getNode(), NewShl.getNode());
1111 ConstantSDNode *SN = dyn_cast<ConstantSDNode>(S.getOperand(1).getNode());
1119 ConstantSDNode *MN = dyn_cast<ConstantSDNode>(T0.getOperand(1).getNode());
1148 ReplaceNode(T0.getNode(), NewShl.getNode());
1148 ReplaceNode(T0.getNode(), NewShl.getNode());
1201 DAG.ReplaceAllUsesWith(U, Sel.getNode());
1608 return isa<ConstantSDNode>(N->getOperand(1).getNode());
1646 assert(A.Value.getNode() && B.Value.getNode());
1646 assert(A.Value.getNode() && B.Value.getNode());
1736 if (!Result.Value.getNode() || Result.Weight > L.Weight ||
1744 if (Result.Value.getNode()) {
1763 if (!Result.Value.getNode() || Result.Weight > L.Weight ||
1771 if (Result.Value.getNode()) {
1800 if (!isa<ConstantSDNode>(Val.getOperand(1).getNode()))
1813 if (isa<ConstantSDNode>(Ops[i].getNode()) &&
1829 if (isa<ConstantSDNode>(Ops[i].getNode()) &&
1892 if ((!isOpcodeHandled(Op0.getNode()) || RootWeights.count(Op0.getNode())) &&
1892 if ((!isOpcodeHandled(Op0.getNode()) || RootWeights.count(Op0.getNode())) &&
1893 (!isOpcodeHandled(Op1.getNode()) || RootWeights.count(Op1.getNode()))) {
1893 (!isOpcodeHandled(Op1.getNode()) || RootWeights.count(Op1.getNode()))) {
1894 SDNode *Op0N = Op0.getNode();
1897 Weight = getWeight(balanceSubTree(Op0N).getNode());
1902 SDNode *Op1N = N->getOperand(1).getNode(); // Op1 may have been RAUWd
1904 Weight += getWeight(balanceSubTree(Op1N).getNode());
1910 RootHeights[N] = std::max(getHeight(N->getOperand(0).getNode()),
1911 getHeight(N->getOperand(1).getNode())) + 1;
1942 ((isOpcodeHandled(Op0.getNode()) && Op0.getOpcode() == ISD::SHL &&
1944 (isOpcodeHandled(Op1.getNode()) && Op1.getOpcode() == ISD::SHL &&
1957 if (Child.getNode() != N && RootWeights.count(Child.getNode())) {
1957 if (Child.getNode() != N && RootWeights.count(Child.getNode())) {
1960 int Weight = RootWeights[Child.getNode()];
1962 Child = balanceSubTree(Child.getNode());
1964 Weight = getWeight(Child.getNode());
1983 if (!Mul1.Value.getNode()) {
1998 } else if (!isOpcodeHandled(Child.getNode())) {
2000 int Weight = getWeight(Child.getNode());
2002 NodeHeights[Child] = getHeight(Child.getNode());
2005 if (isTargetConstant(Child) && !GA.Value.getNode())
2019 Op1 = getMultiplierForSHL(Child.getNode());
2061 } else if (Mul1.Value.getNode()) {
2065 if (Mul2.Value.getNode())
2074 if (NOpcode == ISD::ADD && GA.Value.getNode() && Leaves.hasConst() &&
2094 NodeHeights[GA.Value] = getHeight(GA.Value.getNode());
2110 if (NOpcode == ISD::ADD && GA.Value.getNode()) {
2112 if (SHL.Value.getNode()) {
2122 if (GA.Value.getNode())
2142 if (!L1.Value.getNode())
2153 if ((RootWeights.count(V0.getNode()) && RootWeights[V0.getNode()] == -2) ||
2153 if ((RootWeights.count(V0.getNode()) && RootWeights[V0.getNode()] == -2) ||
2154 (RootWeights.count(V1.getNode()) && RootWeights[V1.getNode()] == -2)) {
2154 (RootWeights.count(V1.getNode()) && RootWeights[V1.getNode()] == -2)) {
2214 if (N != NewRoot.getNode()) {
2219 CurDAG->ReplaceAllUsesWith(N, NewRoot.getNode());
2226 RootWeights[NewRoot.getNode()] = Leaves.top().Weight;
2227 RootHeights[NewRoot.getNode()] = Height;
2243 if (RootWeights.count(BasePtr.getNode()))
2252 Worklist.push_back(BasePtr.getOperand(0).getNode());
2253 Worklist.push_back(BasePtr.getOperand(1).getNode());
2262 Worklist.push_back(N->getOperand(0).getNode());
2263 Worklist.push_back(N->getOperand(1).getNode());
2277 RootWeights[BasePtr.getNode()] = -1;
2278 SDValue NewBasePtr = balanceSubTree(BasePtr.getNode(), /*TopLevel=*/ true);
lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp 619 bool isValue() const { return OpV.getNode() != nullptr; }
711 OpV.getNode()->print(OS, &G);
968 WorkQ.insert(W->getOperand(j).getNode());
1022 ? Ops.front().getNode()
1027 SDNode *OutN = Output.back().getNode();
1415 assert(L.getNode());
1436 ISel.ReplaceNode(N, LV.getNode());
1438 if (AllNodes.count(LV.getNode())) {
1452 SubNodes.insert(LV.getNode());
1457 if (AllNodes.count(Op.getNode()))
1459 SubNodes.insert(Op.getNode());
1997 DAG.RemoveDeadNode(BV.getNode());
2043 ISel.ReplaceNode(N, ISel.selectUndef(SDLoc(SN), ResTy).getNode());
2084 if (auto *CN = dyn_cast<ConstantSDNode>(RotV.getNode())) {
2087 NewN = VecV.getNode();
lib/Target/Hexagon/HexagonISelLowering.cpp 227 if (Flag.getNode())
514 if (Glue.getNode())
566 if (!isa<ConstantSDNode>(Offset.getNode()))
570 int32_t V = cast<ConstantSDNode>(Offset.getNode())->getSExtValue();
679 Size.getNode()->dump(&DAG);
1901 if (auto *CN = dyn_cast<const ConstantSDNode>(Op1.getNode()))
2039 if (auto *BVN = dyn_cast<BuildVectorSDNode>(Op.getOperand(1).getNode())) {
2069 if (isa<ConstantSDNode>(Op.getOperand(1).getNode()))
2108 if (auto *CN = dyn_cast<ConstantSDNode>(V.getNode())) {
2111 } else if (auto *CN = dyn_cast<ConstantFPSDNode>(V.getNode())) {
2485 auto *CN = dyn_cast<ConstantSDNode>(P.getNode());
2548 for (SDValue P : Op.getNode()->op_values()) {
2631 LoadSDNode *LN = cast<LoadSDNode>(Op.getNode());
2641 StoreSDNode *SN = cast<StoreSDNode>(Op.getNode());
2657 LoadSDNode *LN = cast<LoadSDNode>(Op.getNode());
2748 SDVTList VTs = Op.getNode()->getVTList();
2784 return DAG.getNode(HexagonISD::ADDC, dl, Op.getNode()->getVTList(),
2788 SDValue SubC = DAG.getNode(HexagonISD::SUBC, dl, Op.getNode()->getVTList(),
2839 Op.getNode()->dumpr(&DAG);
lib/Target/Hexagon/HexagonISelLoweringHVX.cpp 375 if (!SplatV.getNode())
383 assert(SplatV.getNode());
384 auto *IdxN = dyn_cast<ConstantSDNode>(SplatV.getNode());
423 if (Vec.getNode() != nullptr && T.getNode() != Vec.getNode())
423 if (Vec.getNode() != nullptr && T.getNode() != Vec.getNode())
423 if (Vec.getNode() != nullptr && T.getNode() != Vec.getNode())
596 if (const auto *N = dyn_cast<ConstantSDNode>(V.getNode()))
601 if (const auto *N = dyn_cast<ConstantSDNode>(V.getNode()))
765 unsigned Idx = cast<ConstantSDNode>(IdxV.getNode())->getZExtValue();
813 unsigned Idx = cast<ConstantSDNode>(IdxV.getNode())->getZExtValue();
893 if (const auto *CN = dyn_cast<const ConstantSDNode>(IdxV.getNode())) {
918 auto *IdxN = dyn_cast<ConstantSDNode>(IdxV.getNode());
978 auto *IdxN = dyn_cast<ConstantSDNode>(IdxV.getNode());
1057 for (SDValue V : Op.getNode()->ops())
1100 ArrayRef<SDUse> U(Op.getNode()->ops());
1117 for (SDValue V : Op.getNode()->op_values()) {
1168 unsigned Idx = cast<ConstantSDNode>(IdxV.getNode())->getZExtValue();
1453 for (SDValue A : Op.getNode()->ops()) {
1459 if (const auto *N = dyn_cast<const VTSDNode>(A.getNode()))
1476 LSBaseSDNode *BN = cast<LSBaseSDNode>(Op.getNode());
1521 llvm::any_of(Op.getNode()->ops(), [this] (SDValue V) {
1612 llvm::any_of(Op.getNode()->ops(),
lib/Target/Lanai/LanaiISelDAGToDAG.cpp 293 return ReplaceNode(Node, New.getNode());
300 return ReplaceNode(Node, New.getNode());
lib/Target/Lanai/LanaiISelLowering.cpp 354 if (Result.getNode()) {
586 if (Flag.getNode())
690 if (StackPtr.getNode() == nullptr)
751 if (InFlag.getNode())
1426 if (!isConditionalZeroOrAllOnes(Slct.getNode(), AllOnes, CCOp, SwapSelectOps,
1447 if (N0.getNode()->hasOneUse())
1450 if (N1.getNode()->hasOneUse())
1463 if (N1.getNode()->hasOneUse())
lib/Target/MSP430/MSP430ISelDAGToDAG.cpp 67 if (BaseType == RegBase && Base.Reg.getNode() != nullptr) {
69 Base.Reg.getNode()->dump();
172 if (AM.BaseType != MSP430ISelAddressMode::RegBase || AM.Base.Reg.getNode()) {
201 && AM.Base.Reg.getNode() == nullptr) {
210 if (!MatchAddress(N.getNode()->getOperand(0), AM) &&
211 !MatchAddress(N.getNode()->getOperand(1), AM))
214 if (!MatchAddress(N.getNode()->getOperand(1), AM) &&
215 !MatchAddress(N.getNode()->getOperand(0), AM))
255 if (!AM.Base.Reg.getNode())
370 ReplaceUses(SDValue(N1.getNode(), 2), SDValue(ResNode, 2));
372 ReplaceUses(SDValue(N1.getNode(), 1), SDValue(ResNode, 1));
lib/Target/MSP430/MSP430ISelLowering.cpp 780 if (Flag.getNode())
838 if (!StackPtr.getNode())
900 if (InFlag.getNode())
946 SDNode* N = Op.getNode();
lib/Target/Mips/MipsISelDAGToDAG.cpp 71 .getNode();
256 ISD::SUB, DL, VT, CurDAG->getConstant(0, DL, VT).getNode(), C.getNode());
256 ISD::SUB, DL, VT, CurDAG->getConstant(0, DL, VT).getNode(), C.getNode());
260 ReplaceNode(Node, NewNode.getNode());
261 SelectCode(NewNode.getNode());
lib/Target/Mips/MipsISelLowering.cpp 2146 SDNode *Node = Op.getNode();
2961 if (InFlag.getNode())
3039 MipsCCState::getSpecialCallingConvForCallee(Callee.getNode(), Subtarget));
3042 dyn_cast_or_null<const ExternalSymbolSDNode>(Callee.getNode());
3348 dyn_cast_or_null<const ExternalSymbolSDNode>(CLI.Callee.getNode());
3740 if (Flag.getNode())
4106 if (Result.getNode()) {
4292 if (Val.getNode())
4363 cast<StoreSDNode>(Store.getNode())->getMemOperand()->setValue(
lib/Target/Mips/MipsSEISelDAGToDAG.cpp 557 if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
633 if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
664 if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
698 if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
720 if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
843 ReplaceNode(Node, Reg.getNode());
877 ReplaceNode(Node, ChainOut.getNode());
961 ReplaceNode(Node, ResNode.getNode());
lib/Target/Mips/MipsSEISelLowering.cpp 534 BuildVectorSDNode *Node = dyn_cast<BuildVectorSDNode>(N.getNode());
642 if (!IfClr.getNode() && isVSplat(Op0Op1, Mask, IsLittleEndian)) {
659 if (!IfClr.getNode()) {
696 if (!IfClr.getNode())
699 assert(Cond.getNode() && IfSet.getNode());
699 assert(Cond.getNode() && IfSet.getNode());
1009 if (ISD::isBuildVectorAllOnes(Op0.getNode()))
1011 else if (ISD::isBuildVectorAllOnes(Op1.getNode()))
1055 if (Val.getNode()) {
1058 Val.getNode()->printrWithDepth(dbgs(), &DAG); dbgs() << "\n");
1338 if (In64.getNode())
1356 SDValue Vals[] = { Out, SDValue(Val.getNode(), 1) };
1490 if (!Exp2Imm.getNode()) {
lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp 614 for (const auto &U : Vector.getNode()->uses()) {
928 } else if (PointerSize == 64 ? SelectADDRsi64(N1.getNode(), N1, Base, Offset)
929 : SelectADDRsi(N1.getNode(), N1, Base, Offset)) {
941 } else if (PointerSize == 64 ? SelectADDRri64(N1.getNode(), N1, Base, Offset)
942 : SelectADDRri(N1.getNode(), N1, Base, Offset)) {
1097 ? SelectADDRsi64(Op1.getNode(), Op1, Base, Offset)
1098 : SelectADDRsi(Op1.getNode(), Op1, Base, Offset)) {
1124 ? SelectADDRri64(Op1.getNode(), Op1, Base, Offset)
1125 : SelectADDRri(Op1.getNode(), Op1, Base, Offset)) {
1365 } else if (TM.is64Bit() ? SelectADDRri64(Op1.getNode(), Op1, Base, Offset)
1366 : SelectADDRri(Op1.getNode(), Op1, Base, Offset)) {
1773 Value.getNode()->getSimpleValueType(0).SimpleTy;
1792 ? SelectADDRsi64(BasePtr.getNode(), BasePtr, Base, Offset)
1793 : SelectADDRsi(BasePtr.getNode(), BasePtr, Base, Offset)) {
1811 ? SelectADDRri64(BasePtr.getNode(), BasePtr, Base, Offset)
1812 : SelectADDRri(BasePtr.getNode(), BasePtr, Base, Offset)) {
1969 } else if (PointerSize == 64 ? SelectADDRsi64(N2.getNode(), N2, Base, Offset)
1970 : SelectADDRsi(N2.getNode(), N2, Base, Offset)) {
1991 } else if (PointerSize == 64 ? SelectADDRri64(N2.getNode(), N2, Base, Offset)
1992 : SelectADDRri(N2.getNode(), N2, Base, Offset)) {
3413 Val = LHS.getNode()->getOperand(0);
3414 Start = LHS.getNode()->getOperand(1);
3703 if (SelectADDRri(Op.getNode(), Op, Op0, Op1)) {
lib/Target/NVPTX/NVPTXISelLowering.cpp 1630 GlobalAddressSDNode *Func = dyn_cast<GlobalAddressSDNode>(Callee.getNode());
1890 SDNode *Node = Op.getNode();
1896 EVT VVT = SubOp.getNode()->getValueType(0);
1938 if (isa<ConstantSDNode>(Index.getNode()))
1947 SDLoc dl(Op.getNode());
2212 SDLoc DL(Op.getNode());
2249 SDNode *Node = Op.getNode();
2288 SDNode *N = Op.getNode();
2411 SDNode *Node = Op.getNode();
2596 if (P.getNode())
2597 P.getNode()->setIROrder(idx + 1);
2640 if (p.getNode())
2641 p.getNode()->setIROrder(idx + 1);
4361 !N0.getNode()->hasOneUse())
4385 for (SDNode::use_iterator UI = N0.getNode()->use_begin(),
4386 UE = N0.getNode()->use_end();
4397 int orderNo2 = N0.getNode()->getIROrder();
4408 const SDNode *left = N0.getOperand(0).getNode();
4409 const SDNode *right = N0.getOperand(1).getNode();
4525 if (AExt.getNode() != nullptr) {
4916 unsigned IntrinNo = cast<ConstantSDNode>(Intrin.getNode())->getZExtValue();
lib/Target/PowerPC/PPCISelDAGToDAG.cpp 480 .getNode();
506 return isInt32Immediate(N.getNode(), Imm);
512 return isInt64Immediate(N.getNode(), Imm);
570 && isInt32Immediate(N->getOperand(1).getNode(), Imm);
598 !isInt32Immediate(N->getOperand(1).getNode(), Shift) || (Shift > 31))
1166 LLVM_DEBUG(dbgs() << "\tbit group for " << V.getNode() << " RLAmt = " << R
1412 if (ISD::isZEXTLoad(V.getNode()) && V.getResNo() == 0) {
1493 if (LastValue.getNode())
1501 if (LastValue.getNode())
1621 << BG.V.getNode() << " RLAmt = " << BG.RLAmt << " ["
1637 << I->V.getNode() << " RLAmt = " << I->RLAmt << " ["
1664 LLVM_DEBUG(dbgs() << "\tcombining bit group for " << I->V.getNode()
1789 LLVM_DEBUG(dbgs() << "\t\trotation groups for " << VRI.V.getNode()
1922 return Res.getNode();
2145 LLVM_DEBUG(dbgs() << "\t\trotation groups for " << VRI.V.getNode()
2356 return Res.getNode();
2563 return ConvOp.getNode();
2640 return CRBit.getNode();
3562 for (auto CompareUse : Compare.getNode()->uses())
3730 if (isInt64Immediate(RHS.getNode(), Imm)) {
3761 if (isInt64Immediate(RHS.getNode(), Imm) && isUInt<16>(Imm))
4575 isRotateAndMask(N->getOperand(0).getNode(), Imm, false, SH, MB, ME)) {
4594 if (isInt64Immediate(N->getOperand(1).getNode(), Imm64) &&
4603 isInt32Immediate(Op0.getOperand(1).getNode(), Imm) && Imm <= MB) {
4605 auto ResultType = Val.getNode()->getValueType(0);
4623 isInt32Immediate(Val.getOperand(1).getNode(), Imm) && Imm <= MB) {
4636 if (isInt64Immediate(N->getOperand(1).getNode(), Imm64) &&
4696 selectFrameIndex(N, N->getOperand(0).getNode(), (int)Imm);
4749 selectFrameIndex(N, N->getOperand(0).getNode(), (int)Imm);
4757 if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::AND, Imm) &&
4771 if (isOpcWithIntImmediate(N->getOperand(0).getNode(), ISD::AND, Imm) &&
4804 SRIdxVal, SDValue(AndI.getNode(), 1) /* glue */);
5388 for (const SDValue &O : V.getNode()->ops()) {
5491 SDValue O0 = UserO0.getNode() == N ? Val : UserO0;
5492 SDValue O1 = UserO1.getNode() == N ? Val : UserO1;
5496 O0.getNode(), O1.getNode());
5496 O0.getNode(), O1.getNode());
5548 LLVM_DEBUG(Res.getNode()->dump(CurDAG));
5587 SDNode *Op2 = User->getOperand(2).getNode();
5709 ResNode = MachineNode->getOperand(0).getNode();
5712 ResNode = MachineNode->getOperand(1).getNode();
5715 ResNode = MachineNode->getOperand(0).getNode();
5781 ResNode = MachineNode->getOperand(0).getNode();
5788 ResNode = MachineNode->getOperand(1).getNode();
5791 ResNode = MachineNode->getOperand(0).getNode();
5828 ResNode = MachineNode->getOperand(1).getNode();
5831 ResNode = MachineNode->getOperand(0).getNode();
5892 ResNode = MachineNode->getOperand(1).getNode();
5895 ResNode = MachineNode->getOperand(0).getNode();
5941 ResNode = MachineNode->getOperand(0).getNode();
5972 ResNode = MachineNode->getOperand(0).getNode();
6011 ResNode = MachineNode->getOperand(1).getNode();
6013 ResNode = MachineNode->getOperand(2).getNode();
6075 ToPromote.insert(Op32.getNode());
6082 ToPromote.insert(Op32.getNode());
6093 ToPromote.insert(Op32.getNode());
6100 ToPromote.insert(Op32.getNode());
6107 ToPromote.insert(Op32.getNode());
6121 ToPromote.insert(Op32.getNode());
6138 ToPromote.insert(Op32.getNode());
6154 ToPromote.insert(Op32.getNode());
6170 ToPromote.insert(Op32.getNode());
6193 ToPromote.insert(Op32.getNode());
6268 if (!ToPromote.count(UN) && UN != ISR.getNode()) {
6318 if (!ToPromote.count(V.getNode()) && V.getValueType() == MVT::i32 &&
6323 ISR.getNode()->getVTList(), ReplOpOps);
6359 LLVM_DEBUG(Op32.getNode()->dump(CurDAG));
6362 ReplaceUses(N, Op32.getNode());
6577 (void)CurDAG->UpdateNodeOperands(HBase.getNode(), HBase.getOperand(0),
6581 if (Base.getNode()->use_empty())
6582 CurDAG->RemoveDeadNode(Base.getNode());
lib/Target/PowerPC/PPCISelLowering.cpp 1447 else if (ISD::isEXTLoad(Op.getNode()) || ISD::isNON_EXTLoad(Op.getNode())) {
1447 else if (ISD::isEXTLoad(Op.getNode()) || ISD::isNON_EXTLoad(Op.getNode())) {
2123 if (!UniquedVals[i&(Multiple-1)].getNode())
2138 if (!UniquedVals[i].getNode()) continue; // Must have been undefs.
2145 if (!UniquedVals[Multiple-1].getNode())
2152 if (!UniquedVals[Multiple-1].getNode())
2165 if (!OpVal.getNode())
2171 if (!OpVal.getNode()) return SDValue(); // All UNDEF: use implicit def.
2253 return isIntS16Immediate(Op.getNode(), Imm);
2594 if (Val == Base || Base.getNode()->isPredecessorOf(Val.getNode()))
2594 if (Val == Base || Base.getNode()->isPredecessorOf(Val.getNode()))
3030 SDNode *Node = Op.getNode();
4760 .getNode();
4855 Chain = SDValue(LROpOut.getNode(), 1);
4862 Chain = SDValue(FPOpOut.getNode(), 1);
5104 makeArrayRef(MTCTROps, InFlag.getNode() ? 3 : 2));
5122 if (Callee.getNode()) {
5248 if (InFlag.getNode())
5555 CallSeqStart.getNode()->getOperand(0),
5561 DAG.ReplaceAllUsesWith(CallSeqStart.getNode(),
5562 NewCallSeqStart.getNode());
5632 dl, VTs, makeArrayRef(Ops, InFlag.getNode() ? 2 : 1));
5653 CallSeqStart.getNode()->getOperand(0),
5659 DAG.ReplaceAllUsesWith(CallSeqStart.getNode(),
5660 NewCallSeqStart.getNode());
6120 if (ArgVal.getNode())
6964 if (Flag.getNode())
7127 SDValue Ops[] = { Result, SDValue(NewLD.getNode(), 1) };
7561 assert(TF.getNode() != NewResChain.getNode() &&
7561 assert(TF.getNode() != NewResChain.getNode() &&
7565 DAG.UpdateNodeOperands(TF.getNode(), ResChain, NewResChain);
7572 SDNode *Origin = Op.getOperand(0).getNode();
8221 (!IsLoad && !V->isOnlyUserOf(V->getOperand(i).getNode())))
8264 BuildVectorSDNode *BVN = dyn_cast<BuildVectorSDNode>(Op.getNode());
8391 if (InputLoad->getNode()->hasNUsesOfValue(128 / ElementSize, 0) &&
9577 auto *AtomicNode = cast<AtomicSDNode>(Op.getNode());
9654 SDNode *N = Op.getNode();
9714 LoadSDNode *LN = cast<LoadSDNode>(Op.getNode());
9802 StoreSDNode *SN = cast<StoreSDNode>(Op.getNode());
10093 NewLoad[1], Op0.getNode()->getFlags());
11752 bool isGA1 = TLI.isGAPlusOffset(Loc.getNode(), GV1, Offset1);
11753 bool isGA2 = TLI.isGAPlusOffset(BaseLoc.getNode(), GV2, Offset2);
11879 SmallVector<SDNode *, 8> Queue(1, Chain.getNode());
11894 if (!Visited.count(ChainLD->getChain().getNode()))
11895 Queue.push_back(ChainLD->getChain().getNode());
11928 cast<MemSDNode>(*UI)->getChain().getNode() == LoadRoot) ||
12124 if (!Visited.insert(BinOp.getNode()).second)
12167 for (SDNode::use_iterator UI = Inputs[i].getNode()->use_begin(),
12168 UE = Inputs[i].getNode()->use_end();
12191 for (SDNode::use_iterator UI = PromOps[i].getNode()->use_begin(),
12192 UE = PromOps[i].getNode()->use_end();
12275 SmallVector<SDValue, 3> Ops(PromOp.getNode()->op_begin(),
12276 PromOp.getNode()->op_end());
12340 if (!Visited.insert(BinOp.getNode()).second)
12380 for (SDNode::use_iterator UI = Inputs[i].getNode()->use_begin(),
12381 UE = Inputs[i].getNode()->use_end();
12405 for (SDNode::use_iterator UI = PromOps[i].getNode()->use_begin(),
12406 UE = PromOps[i].getNode()->use_end();
12513 if ((SelectTruncOp[0].count(PromOp.getNode()) &&
12515 (SelectTruncOp[1].count(PromOp.getNode()) &&
12522 SmallVector<SDValue, 3> Ops(PromOp.getNode()->op_begin(),
12523 PromOp.getNode()->op_end());
12544 auto SI0 = SelectTruncOp[0].find(PromOp.getNode());
12547 auto SI1 = SelectTruncOp[1].find(PromOp.getNode());
12612 if (LoadSDNode *LD = dyn_cast<LoadSDNode>(Op.getNode()))
13047 LoadSDNode *LDN = cast<LoadSDNode>(FirstOperand.getNode());
13092 DCI.AddToWorklist(Src.getNode());
13108 DCI.AddToWorklist(FP.getNode());
13167 DCI.AddToWorklist(Load.getNode());
13171 DCI.AddToWorklist(Swap.getNode());
13176 DCI.AddToWorklist(N.getNode());
13236 DCI.AddToWorklist(Src.getNode());
13241 DCI.AddToWorklist(Swap.getNode());
13247 DCI.AddToWorklist(Store.getNode());
13282 DCI.AddToWorklist(Val.getNode());
13292 DCI.AddToWorklist(Val.getNode());
13305 DCI.AddToWorklist(Val.getNode());
13411 if (ISD::isNormalLoad(N->getOperand(0).getNode())) {
13436 N->getOperand(1).getNode()->hasOneUse() &&
13599 MVT::f32, dl, SDValue(FloatLoad.getNode(), 1), AddPtr,
13613 SDValue(FloatLoad2.getNode(), 1));
13783 SDNode *BasePtr = Add->getOperand(0).getNode();
13799 SDNode *BasePtr = Add->getOperand(0).getNode();
13834 ISD::isBuildVectorAllZeros(V1.getOperand(0).getNode()) &&
13840 ISD::isBuildVectorAllZeros(V2.getOperand(0).getNode()) &&
13883 if (ISD::isNON_EXTLoad(N->getOperand(0).getNode()) &&
13913 DCI.CombineTo(Load.getNode(), ResVal, BSLoad.getValue(1));
13931 SDNode *LHSN = N->getOperand(0).getNode();
13980 assert(Cond.getNode()->hasOneUse() &&
14020 assert(LHS.getNode()->hasOneUse() &&
14113 Created.push_back(Op.getNode());
14117 Created.push_back(Op.getNode());
14457 if (Result.getNode()) {
15241 SDValue(Addc.getNode(), 1));
15256 SDValue(Subc.getNode(), 1));
lib/Target/RISCV/RISCVISelDAGToDAG.cpp 119 ReplaceNode(Node, New.getNode());
147 isConstantMask(Op0.getNode(), Mask)) {
148 uint64_t ShAmt = cast<ConstantSDNode>(Op1.getNode())->getZExtValue();
204 SelectionDAG::allnodes_iterator Position(CurDAG->getRoot().getNode());
283 if (Base.getNode()->use_empty())
284 CurDAG->RemoveDeadNode(Base.getNode());
lib/Target/RISCV/RISCVISelLowering.cpp 954 !Op0.getNode()->hasOneUse())
1002 !Op0.getNode()->hasOneUse())
1990 cast<StoreSDNode>(Store.getNode())
2176 if (!StackPtr.getNode())
2234 if (!StackPtr.getNode())
2308 if (Glue.getNode())
2447 if (Glue.getNode()) {
lib/Target/Sparc/SparcISelDAGToDAG.cpp 72 .getNode();
291 if(PairedReg.getNode()) {
308 if (Glue.getNode())
318 ReplaceNode(N, New.getNode());
lib/Target/Sparc/SparcISelLowering.cpp 284 if (Flag.getNode())
363 if (Flag.getNode())
970 if (InFlag.getNode())
1272 if (InGlue.getNode())
1314 if (!RV.getNode()) {
2521 SDNode *Node = Op.getNode();
2728 LoadSDNode *LdNode = dyn_cast<LoadSDNode>(Op.getNode());
2761 SDValue OutChains[2] = { SDValue(Hi64.getNode(), 1),
2762 SDValue(Lo64.getNode(), 1) };
2770 LoadSDNode *LdNode = cast<LoadSDNode>(Op.getNode());
2782 StoreSDNode *StNode = dyn_cast<StoreSDNode>(Op.getNode());
2819 StoreSDNode *St = cast<StoreSDNode>(Op.getNode());
3247 if (Result.getNode()) {
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp 78 if (Base.getNode())
79 Base.getNode()->dump(DAG);
85 if (Index.getNode())
86 Index.getNode()->dump(DAG);
426 if (AM.hasIndexField() && !AM.Index.getNode()) {
584 (AM.Index.getNode() && expandAddress(AM, false)))
589 !shouldUseLA(AM.Base.getNode(), AM.Disp, AM.Index.getNode()))
589 !shouldUseLA(AM.Base.getNode(), AM.Disp, AM.Index.getNode()))
611 (SelectionDAGISel::getUninvalidatedNodeId(N.getNode()) >
613 DAG->RepositionNode(Pos->getIterator(), N.getNode());
619 SelectionDAGISel::InvalidateNodeId(N.getNode());
627 if (!Base.getNode())
640 insertDAGNode(CurDAG, Base.getNode(), Trunc);
655 if (!Index.getNode())
675 if (!selectAddress(Addr, AM) || AM.Index.getNode())
700 Regs[0].getNode() && Regs[1].getNode()) {
700 Regs[0].getNode() && Regs[1].getNode()) {
726 auto *MaskNode = dyn_cast<ConstantSDNode>(Op.getOperand(1).getNode());
787 auto *MaskNode = dyn_cast<ConstantSDNode>(N.getOperand(1).getNode());
810 auto *MaskNode = dyn_cast<ConstantSDNode>(N.getOperand(1).getNode());
833 auto *CountNode = dyn_cast<ConstantSDNode>(N.getOperand(1).getNode());
878 auto *CountNode = dyn_cast<ConstantSDNode>(N.getOperand(1).getNode());
905 auto *CountNode = dyn_cast<ConstantSDNode>(N.getOperand(1).getNode());
1006 if (N != New.getNode()) {
1009 ReplaceNode(N, New.getNode());
1010 N = New.getNode();
1047 ReplaceNode(N, New.getNode());
1082 if (auto *Load = dyn_cast<LoadSDNode>(Op0.getNode()))
1104 ReplaceNode(N, New.getNode());
1114 if (Op0.getNode())
1131 SelectCode(Upper.getNode());
1138 ReplaceNode(Node, Or.getNode());
1140 SelectCode(Or.getNode());
1158 ReplaceNode(Node, Op.getNode());
1161 ReplaceNode(Node, BitCast.getNode());
1162 SelectCode(BitCast.getNode());
1167 Node, CurDAG->getTargetExtractSubreg(SubRegIdx, DL, VT, Op).getNode());
1169 SelectCode(Op.getNode());
1249 if (!StoredVal.getNode()->hasNUsesOfValue(1, 0))
1258 if (!ISD::isNormalLoad(Load.getNode()))
1294 LoopWorklist.push_back(Op.getNode());
1301 if (Op.getNode() != LoadNode)
1302 LoopWorklist.push_back(Op.getNode());
1305 if (SDNode::hasPredecessorHelper(Load.getNode(), Visited, LoopWorklist, Max,
1396 ReplaceUses(SDValue(StoredVal.getNode(), 1), SDValue(Result, 0));
1554 cast<ConstantSDNode>(CCValid.getNode())->getZExtValue();
1556 cast<ConstantSDNode>(CCMask.getNode())->getZExtValue();
1730 return !N->isPredecessorOf(CCUser->getOperand(0).getNode());
1909 LLVM_DEBUG(Res.getNode()->dump(CurDAG));
lib/Target/SystemZ/SystemZISelLowering.cpp 1538 if (!StackPtr.getNode())
1597 if (Glue.getNode())
1701 if (Glue.getNode())
1908 SDValue OldChain = SDValue(Op.getNode(), 1);
1909 SDValue NewChain = SDValue(Intr.getNode(), 1);
1911 return Intr.getNode();
1925 return Intr.getNode();
1962 auto *ConstOp1 = dyn_cast<ConstantSDNode>(C.Op1.getNode());
2052 auto *Load = dyn_cast<LoadSDNode>(Op.getNode());
2537 if (!C.Op1.getNode()) {
3438 SDNode *N = Op.getNode();
3496 SDNode *N = Op.getNode();
3644 auto *Node = cast<AtomicSDNode>(Op.getNode());
3653 auto *Node = cast<AtomicSDNode>(Op.getNode());
3670 auto *Node = cast<AtomicSDNode>(Op.getNode());
3743 auto *Node = cast<AtomicSDNode>(Op.getNode());
3763 if (NegSrc2.getNode())
3778 auto *Node = cast<AtomicSDNode>(Op.getNode());
3902 auto *Node = cast<MemIntrinsicSDNode>(Op.getNode());
3926 DAG.ReplaceAllUsesOfValueWith(SDValue(Op.getNode(), 0), CC);
4325 EVT FromVT = Op.getNode() ? Op.getValueType() : VT;
4337 while (Op.getNode()) {
4560 if (!Op.getNode()) {
4587 if (!Single.getNode())
4609 if (Single.getNode() && (Count > 1 || isVectorElementLoad(Single)))
4674 if (!Constants[I].getNode())
4688 SDNode *Ld = Elems[I].getNode();
4724 auto *BVN = cast<BuildVectorSDNode>(Op.getNode());
4754 auto *VSN = cast<ShuffleVectorSDNode>(Op.getNode());
5322 DCI.AddToWorklist(Op.getNode());
5327 DCI.AddToWorklist(Op.getNode());
5362 DCI.AddToWorklist(Op.getNode());
5426 DCI.CombineTo(N0.getNode(), TruncSelect);
5493 if (ISD::isBuildVectorAllZeros(Op0.getNode())) {
5509 DCI.AddToWorklist(Op1.getNode());
5512 DCI.AddToWorklist(Op.getNode());
5553 Ops.push_back((Op.getNode() == N && Op.getResNo() == 0) ? Extract0 : Op);
5597 DCI.AddToWorklist(Value.getNode());
5608 Op1.getNode()->hasOneUse() &&
5627 Op1.getNode()->hasOneUse() &&
5629 ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(Op1.getNode());
5649 if (ISD::isNON_EXTLoad(N->getOperand(0).getNode()) &&
5674 DCI.CombineTo(Load.getNode(), ESLoad, ESLoad.getValue(1));
5706 DCI.AddToWorklist(Op.getNode());
5709 DCI.AddToWorklist(Op.getNode());
5757 if (U != Op0.getNode() &&
5769 DCI.AddToWorklist(VRound.getNode());
5773 DCI.AddToWorklist(Extract1.getNode());
5808 if (U != Op0.getNode() &&
5820 DCI.AddToWorklist(VExtend.getNode());
5824 DCI.AddToWorklist(Extract1.getNode());
5841 if (ISD::isNON_EXTLoad(N->getOperand(0).getNode()) &&
5871 DCI.CombineTo(Load.getNode(), ResVal, BSLoad.getValue(1));
5897 ISD::isNON_EXTLoad(Elt.getNode()) && Elt.hasOneUse())) {
5902 DCI.AddToWorklist(Vec.getNode());
5906 DCI.AddToWorklist(Elt.getNode());
5909 DCI.AddToWorklist(Vec.getNode());
5911 DCI.AddToWorklist(Elt.getNode());
5930 DCI.AddToWorklist(Op0.getNode());
5934 DCI.AddToWorklist(Op1.getNode());
5937 DCI.AddToWorklist(Op0.getNode());
5939 DCI.AddToWorklist(Op1.getNode());
5957 auto *ICmp = CCReg.getNode();
5960 auto *CompareLHS = ICmp->getOperand(0).getNode();
6006 auto *SHL = CompareLHS->getOperand(0).getNode();
6012 auto *IPM = SHL->getOperand(0).getNode();
lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp 96 cast<ConstantSDNode>(Node->getOperand(2).getNode())->getZExtValue();
lib/Target/WebAssembly/WebAssemblyISelLowering.cpp 1024 if (isa<FrameIndexSDNode>(Src.getNode())) {
1038 return Op.getNode()->getNumValues() == 1
1231 int Tag = cast<ConstantSDNode>(Op.getOperand(2).getNode())->getZExtValue();
1264 MVT ExtractedLaneT = static_cast<VTSDNode *>(Op.getOperand(1).getNode())
1274 static_cast<ConstantSDNode *>(Index.getNode())->getZExtValue();
1452 ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(Op.getNode())->getMask();
1479 SDNode *IdxNode = Op.getOperand(Op.getNumOperands() - 1).getNode();
1491 return DAG.UnrollVectorOp(Op.getNode());
1509 .getNode());
1522 if (!(ShiftVec = dyn_cast<BuildVectorSDNode>(Op.getOperand(1).getNode())) ||
lib/Target/X86/X86ISelDAGToDAG.cpp 90 IndexReg.getNode() != nullptr || Base_Reg.getNode() != nullptr;
90 IndexReg.getNode() != nullptr || Base_Reg.getNode() != nullptr;
97 dyn_cast_or_null<RegisterSDNode>(Base_Reg.getNode()))
111 if (Base_Reg.getNode())
112 Base_Reg.getNode()->dump(DAG);
121 if (IndexReg.getNode())
122 IndexReg.getNode()->dump(DAG);
275 else if (AM.Base_Reg.getNode())
290 if (AM.IndexReg.getNode())
320 if (AM.Segment.getNode())
356 User->getOperand(1).getNode() == N) {
386 if (OtherOp.getNode() == N)
393 OtherOp->getOperand(1).getNode())))
565 return isLegalMaskCompare(N->getOperand(0).getNode(), Subtarget) ||
566 isLegalMaskCompare(N->getOperand(1).getNode(), Subtarget);
709 ISD::isBuildVectorAllZeros(Root->getOperand(0).getNode())))
721 if (Chain.getNode() == Load.getNode())
721 if (Chain.getNode() == Load.getNode())
727 if (Chain.getOperand(i).getNode() == Load.getNode())
727 if (Chain.getOperand(i).getNode() == Load.getNode())
737 CurDAG->UpdateNodeOperands(OrigChain.getNode(), Ops);
738 CurDAG->UpdateNodeOperands(Load.getNode(), Call.getOperand(0),
742 Ops.push_back(SDValue(Load.getNode(), 1));
744 CurDAG->UpdateNodeOperands(Call.getNode(), Ops);
757 if (Callee.getNode() == Chain.getNode() || !Callee.hasOneUse())
757 if (Callee.getNode() == Chain.getNode() || !Callee.hasOneUse())
759 LoadSDNode *LD = dyn_cast<LoadSDNode>(Callee.getNode());
777 if (isa<MemSDNode>(Chain.getNode()) &&
778 cast<MemSDNode>(Chain.getNode())->writeMem())
780 if (Chain.getOperand(0).getNode() == Callee.getNode())
780 if (Chain.getOperand(0).getNode() == Callee.getNode())
783 Callee.getValue(1).isOperandOf(Chain.getOperand(0).getNode()) &&
1100 CurDAG->ReplaceAllUsesWith(N, Result.getNode());
1148 ReplaceUses(N, N00.getNode());
1179 N->isOnlyUserOf(N->getOperand(0).getNode()) &&
1226 N->isOnlyUserOf(N->getOperand(0).getNode()) &&
1382 if (C->getSExtValue() == 0 && AM.Segment.getNode() == nullptr &&
1483 AM.Base_Reg.getNode() == nullptr) {
1498 AM.Base_Reg.getNode() == nullptr &&
1499 AM.IndexReg.getNode() == nullptr &&
1531 !AM.Base_Reg.getNode() &&
1532 !AM.IndexReg.getNode()) {
1550 (SelectionDAGISel::getUninvalidatedNodeId(N.getNode()) >
1551 SelectionDAGISel::getUninvalidatedNodeId(Pos.getNode()))) {
1552 DAG.RepositionNode(Pos->getIterator(), N.getNode());
1558 SelectionDAGISel::InvalidateNodeId(N.getNode());
1601 DAG.RemoveDeadNode(N.getNode());
1668 DAG.RemoveDeadNode(N.getNode());
1779 DAG.RemoveDeadNode(N.getNode());
1838 DAG.RemoveDeadNode(N.getNode());
1903 AM.Base_Reg.getNode() == nullptr &&
1912 if (AM.IndexReg.getNode() != nullptr || AM.Scale != 1)
1944 if (AM.IndexReg.getNode() != nullptr || AM.Scale != 1) break;
1979 AM.Base_Reg.getNode() == nullptr &&
1980 AM.IndexReg.getNode() == nullptr) {
1992 if (MulVal.getNode()->getOpcode() == ISD::ADD && MulVal.hasOneUse() &&
2031 if (AM.IndexReg.getNode() || AM.isRIPRelative()) {
2041 if (!RHS.getNode()->hasOneUse() ||
2042 RHS.getNode()->getOpcode() == ISD::CopyFromReg ||
2043 RHS.getNode()->getOpcode() == ISD::TRUNCATE ||
2044 RHS.getNode()->getOpcode() == ISD::ANY_EXTEND ||
2045 (RHS.getNode()->getOpcode() == ISD::ZERO_EXTEND &&
2050 if ((AM.BaseType == X86ISelAddressMode::RegBase && AM.Base_Reg.getNode() &&
2051 !AM.Base_Reg.getNode()->hasOneUse()) ||
2058 (AM.Segment.getNode() && !Backup.Segment.getNode()) >= 2)
2058 (AM.Segment.getNode() && !Backup.Segment.getNode()) >= 2)
2097 if (AM.IndexReg.getNode() != nullptr || AM.Scale != 1) break;
2136 if (AM.IndexReg.getNode() != nullptr || AM.Scale != 1)
2167 CurDAG->RemoveDeadNode(N.getNode());
2179 if (AM.BaseType != X86ISelAddressMode::RegBase || AM.Base_Reg.getNode()) {
2181 if (!AM.IndexReg.getNode()) {
2320 if (ISD::isNON_EXTLoad(N.getNode())) {
2334 if (IsProfitableToFold(PatternNodeWithChain, N.getNode(), Root) &&
2345 if (N.getOpcode() == ISD::SCALAR_TO_VECTOR && N.getNode()->hasOneUse()) {
2347 if (ISD::isNON_EXTLoad(PatternNodeWithChain.getNode()) &&
2348 IsProfitableToFold(PatternNodeWithChain, N.getNode(), Root) &&
2349 IsLegalToFold(PatternNodeWithChain, N.getNode(), Root, OptLevel)) {
2452 if (AM.BaseType == X86ISelAddressMode::RegBase && AM.Base_Reg.getNode())
2457 if (AM.IndexReg.getNode())
2497 return !SDValue(V.getNode(), 1).use_empty();
2590 if (!ISD::isNON_EXTLoad(N.getNode()) ||
2595 return selectAddr(N.getNode(),
2609 return selectAddr(N.getNode(),
2619 return CurDAG->getRegister(GlobalBaseReg, TLI->getPointerTy(DL)).getNode();
2624 N = N->getOperand(0).getNode();
2816 if (!StoredVal.getNode()->hasNUsesOfValue(1, 0)) return false;
2824 if (!ISD::isNormalLoad(Load.getNode())) return false;
2896 LoopWorklist.push_back(Op.getNode());
2906 if (Op.getNode() != LoadNode)
2907 LoopWorklist.push_back(Op.getNode());
2910 if (SDNode::hasPredecessorHelper(Load.getNode(), Visited, LoopWorklist, Max,
3176 ReplaceUses(SDValue(StoredVal.getNode(), 1), SDValue(Result, 0));
3209 Op.getNode()->hasNUsesOfValue(NUses, Op.getResNo());
3379 ReplaceNode(Node, Extract.getNode());
3380 SelectCode(Extract.getNode());
3444 ReplaceNode(Node, Extract.getNode());
3445 SelectCode(Extract.getNode());
3546 if (tryFoldLoad(Node, N0.getNode(), Input, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4)) {
3713 if (OrigShiftAmt.getNode()->use_empty())
3714 CurDAG->RemoveDeadNode(OrigShiftAmt.getNode());
3830 ReplaceNode(N, NewSHL.getNode());
3831 SelectCode(NewSHL.getNode());
3876 ReplaceNode(Node, NewNode.getNode());
3877 SelectCode(NewNode.getNode());
3939 ReplaceNode(And, And0.getNode());
3946 ReplaceNode(And, NewAnd.getNode());
3947 SelectCode(NewAnd.getNode());
4125 if (ISD::isBuildVectorAllZeros(SetccOp0.getNode()))
4129 if (!ISD::isBuildVectorAllZeros(SetccOp1.getNode()))
4165 FoldedLoad = tryFoldLoad(Root, N0.getNode(), Load, Tmp0, Tmp1, Tmp2, Tmp3,
4170 FoldedLoad = tryFoldLoad(Root, N0.getNode(), Load, Tmp0, Tmp1, Tmp2,
4180 Parent = Src.getNode();
4198 SDNode *ParentNode = N0.getNode();
4206 SDNode *ParentNode = N0.getNode();
4228 bool IsMasked = InMask.getNode() != nullptr;
4344 ReplaceNode(N, Ternlog.getNode());
4345 SelectCode(Ternlog.getNode());
4432 ReplaceNode(Node, Brind.getNode());
4433 SelectCode(ZextTarget.getNode());
4434 SelectCode(Brind.getNode());
4462 ReplaceNode(Node, Blendv.getNode());
4463 SelectCode(Blendv.getNode());
4549 if (!shouldAvoidImmediateInstFormsForSize(N1.getNode()))
4776 LLVM_DEBUG(dbgs() << "=> "; ResLo.getNode()->dump(CurDAG);
4786 LLVM_DEBUG(dbgs() << "=> "; ResHi.getNode()->dump(CurDAG);
4946 LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
4955 LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
4964 LLVM_DEBUG(dbgs() << "=> "; Result.getNode()->dump(CurDAG);
4987 if (MachineSDNode *NewNode = matchBEXTRFromAndImm(N0.getNode())) {
5006 N0.getNode()->hasOneUse() &&
5096 if (tryFoldLoad(Node, N0.getNode(), Reg, Tmp0, Tmp1, Tmp2, Tmp3, Tmp4)) {
5217 ReplaceNode(Node, Res.getNode());
5218 SelectCode(Res.getNode());
lib/Target/X86/X86ISelLowering.cpp 2660 if (Flag.getNode())
3565 return SDValue(OutRetAddr.getNode(), 1);
3844 if (!StackPtr.getNode())
3958 if (!StackPtr.getNode())
4085 if (InFlag.getNode())
4097 DAG.addCallSiteInfo(Ret.getNode(), std::move(CSInfo));
4107 DAG.addCallSiteInfo(Chain.getNode(), std::move(CSInfo));
4112 DAG.addHeapAllocSite(Chain.getNode(), HeapAlloc);
4505 return Op.hasOneUse() && ISD::isNormalLoad(Op.getNode());
4509 return Op.hasOneUse() && ISD::isNormalStore(*Op.getNode()->use_begin());
4514 unsigned Opcode = Op.getNode()->use_begin()->getOpcode();
4716 if (ISD::isNON_EXTLoad(LHS.getNode()) &&
4717 !ISD::isNON_EXTLoad(RHS.getNode())) {
4928 if (!ISD::isConstantSplatVector(C.getNode(), MulC))
5681 if (IdxVal == 0 && ISD::isBuildVectorAllZeros(Vec.getNode())) {
5723 if (ISD::isBuildVectorAllZeros(Vec.getNode())) {
5869 ISD::isBuildVectorAllOnes(V.getOperand(1).getNode()))
5880 if (collectConcatOps(V.getNode(), CatOps)) {
6065 if (ISD::isBuildVectorOfConstantSDNodes(Op.getNode())) {
6082 if (ISD::isBuildVectorOfConstantFPSDNodes(Op.getNode())) {
6733 if (!getTargetShuffleMask(N.getNode(), VT, true, Ops, Mask, IsUnary))
6981 !N->isOnlyUserOf(Sub.getNode()))
7339 return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG, Depth+1);
7363 return getShuffleScalarElt(NewV.getNode(), Elt % NumElems, DAG,
7377 return getShuffleScalarElt(Sub.getNode(), Index - SubIdx, DAG, Depth + 1);
7378 return getShuffleScalarElt(Vec.getNode(), Index, DAG, Depth + 1);
7386 return getShuffleScalarElt(Src.getNode(), Index + SrcIdx, DAG, Depth + 1);
7577 if (!FirstNonZero.getNode()) {
7583 assert(FirstNonZero.getNode() && "Unexpected build vector of all zeros!");
7631 if (!V1.getNode())
7639 assert(V1.getNode() && "Expected at least two non-zero elements!");
7744 if (ISD::isNON_EXTLoad(Elt.getNode())) {
7811 if (!Elt.getNode())
7817 if (X86::isZeroNode(Elt) || ISD::isBuildVectorAllZeros(Elt.getNode())) {
8097 if (Opc == X86ISD::VPERMV && U->getOperand(0).getNode() == N)
8099 if (Opc == X86ISD::VPERMV3 && U->getOperand(1).getNode() == N)
8298 if (!ConstSplatVal && !BVOp->isOnlyUserOf(Ld.getNode()))
8348 bool IsLoad = ISD::isNormalLoad(Ld.getNode());
8452 if (!VecIn1.getNode())
8455 if (!VecIn2.getNode())
8468 if (!VecIn1.getNode())
8471 VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
8482 assert(ISD::isBuildVectorOfConstantSDNodes(Op.getNode()) &&
8504 if (ISD::isBuildVectorAllZeros(Op.getNode()) ||
8505 ISD::isBuildVectorAllOnes(Op.getNode()))
9262 if (ISD::isBuildVectorAllZeros(Op.getNode()))
9268 if (Subtarget.hasSSE2() && ISD::isBuildVectorAllOnes(Op.getNode())) {
9597 BuildVectorSDNode *BV = cast<BuildVectorSDNode>(Op.getNode());
9661 assert(!VarElt.getNode() && !InsIndex.getNode() &&
9661 assert(!VarElt.getNode() && !InsIndex.getNode() &&
9765 if (Op.getNode()->isOnlyUserOf(Item.getNode()))
9765 if (Op.getNode()->isOnlyUserOf(Item.getNode()))
9967 if (ISD::isBuildVectorAllZeros(SubVec.getNode()))
10026 if (ISD::isBuildVectorAllZeros(SubVec.getNode()))
10329 if (!ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
10441 bool V1IsZero = ISD::isBuildVectorAllZeros(V1.getNode());
10442 bool V2IsZero = ISD::isBuildVectorAllZeros(V2.getNode());
10782 if (!ISD::isBuildVectorAllZeros(V2.getNode())) {
10783 if (!ISD::isBuildVectorAllZeros(V1.getNode()))
10980 V1.isUndef() || ISD::isBuildVectorAllZeros(V1.getNode());
10982 V2.isUndef() || ISD::isBuildVectorAllZeros(V2.getNode());
11126 if (!ISD::isNormalLoad(V1.getNode()) && ISD::isNormalLoad(V2.getNode())) {
11126 if (!ISD::isNormalLoad(V1.getNode()) && ISD::isNormalLoad(V2.getNode())) {
12255 return ISD::isNON_EXTLoad(V.getNode());
12866 if (ISD::isBuildVectorAllZeros(V1.getNode()) ||
12867 ISD::isBuildVectorAllZeros(V2.getNode()))
17093 bool V2IsZero = !V2IsUndef && ISD::isBuildVectorAllZeros(V2.getNode());
17202 if (ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()) &&
17203 ISD::isBuildVectorOfConstantSDNodes(LHS.getNode()) &&
17204 ISD::isBuildVectorOfConstantSDNodes(RHS.getNode()))
17302 SDNode *User = *Op.getNode()->use_begin();
17461 if (VT.getSizeInBits() == 8 && Op->isOnlyUserOf(Vec.getNode())) {
17615 if (IdxVal == 0 && ISD::isBuildVectorAllZeros(N0.getNode()) &&
20041 if (Op.getNode()->getFlags().hasNoSignedWrap())
20082 for (SDNode::use_iterator UI = Op.getNode()->use_begin(),
20083 UE = Op.getNode()->use_end(); UI != UE; ++UI)
20106 return SDValue(Op.getNode(), 1);
20128 DAG.ReplaceAllUsesOfValueWith(SDValue(Op.getNode(), 0), New);
20129 return SDValue(New.getNode(), 1);
20344 Created.push_back(Cmp.getNode());
20345 Created.push_back(Add.getNode());
20346 Created.push_back(CMov.getNode());
20357 Created.push_back(SRA.getNode());
20413 if (!Src.getNode())
20544 auto *BV = dyn_cast<BuildVectorSDNode>(V.getNode());
20742 if (Cond == ISD::SETNE && ISD::isBuildVectorAllZeros(Op1.getNode())) {
20785 ISD::isConstantSplatVector(Op1.getNode(), ConstValue)) {
21075 if (!Op1.getNode()) {
21288 if (ISD::isBuildVectorOfConstantSDNodes(Op1.getNode()))
21293 if (ISD::isBuildVectorOfConstantSDNodes(Op2.getNode()))
21297 if (Op1Scalar.getNode() && Op2Scalar.getNode()) {
21297 if (Op1Scalar.getNode() && Op2Scalar.getNode()) {
21832 StoreSDNode *St = cast<StoreSDNode>(Op.getNode());
21866 if (StoredVal.hasOneUse() && collectConcatOps(StoredVal.getNode(), CatOps))
21915 LoadSDNode *Ld = cast<LoadSDNode>(Op.getNode());
22071 Op.getNode()->hasOneUse()) {
22076 SDNode *User = *Op.getNode()->use_begin();
22116 if (Op.getNode()->hasOneUse()) {
22117 SDNode *User = *Op.getNode()->use_begin();
22201 SDNode *Node = Op.getNode();
22340 return DAG.expandVAArg(Op.getNode());
22348 EVT ArgVT = Op.getNode()->getValueType(0);
22399 return DAG.expandVACopy(Op.getNode());
22462 if (ISD::isBuildVectorOfConstantSDNodes(SrcOp.getNode())) {
23135 if (!Cmp.getNode())
23216 if (ISD::isBuildVectorAllOnes(Mask.getNode())) // return data as is
23342 if (ISD::isBuildVectorAllOnes(Mask.getNode()))
23688 if (Src.isUndef() || ISD::isBuildVectorAllOnes(Mask.getNode()))
23725 if (Src.isUndef() || ISD::isBuildVectorAllOnes(Mask.getNode()))
23814 TargetOpcode, DL, Tys, ArrayRef<SDValue>(N1Ops, Glue.getNode() ? 2 : 1));
23876 getReadTimeStampCounter(Op.getNode(), DL, X86::RDTSC, DAG, Subtarget,
24051 SDValue(Result.getNode(), 1)};
24056 SDValue(Result.getNode(), 2));
24106 getReadTimeStampCounter(Op.getNode(), dl, IntrData->Opc0, DAG, Subtarget,
24119 expandIntrinsicWChainHelper(Op.getNode(), dl, DAG, IntrData->Opc0, X86::ECX,
24131 Ret, SDValue(InTrans.getNode(), 1));
24956 SDValue(Neg.getNode(), 1)};
25059 if (ISD::isBuildVectorOfConstantSDNodes(B.getNode())) {
25331 if (ISD::isBuildVectorOfConstantSDNodes(B.getNode())) {
25707 if (ISD::isBuildVectorOfConstantSDNodes(Amt.getNode())) {
25768 bool ConstantAmt = ISD::isBuildVectorOfConstantSDNodes(Amt.getNode());
26012 assert(ISD::isBuildVectorOfConstantSDNodes(Amt.getNode()) &&
26176 !ISD::isBuildVectorOfConstantSDNodes(Amt.getNode());
26322 if (ISD::isBuildVectorOfConstantSDNodes(Amt.getNode()))
26385 bool ConstantAmt = ISD::isBuildVectorOfConstantSDNodes(Amt.getNode());
26954 SDLoc DL(Op.getNode());
27137 AtomicSDNode *AN = cast<AtomicSDNode>(N.getNode());
27201 auto *Node = cast<AtomicSDNode>(Op.getNode());
27251 SDNode *N = Op.getNode();
27357 if ((ISD::isBuildVectorAllZeros(N1.getNode()) && FillWithZeroes) ||
27364 if (ISD::isBuildVectorOfConstantSDNodes(InOp.getNode()) ||
27365 ISD::isBuildVectorOfConstantFPSDNodes(InOp.getNode())) {
27389 MaskedScatterSDNode *N = cast<MaskedScatterSDNode>(Op.getNode());
27412 return SDValue(NewScatter.getNode(), 1);
27447 return SDValue(NewScatter.getNode(), 1);
27453 MaskedLoadSDNode *N = cast<MaskedLoadSDNode>(Op.getNode());
27464 if (PassThru.isUndef() || ISD::isBuildVectorAllZeros(PassThru.getNode()))
27521 MaskedStoreSDNode *N = cast<MaskedStoreSDNode>(Op.getNode());
27565 MaskedGatherSDNode *N = cast<MaskedGatherSDNode>(Op.getNode());
27795 if (!Res.getNode())
27915 SDValue(Lo.getNode(), 1));
27949 if (ISD::isConstantSplatVector(N->getOperand(1).getNode(), SplatVal)) {
28398 int SPFI = cast<FrameIndexSDNode>(StackPtr.getNode())->getIndex();
31621 if (getTargetShuffleMask(Op.getNode(), VT.getSimpleVT(), true, Ops, Mask,
31759 if (getTargetShuffleMask(Op.getNode(), VT.getSimpleVT(), true, Ops, Mask,
33184 CombinedNodes.push_back(Op.getNode());
33196 if (Ops[i].getNode()->hasOneUse() ||
33197 SDNode::areOnlyUsersOf(CombinedNodes, Ops[i].getNode()))
33260 getTargetShuffleMask(N.getNode(), VT, false, Ops, Mask, IsUnary);
33356 !V->isOnlyUserOf(V.getOperand(0).getNode()))
33506 if (User != N.getNode() && User->getOpcode() == X86ISD::VBROADCAST &&
33515 ISD::isNormalLoad(Src.getNode())) {
33524 DCI.CombineTo(N.getNode(), BcastLd);
34032 N = SrcOp.getNode();
34235 ISD::isNormalLoad(N->getOperand(0).getNode())) {
34951 ISD::isBuildVectorAllZeros(Op.getOperand(0).getNode()))
35100 if (!getTargetShuffleMask(InVec.getNode(), CurrentVT.getSimpleVT(), true,
35137 if (!LdNode.getNode()->hasNUsesOfValue(AllowedUses, 0))
35144 if (!ISD::isNormalLoad(LdNode.getNode()))
35318 assert(ISD::isBuildVectorOfConstantSDNodes(Op.getNode()) &&
35378 if (ISD::isBuildVectorOfConstantSDNodes(RHS.getNode())) {
35481 ISD::isBuildVectorAllZeros(N0.getOperand(1).getNode()) &&
35485 if (ISD::isNormalLoad(N00.getNode()) ||
35517 if (ISD::isBuildVectorAllZeros(LastOp.getNode())) {
35634 ISD::isBuildVectorOfConstantSDNodes(N0.getNode())) {
36538 bool TValIsAllZeros = ISD::isBuildVectorAllZeros(LHS.getNode());
36539 bool FValIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
36567 bool TValIsAllOnes = ISD::isBuildVectorAllOnes(LHS.getNode());
36574 bool FValIsAllOnes = ISD::isBuildVectorAllOnes(RHS.getNode());
36647 !collectConcatOps(TVal.getNode(), CatOpsT) ||
36648 !collectConcatOps(FVal.getNode(), CatOpsF))
36733 ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()))
36823 if (ISD::isBuildVectorOfConstantSDNodes(Cond.getNode()) &&
37034 bool ZeroLHS = ISD::isBuildVectorAllZeros(LHS.getNode());
37035 bool ZeroRHS = ISD::isBuildVectorAllZeros(RHS.getNode());
37101 if (ISD::isBuildVectorAllZeros(LHS.getNode())) {
37104 } else if (ISD::isBuildVectorAllZeros(RHS.getNode())) {
37108 if (Other.getNode() && Other->getNumOperands() == 2 &&
37145 ISD::isBuildVectorAllZeros(CondRHS.getNode()) &&
37173 if (ISD::isBuildVectorAllOnes(LHS.getNode())) {
37176 } else if (ISD::isBuildVectorAllOnes(RHS.getNode())) {
37180 if (Other.getNode() && Other.getOpcode() == ISD::ADD) {
37303 auto *AN = cast<AtomicSDNode>(CmpLHS.getNode());
37539 CarryOp1.getNode()->hasOneUse() &&
37545 return SDValue(SubCommute.getNode(), CarryOp1.getResNo());
38434 if ((N0.isUndef() || N->isOnlyUserOf(N0.getNode())) &&
38435 (N1.isUndef() || N->isOnlyUserOf(N1.getNode())) &&
38524 if (ISD::isBuildVectorAllZeros(N0.getNode()))
38577 if (ISD::isBuildVectorAllZeros(N0.getNode()))
38601 if (N->isOnlyUserOf(N0.getNode()) &&
38816 !ISD::isBuildVectorOfConstantSDNodes(N1.getNode()))
38896 if (!ISD::isConstantSplatVector(Op1.getNode(), SplatVal) ||
38971 LoadSDNode *Ld = dyn_cast<LoadSDNode>(N.getNode());
39258 N->getOperand(0)->isOnlyUserOf(SrcVec.getNode()) &&
39399 ISD::isBuildVectorAllZeros(N->getOperand(0).getNode());
39403 if (IsNegV(Y.getNode(), X))
39405 else if (IsNegV(X.getNode(), Y))
39537 SDNode *OR = N->getOperand(0).getNode();
39546 OR = (LHS->getOpcode() == ISD::OR) ? LHS.getNode() : RHS.getNode();
39546 OR = (LHS->getOpcode() == ISD::OR) ? LHS.getNode() : RHS.getNode();
39849 !ISD::isBuildVectorAllOnes(Ones.getNode()))
39891 ISD::isConstantSplatVector(V.getOperand(1).getNode(), Limit))
39936 ISD::isConstantSplatVector(V.getOperand(1).getNode(), C) && C == Limit)
40357 if (!ISD::isBuildVectorOfConstantSDNodes(ML->getMask().getNode()))
40387 if (ISD::isBuildVectorAllZeros(ML->getPassThru().getNode()))
40477 if (Value.getOpcode() == ISD::TRUNCATE && Value.getNode()->hasOneUse() &&
40536 ISD::isBuildVectorOfConstantSDNodes(StoredVal.getNode())) {
40670 LoadSDNode *Ld = cast<LoadSDNode>(St->getValue().getNode());
40807 getTargetShuffleMask(BC.getNode(), BC.getSimpleValueType(), false,
40882 (!A.getNode() && (LIdx < (int)NumElts || RIdx < (int)NumElts)) ||
40883 (!B.getNode() && (LIdx >= (int)NumElts || RIdx >= (int)NumElts)))
40890 unsigned Src = B.getNode() ? i >= NumEltsPer64BitChunk : 0;
40901 LHS = A.getNode() ? A : B; // If A is 'UNDEF', use B for it.
40902 RHS = B.getNode() ? B : A; // If B is 'UNDEF', use A for it.
40963 return ISD::isBuildVectorOfConstantSDNodes(Op.getNode());
41191 if (!ISD::isConstantSplatVector(Src.getOperand(1).getNode(), ShiftAmt) ||
41433 if (auto SVOp = dyn_cast<ShuffleVectorSDNode>(Op.getNode())) {
41438 if (SDValue NegOp0 = isFNEG(DAG, SVOp->getOperand(0).getNode(), Depth + 1))
41452 if (SDValue NegInsVal = isFNEG(DAG, InsVal.getNode(), Depth + 1))
41596 if (isFNEG(DAG, Op.getNode(), Depth))
41639 if (SDValue Arg = isFNEG(DAG, Op.getNode(), Depth))
41790 return isNullFPConstant(V) || ISD::isBuildVectorAllZeros(V.getNode());
41825 return ISD::isBuildVectorAllOnes(V.getNode());
41992 ISD::isNormalLoad(In.getNode()) && In.hasOneUse()) {
42027 ISD::isNormalLoad(In.getNode()) && In.hasOneUse()) {
42061 if (ISD::isBuildVectorAllZeros(N->getOperand(0).getNode()))
42065 if (ISD::isBuildVectorAllZeros(N->getOperand(1).getNode()))
42126 if (!isa<ConstantSDNode>(CMovOp0.getNode()) ||
42127 !isa<ConstantSDNode>(CMovOp1.getNode()))
42184 if (!ISD::isNormalLoad(N00.getNode()))
42286 if (!isa<ConstantSDNode>(CMovOp0.getNode()) ||
42287 !isa<ConstantSDNode>(CMovOp1.getNode()))
42855 bool IsVZero1 = ISD::isBuildVectorAllZeros(RHS.getNode());
42906 if (ISD::isBuildVectorOfConstantSDNodes(Src.getNode())) {
43263 LoadSDNode *Ld = cast<LoadSDNode>(Op0.getNode());
43276 ISD::isNON_EXTLoad(Op0.getNode()) && Op0.hasOneUse() &&
43591 X86ISD::SUB, SDLoc(EFLAGS), EFLAGS.getNode()->getVTList(),
43593 SDValue NewEFLAGS = SDValue(NewSub.getNode(), EFLAGS.getResNo());
43617 if (EFLAGS.getOpcode() == X86ISD::SUB && EFLAGS.getNode()->hasOneUse() &&
43621 EFLAGS.getNode()->getVTList(),
43623 SDValue NewEFLAGS = SDValue(NewSub.getNode(), EFLAGS.getResNo());
43656 SDValue(Neg.getNode(), 1));
43709 canReduceVMulWidth(Op.getNode(), DAG, Mode) && Mode != MULU16 &&
43711 (Op->isOnlyUserOf(Op.getOperand(0).getNode()) &&
43712 Op->isOnlyUserOf(Op.getOperand(1).getNode())));
43914 if (!canReduceVMulWidth(Mul.getNode(), DAG, Mode) || Mode == MULU16)
44278 return ISD::isBuildVectorAllZeros(Op.getNode());
44421 if ((Vec.isUndef() || ISD::isBuildVectorAllZeros(Vec.getNode())) &&
44422 (SubVec.isUndef() || ISD::isBuildVectorAllZeros(SubVec.getNode())))
44425 if (ISD::isBuildVectorAllZeros(Vec.getNode())) {
44429 ISD::isBuildVectorAllZeros(SubVec.getOperand(0).getNode())) {
44446 ISD::isBuildVectorAllZeros(Ins.getOperand(0).getNode()) &&
44492 ISD::isBuildVectorAllZeros(SubVectorOps[1].getNode()))
44530 !collectConcatOps(Sel.getOperand(0).getNode(), CatOps))
44628 if (ISD::isBuildVectorAllZeros(InVec.getNode()))
44631 if (ISD::isBuildVectorAllOnes(InVec.getNode())) {
44640 InVec.getNode()->ops().slice(IdxVal, VT.getVectorNumElements()));
44673 ISD::isBuildVectorAllZeros(InVec.getOperand(0).getNode()) &&
44799 if (ISD::isBuildVectorAllZeros(RHS.getNode()))
44846 if (!DCI.isBeforeLegalizeOps() && ISD::isNormalLoad(In.getNode()) &&
45598 if (Flag.getNode()) {
45748 if (Result.getNode()) {
lib/Target/XCore/XCoreISelDAGToDAG.cpp 248 SDValue CheckEventChainOut(Addr.getNode(), 1);
257 if (!NewChain.getNode())
lib/Target/XCore/XCoreISelLowering.cpp 213 case ISD::SUB: return ExpandADDSUB(Op.getNode(), DAG);
378 dyn_cast<GlobalAddressSDNode>(Base.getNode())) {
435 if (TLI.isGAPlusOffset(BasePtr.getNode(), GV, Offset) &&
550 SDValue Lo(Hi.getNode(), 1);
567 SDValue Lo(Hi.getNode(), 1);
664 SDValue Lo(Hi.getNode(), 1);
672 SDValue Lo(Hi.getNode(), 1);
683 SDValue Lo(Hi.getNode(), 1);
724 SDValue Carry(Lo.getNode(), 1);
728 SDValue Ignored(Hi.getNode(), 1);
738 SDNode *Node = Op.getNode();
923 SDValue Crc(Data.getNode(), 1);
1215 if (InFlag.getNode())
1512 if (Flag.getNode())
1732 SDValue Carry(Result.getNode(), 1);
1749 SDValue Result(Ignored.getNode(), 1);
1774 SDValue Lo(Hi.getNode(), 1);