Lines Matching defs:Ops
694 ArrayRef<SDValue> Ops) {
695 for (const auto &Op : Ops) {
703 ArrayRef<SDUse> Ops) {
704 for (const auto &Op : Ops) {
1268 SDValue Ops[] = { Op };
1270 AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops);
1288 SDValue Ops[] = { Op1, Op2 };
1290 AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops);
1302 SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N, ArrayRef<SDValue> Ops,
1308 AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops);
1714 SmallVector<SDValue, 8> Ops;
1716 llvm::append_range(Ops, EltParts);
1719 getNode(ISD::BITCAST, DL, VT, getBuildVector(ViaVecVT, DL, Ops));
2230 SDValue Ops[2] = { N1, N2 };
2231 AddNodeIDNode(ID, ISD::VECTOR_SHUFFLE, VTs, Ops);
2247 createOperands(N, Ops);
2304 SDValue Ops[] = { Root };
2305 AddNodeIDNode(ID, Opcode, getVTList(MVT::Other), Ops);
2313 createOperands(N, Ops);
2381 SDValue Ops[] = {Ptr};
2383 AddNodeIDNode(ID, ISD::ADDRSPACECAST, VTs, Ops);
2393 createOperands(N, Ops);
5760 ArrayRef<SDValue> Ops,
5762 int NumOps = Ops.size();
5770 if (llvm::all_of(Ops, [](SDValue Op) { return Op.isUndef(); }))
5777 if (Ops[i].getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
5778 Ops[i].getOperand(0).getValueType() != VT ||
5779 (IdentitySrc && Ops[i].getOperand(0) != IdentitySrc) ||
5780 !isa<ConstantSDNode>(Ops[i].getOperand(1)) ||
5781 Ops[i].getConstantOperandAPInt(1) != i) {
5785 IdentitySrc = Ops[i].getOperand(0);
5796 ArrayRef<SDValue> Ops,
5798 assert(!Ops.empty() && "Can't concatenate an empty list of vectors!");
5799 assert(llvm::all_of(Ops,
5800 [Ops](SDValue Op) {
5801 return Ops[0].getValueType() == Op.getValueType();
5804 assert((Ops[0].getValueType().getVectorElementCount() * Ops.size()) ==
5808 if (Ops.size() == 1)
5809 return Ops[0];
5812 if (llvm::all_of(Ops, [](SDValue Op) { return Op.isUndef(); }))
5820 for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
5821 SDValue Op = Ops[i];
5849 for (SDValue Op : Ops) {
5944 SDValue Ops = {N1};
5945 if (SDValue Fold = FoldConstantArithmetic(Opcode, DL, VT, Ops))
5971 SDValue Ops[] = {N1};
5972 if (SDValue V = FoldBUILD_VECTOR(DL, VT, Ops, *this))
6227 SDValue Ops[] = {N1};
6230 AddNodeIDNode(ID, Opcode, VTs, Ops);
6239 createOperands(N, Ops);
6243 createOperands(N, Ops);
6347 bool SelectionDAG::isUndef(unsigned Opcode, ArrayRef<SDValue> Ops) {
6355 assert(Ops.size() == 2 && "Div/rem should have 2 operands");
6356 SDValue Divisor = Ops[1];
6373 EVT VT, ArrayRef<SDValue> Ops,
6384 unsigned NumOps = Ops.size();
6388 if (isUndef(Opcode, Ops))
6393 SDValue N1 = Ops[0];
6558 if (SDValue CFP = foldConstantFPMath(Opcode, DL, VT, Ops))
6561 if (auto *C1 = dyn_cast<ConstantSDNode>(Ops[0])) {
6562 if (auto *C2 = dyn_cast<ConstantSDNode>(Ops[1])) {
6579 if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Ops[0]))
6580 return FoldSymbolOffset(Opcode, VT, GA, Ops[1].getNode());
6582 if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Ops[1]))
6583 return FoldSymbolOffset(Opcode, VT, GA, Ops[0].getNode());
6594 Ops[0].getValueType() == VT && Ops[1].getValueType() == VT &&
6595 (Ops[0].getOpcode() == ISD::BITCAST ||
6596 Ops[1].getOpcode() == ISD::BITCAST)) {
6597 SDValue N1 = peekThroughBitcasts(Ops[0]);
6598 SDValue N2 = peekThroughBitcasts(Ops[1]);
6634 SmallVector<SDValue> Ops(DstBits.size(), getUNDEF(BVEltVT));
6638 Ops[I] = getConstant(DstBits[I].sext(BVEltBits), DL, BVEltVT);
6640 return getBitcast(VT, getBuildVector(BVVT, DL, Ops));
6649 Ops[0].getOpcode() == ISD::STEP_VECTOR) {
6651 if (ISD::isConstantSplatVector(Ops[1].getNode(), RHSVal)) {
6653 ? Ops[0].getConstantOperandAPInt(0) * RHSVal
6654 : Ops[0].getConstantOperandAPInt(0) << RHSVal;
6673 if (!llvm::all_of(Ops, IsBuildVectorSplatVectorOrUndef) ||
6674 !llvm::all_of(Ops, IsScalarOrSameVectorSize))
6704 for (SDValue Op : Ops) {
6758 EVT VT, ArrayRef<SDValue> Ops) {
6760 if (Ops.size() != 2)
6767 SDValue N1 = Ops[0];
6768 SDValue N2 = Ops[1];
6922 SDValue Ops[] = {N1, N2};
6923 if (SDValue V = FoldBUILD_VECTOR(DL, VT, Ops, *this))
6928 SDValue Ops[] = {N1, N2};
6929 if (SDValue V = foldCONCAT_VECTORS(DL, VT, Ops, *this))
7135 SmallVector<SDValue, 8> Ops;
7140 Ops.push_back(getUNDEF(OpVT));
7145 Ops.push_back(SignExtendInReg(Val, OpVT));
7147 return getBuildVector(VT, DL, Ops);
7382 SDValue Ops[] = {N1, N2};
7385 AddNodeIDNode(ID, Opcode, VTs, Ops);
7394 createOperands(N, Ops);
7398 createOperands(N, Ops);
7447 SDValue Ops[] = {N1, N2, N3};
7448 if (SDValue V = FoldBUILD_VECTOR(DL, VT, Ops, *this))
7453 SDValue Ops[] = {N1, N2, N3};
7454 if (SDValue V = foldCONCAT_VECTORS(DL, VT, Ops, *this))
7471 SDValue Ops[] = {N1, N2, N3};
7472 if (SDValue V = FoldConstantArithmetic(Opcode, DL, VT, Ops)) {
7580 SDValue Ops[] = {N1, N2, N3};
7583 AddNodeIDNode(ID, Opcode, VTs, Ops);
7592 createOperands(N, Ops);
7596 createOperands(N, Ops);
7607 SDValue Ops[] = { N1, N2, N3, N4 };
7608 return getNode(Opcode, DL, VT, Ops);
7614 SDValue Ops[] = { N1, N2, N3, N4, N5 };
7615 return getNode(Opcode, DL, VT, Ops);
8636 SDVTList VTList, ArrayRef<SDValue> Ops,
8640 AddNodeIDNode(ID, Opcode, VTList, Ops);
8651 createOperands(N, Ops);
8666 SDValue Ops[] = {Chain, Ptr, Cmp, Swp};
8667 return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO);
8698 SDValue Ops[] = {Chain, Ptr, Val};
8699 return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO);
8708 SDValue Ops[] = {Chain, Ptr};
8709 return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO);
8713 SDValue SelectionDAG::getMergeValues(ArrayRef<SDValue> Ops, const SDLoc &dl) {
8714 if (Ops.size() == 1)
8715 return Ops[0];
8718 VTs.reserve(Ops.size());
8719 for (const SDValue &Op : Ops)
8721 return getNode(ISD::MERGE_VALUES, dl, getVTList(VTs), Ops);
8725 unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef<SDValue> Ops,
8736 return getMemIntrinsicNode(Opcode, dl, VTList, Ops, MemVT, MMO);
8741 ArrayRef<SDValue> Ops, EVT MemVT,
8754 AddNodeIDNode(ID, Opcode, VTList, Ops);
8768 createOperands(N, Ops);
8774 createOperands(N, Ops);
8787 SDValue Ops[2] = {
8794 AddNodeIDNode(ID, Opcode, VTs, Ops);
8804 createOperands(N, Ops);
8817 SDValue Ops[] = {Chain};
8819 AddNodeIDNode(ID, Opcode, VTs, Ops);
8828 createOperands(N, Ops);
8925 SDValue Ops[] = { Chain, Ptr, Offset };
8927 AddNodeIDNode(ID, ISD::LOAD, VTs, Ops);
8940 createOperands(N, Ops);
9026 SDValue Ops[] = { Chain, Val, Ptr, Undef };
9028 AddNodeIDNode(ID, ISD::STORE, VTs, Ops);
9041 createOperands(N, Ops);
9093 SDValue Ops[] = { Chain, Val, Ptr, Undef };
9095 AddNodeIDNode(ID, ISD::STORE, VTs, Ops);
9108 createOperands(N, Ops);
9123 SDValue Ops[] = { ST->getChain(), ST->getValue(), Base, Offset };
9125 AddNodeIDNode(ID, ISD::STORE, VTs, Ops);
9137 createOperands(N, Ops);
9180 SDValue Ops[] = {Chain, Ptr, Offset, Mask, EVL};
9182 AddNodeIDNode(ID, ISD::VP_LOAD, VTs, Ops);
9195 createOperands(N, Ops);
9273 SDValue Ops[] = {Chain, Val, Ptr, Offset, Mask, EVL};
9275 AddNodeIDNode(ID, ISD::VP_STORE, VTs, Ops);
9288 createOperands(N, Ops);
9344 SDValue Ops[] = {Chain, Val, Ptr, Undef, Mask, EVL};
9346 AddNodeIDNode(ID, ISD::VP_STORE, VTs, Ops);
9360 createOperands(N, Ops);
9375 SDValue Ops[] = {ST->getChain(), ST->getValue(), Base,
9378 AddNodeIDNode(ID, ISD::VP_STORE, VTs, Ops);
9390 createOperands(N, Ops);
9406 SDValue Ops[] = {Chain, Ptr, Offset, Stride, Mask, EVL};
9410 AddNodeIDNode(ID, ISD::EXPERIMENTAL_VP_STRIDED_LOAD, VTs, Ops);
9425 createOperands(N, Ops);
9464 SDValue Ops[] = {Chain, Val, Ptr, Offset, Stride, Mask, EVL};
9466 AddNodeIDNode(ID, ISD::EXPERIMENTAL_VP_STRIDED_STORE, VTs, Ops);
9479 createOperands(N, Ops);
9513 SDValue Ops[] = {Chain, Val, Ptr, Undef, Stride, Mask, EVL};
9515 AddNodeIDNode(ID, ISD::EXPERIMENTAL_VP_STRIDED_STORE, VTs, Ops);
9528 createOperands(N, Ops);
9538 ArrayRef<SDValue> Ops, MachineMemOperand *MMO,
9540 assert(Ops.size() == 6 && "Incompatible number of operands");
9543 AddNodeIDNode(ID, ISD::VP_GATHER, VTs, Ops);
9557 createOperands(N, Ops);
9581 ArrayRef<SDValue> Ops,
9584 assert(Ops.size() == 7 && "Incompatible number of operands");
9587 AddNodeIDNode(ID, ISD::VP_SCATTER, VTs, Ops);
9600 createOperands(N, Ops);
9635 SDValue Ops[] = {Chain, Base, Offset, Mask, PassThru};
9637 AddNodeIDNode(ID, ISD::MLOAD, VTs, Ops);
9650 createOperands(N, Ops);
9683 SDValue Ops[] = {Chain, Val, Base, Offset, Mask};
9685 AddNodeIDNode(ID, ISD::MSTORE, VTs, Ops);
9699 createOperands(N, Ops);
9720 ArrayRef<SDValue> Ops,
9724 assert(Ops.size() == 6 && "Incompatible number of operands");
9727 AddNodeIDNode(ID, ISD::MGATHER, VTs, Ops);
9741 createOperands(N, Ops);
9767 ArrayRef<SDValue> Ops,
9771 assert(Ops.size() == 6 && "Incompatible number of operands");
9774 AddNodeIDNode(ID, ISD::MSCATTER, VTs, Ops);
9788 createOperands(N, Ops);
9813 const SDLoc &dl, ArrayRef<SDValue> Ops,
9816 assert(Ops.size() == 7 && "Incompatible number of operands");
9819 AddNodeIDNode(ID, ISD::EXPERIMENTAL_VECTOR_HISTOGRAM, VTs, Ops);
9833 createOperands(N, Ops);
9854 SDValue Ops[] = {Chain, Ptr};
9856 AddNodeIDNode(ID, ISD::GET_FPENV_MEM, VTs, Ops);
9868 createOperands(N, Ops);
9881 SDValue Ops[] = {Chain, Ptr};
9883 AddNodeIDNode(ID, ISD::SET_FPENV_MEM, VTs, Ops);
9895 createOperands(N, Ops);
10009 SDValue Ops[] = { Chain, Ptr, SV, getTargetConstant(Align, dl, MVT::i32) };
10010 return getNode(ISD::VAARG, dl, getVTList(VT, MVT::Other), Ops);
10014 ArrayRef<SDUse> Ops) {
10015 switch (Ops.size()) {
10017 case 1: return getNode(Opcode, DL, VT, static_cast<const SDValue>(Ops[0]));
10018 case 2: return getNode(Opcode, DL, VT, Ops[0], Ops[1]);
10019 case 3: return getNode(Opcode, DL, VT, Ops[0], Ops[1], Ops[2]);
10025 SmallVector<SDValue, 8> NewOps(Ops.begin(), Ops.end());
10030 ArrayRef<SDValue> Ops) {
10034 return getNode(Opcode, DL, VT, Ops, Flags);
10038 ArrayRef<SDValue> Ops, const SDNodeFlags Flags) {
10039 unsigned NumOps = Ops.size();
10042 case 1: return getNode(Opcode, DL, VT, Ops[0], Flags);
10043 case 2: return getNode(Opcode, DL, VT, Ops[0], Ops[1], Flags);
10044 case 3: return getNode(Opcode, DL, VT, Ops[0], Ops[1], Ops[2], Flags);
10049 for (const auto &Op : Ops)
10058 if (SDValue V = FoldBUILD_VECTOR(DL, VT, Ops, *this))
10062 if (SDValue V = foldCONCAT_VECTORS(DL, VT, Ops, *this))
10067 assert(Ops[0].getValueType() == Ops[1].getValueType() &&
10069 assert(Ops[2].getValueType() == Ops[3].getValueType() &&
10071 assert(Ops[2].getValueType() == VT &&
10073 assert((!Ops[0].getValueType().isVector() ||
10074 Ops[0].getValueType().getVectorElementCount() ==
10081 assert(Ops[2].getValueType() == Ops[3].getValueType() &&
10127 AddNodeIDNode(ID, Opcode, VTs, Ops);
10134 createOperands(N, Ops);
10139 createOperands(N, Ops);
10150 ArrayRef<EVT> ResultTys, ArrayRef<SDValue> Ops) {
10151 return getNode(Opcode, DL, getVTList(ResultTys), Ops);
10155 ArrayRef<SDValue> Ops) {
10159 return getNode(Opcode, DL, VTList, Ops, Flags);
10163 ArrayRef<SDValue> Ops, const SDNodeFlags Flags) {
10165 return getNode(Opcode, DL, VTList.VTs[0], Ops, Flags);
10168 for (const auto &Op : Ops)
10178 assert(VTList.NumVTs == 2 && Ops.size() == 2 &&
10181 Ops[0].getValueType() == Ops[1].getValueType() &&
10182 Ops[0].getValueType() == VTList.VTs[0] &&
10184 SDValue N1 = Ops[0], N2 = Ops[1];
10221 assert(VTList.NumVTs == 2 && Ops.size() == 3 &&
10224 Ops[0].getValueType() == Ops[1].getValueType() &&
10225 Ops[0].getValueType() == VTList.VTs[0] &&
10226 Ops[2].getValueType() == VTList.VTs[1] &&
10231 assert(VTList.NumVTs == 2 && Ops.size() == 2 && "Invalid mul lo/hi op!");
10233 VTList.VTs[0] == Ops[0].getValueType() &&
10234 VTList.VTs[0] == Ops[1].getValueType() &&
10237 ConstantSDNode *LHS = dyn_cast<ConstantSDNode>(Ops[0]);
10238 ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(Ops[1]);
10261 assert(VTList.NumVTs == 2 && Ops.size() == 1 && "Invalid ffrexp op!");
10263 VTList.VTs[0] == Ops[0].getValueType() && "frexp type mismatch");
10265 if (const ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(Ops[0])) {
10278 assert(VTList.NumVTs == 2 && Ops.size() == 2 &&
10281 Ops[1].getValueType().isFloatingPoint() && "Invalid FP cast!");
10282 assert(VTList.VTs[0].isVector() == Ops[1].getValueType().isVector() &&
10287 Ops[1].getValueType().getVectorElementCount()) &&
10289 assert(Ops[1].getValueType().bitsLT(VTList.VTs[0]) &&
10293 assert(VTList.NumVTs == 2 && Ops.size() == 3 && "Invalid STRICT_FP_ROUND!");
10294 assert(VTList.VTs[0].isVector() == Ops[1].getValueType().isVector() &&
10299 Ops[1].getValueType().getVectorElementCount()) &&
10302 Ops[1].getValueType().isFloatingPoint() &&
10303 VTList.VTs[0].bitsLT(Ops[1].getValueType()) &&
10304 isa<ConstantSDNode>(Ops[2]) &&
10305 (Ops[2]->getAsZExtVal() == 0 || Ops[2]->getAsZExtVal() == 1) &&
10334 AddNodeIDNode(ID, Opcode, VTList, Ops);
10340 createOperands(N, Ops);
10344 createOperands(N, Ops);
10361 SDValue Ops[] = { N1 };
10362 return getNode(Opcode, DL, VTList, Ops);
10367 SDValue Ops[] = { N1, N2 };
10368 return getNode(Opcode, DL, VTList, Ops);
10373 SDValue Ops[] = { N1, N2, N3 };
10374 return getNode(Opcode, DL, VTList, Ops);
10379 SDValue Ops[] = { N1, N2, N3, N4 };
10380 return getNode(Opcode, DL, VTList, Ops);
10386 SDValue Ops[] = { N1, N2, N3, N4, N5 };
10387 return getNode(Opcode, DL, VTList, Ops);
10536 SDValue Ops[] = { Op1, Op2, Op3 };
10537 return UpdateNodeOperands(N, Ops);
10543 SDValue Ops[] = { Op1, Op2, Op3, Op4 };
10544 return UpdateNodeOperands(N, Ops);
10550 SDValue Ops[] = { Op1, Op2, Op3, Op4, Op5 };
10551 return UpdateNodeOperands(N, Ops);
10555 UpdateNodeOperands(SDNode *N, ArrayRef<SDValue> Ops) {
10556 unsigned NumOps = Ops.size();
10561 if (std::equal(Ops.begin(), Ops.end(), N->op_begin()))
10566 if (SDNode *Existing = FindModifiedNodeSlot(N, Ops, InsertPos))
10576 if (N->OperandList[i] != Ops[i])
10577 N->OperandList[i].set(Ops[i]);
10629 SDValue Ops[] = { Op1 };
10630 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10637 SDValue Ops[] = { Op1, Op2 };
10638 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10645 SDValue Ops[] = { Op1, Op2, Op3 };
10646 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10650 EVT VT, ArrayRef<SDValue> Ops) {
10652 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10656 EVT VT1, EVT VT2, ArrayRef<SDValue> Ops) {
10658 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10669 ArrayRef<SDValue> Ops) {
10671 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10678 SDValue Ops[] = { Op1, Op2 };
10679 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10683 SDVTList VTs,ArrayRef<SDValue> Ops) {
10684 SDNode *New = MorphNodeTo(N, ~MachineOpc, VTs, Ops);
10728 SDVTList VTs, ArrayRef<SDValue> Ops) {
10733 AddNodeIDNode(ID, Opc, VTs, Ops);
10763 createOperands(N, Ops);
10800 SmallVector<SDValue, 3> Ops;
10802 Ops.push_back(Node->getOperand(i));
10805 SDNode *Res = MorphNodeTo(Node, NewOpc, VTs, Ops);
10837 SDValue Ops[] = { Op1 };
10838 return getMachineNode(Opcode, dl, VTs, Ops);
10844 SDValue Ops[] = { Op1, Op2 };
10845 return getMachineNode(Opcode, dl, VTs, Ops);
10852 SDValue Ops[] = { Op1, Op2, Op3 };
10853 return getMachineNode(Opcode, dl, VTs, Ops);
10857 EVT VT, ArrayRef<SDValue> Ops) {
10859 return getMachineNode(Opcode, dl, VTs, Ops);
10866 SDValue Ops[] = { Op1, Op2 };
10867 return getMachineNode(Opcode, dl, VTs, Ops);
10874 SDValue Ops[] = { Op1, Op2, Op3 };
10875 return getMachineNode(Opcode, dl, VTs, Ops);
10880 ArrayRef<SDValue> Ops) {
10882 return getMachineNode(Opcode, dl, VTs, Ops);
10889 SDValue Ops[] = { Op1, Op2 };
10890 return getMachineNode(Opcode, dl, VTs, Ops);
10898 SDValue Ops[] = { Op1, Op2, Op3 };
10899 return getMachineNode(Opcode, dl, VTs, Ops);
10904 ArrayRef<SDValue> Ops) {
10906 return getMachineNode(Opcode, dl, VTs, Ops);
10911 ArrayRef<SDValue> Ops) {
10913 return getMachineNode(Opcode, dl, VTs, Ops);
10918 ArrayRef<SDValue> Ops) {
10925 AddNodeIDNode(ID, ~Opcode, VTs, Ops);
10934 createOperands(N, Ops);
10967 ArrayRef<SDValue> Ops) {
10971 return getNodeIfExists(Opcode, VTList, Ops, Flags);
10975 ArrayRef<SDValue> Ops,
10979 AddNodeIDNode(ID, Opcode, VTList, Ops);
10991 ArrayRef<SDValue> Ops) {
10994 AddNodeIDNode(ID, Opcode, VTList, Ops);
13121 SDUse *Ops = OperandRecycler.allocate(
13126 Ops[I].setUser(Node);
13127 Ops[I].setInitial(Vals[I]);
13128 if (Ops[I].Val.getValueType() != MVT::Other) // Skip Chain. It does not carry divergence.
13129 IsDivergent |= Ops[I].getNode()->isDivergent();
13132 Node->OperandList = Ops;