Lines Matching defs:Ops
730 ArrayRef<SDValue> Ops) {
731 for (const auto &Op : Ops) {
739 ArrayRef<SDUse> Ops) {
740 for (const auto &Op : Ops) {
1310 SDValue Ops[] = { Op };
1312 AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops);
1330 SDValue Ops[] = { Op1, Op2 };
1332 AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops);
1344 SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N, ArrayRef<SDValue> Ops,
1350 AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops);
1758 SmallVector<SDValue, 8> Ops;
1760 llvm::append_range(Ops, EltParts);
1763 getNode(ISD::BITCAST, DL, VT, getBuildVector(ViaVecVT, DL, Ops));
2292 SDValue Ops[2] = { N1, N2 };
2293 AddNodeIDNode(ID, ISD::VECTOR_SHUFFLE, VTs, Ops);
2309 createOperands(N, Ops);
2366 SDValue Ops[] = { Root };
2367 AddNodeIDNode(ID, Opcode, getVTList(MVT::Other), Ops);
2375 createOperands(N, Ops);
2443 SDValue Ops[] = {Ptr};
2445 AddNodeIDNode(ID, ISD::ADDRSPACECAST, VTs, Ops);
2455 createOperands(N, Ops);
6060 ArrayRef<SDValue> Ops,
6062 int NumOps = Ops.size();
6070 if (llvm::all_of(Ops, [](SDValue Op) { return Op.isUndef(); }))
6077 if (Ops[i].getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
6078 Ops[i].getOperand(0).getValueType() != VT ||
6079 (IdentitySrc && Ops[i].getOperand(0) != IdentitySrc) ||
6080 !isa<ConstantSDNode>(Ops[i].getOperand(1)) ||
6081 Ops[i].getConstantOperandAPInt(1) != i) {
6085 IdentitySrc = Ops[i].getOperand(0);
6096 ArrayRef<SDValue> Ops,
6098 assert(!Ops.empty() && "Can't concatenate an empty list of vectors!");
6099 assert(llvm::all_of(Ops,
6100 [Ops](SDValue Op) {
6101 return Ops[0].getValueType() == Op.getValueType();
6104 assert((Ops[0].getValueType().getVectorElementCount() * Ops.size()) ==
6108 if (Ops.size() == 1)
6109 return Ops[0];
6112 if (llvm::all_of(Ops, [](SDValue Op) { return Op.isUndef(); }))
6120 for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
6121 SDValue Op = Ops[i];
6149 for (SDValue Op : Ops) {
6244 SDValue Ops = {N1};
6245 if (SDValue Fold = FoldConstantArithmetic(Opcode, DL, VT, Ops))
6271 SDValue Ops[] = {N1};
6272 if (SDValue V = FoldBUILD_VECTOR(DL, VT, Ops, *this))
6527 SDValue Ops[] = {N1};
6530 AddNodeIDNode(ID, Opcode, VTs, Ops);
6539 createOperands(N, Ops);
6543 createOperands(N, Ops);
6647 bool SelectionDAG::isUndef(unsigned Opcode, ArrayRef<SDValue> Ops) {
6655 assert(Ops.size() == 2 && "Div/rem should have 2 operands");
6656 SDValue Divisor = Ops[1];
6673 EVT VT, ArrayRef<SDValue> Ops,
6684 unsigned NumOps = Ops.size();
6688 if (isUndef(Opcode, Ops))
6693 SDValue N1 = Ops[0];
6857 if (SDValue CFP = foldConstantFPMath(Opcode, DL, VT, Ops))
6860 if (auto *C1 = dyn_cast<ConstantSDNode>(Ops[0])) {
6861 if (auto *C2 = dyn_cast<ConstantSDNode>(Ops[1])) {
6878 if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Ops[0]))
6879 return FoldSymbolOffset(Opcode, VT, GA, Ops[1].getNode());
6881 if (GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Ops[1]))
6882 return FoldSymbolOffset(Opcode, VT, GA, Ops[0].getNode());
6886 EVT EVT = cast<VTSDNode>(Ops[1])->getVT();
6895 if (auto *C1 = dyn_cast<ConstantSDNode>(Ops[0])) {
6900 if (ISD::isBuildVectorOfConstantSDNodes(Ops[0].getNode())) {
6902 llvm::EVT OpVT = Ops[0].getOperand(0).getValueType();
6904 SDValue Op = Ops[0].getOperand(I);
6915 if (Ops[0].getOpcode() == ISD::SPLAT_VECTOR &&
6916 isa<ConstantSDNode>(Ops[0].getOperand(0)))
6918 SignExtendInReg(Ops[0].getConstantOperandAPInt(0),
6919 Ops[0].getOperand(0).getValueType()));
6931 Ops[0].getValueType() == VT && Ops[1].getValueType() == VT &&
6932 (Ops[0].getOpcode() == ISD::BITCAST ||
6933 Ops[1].getOpcode() == ISD::BITCAST)) {
6934 SDValue N1 = peekThroughBitcasts(Ops[0]);
6935 SDValue N2 = peekThroughBitcasts(Ops[1]);
6971 SmallVector<SDValue> Ops(DstBits.size(), getUNDEF(BVEltVT));
6975 Ops[I] = getConstant(DstBits[I].sext(BVEltBits), DL, BVEltVT);
6977 return getBitcast(VT, getBuildVector(BVVT, DL, Ops));
6986 Ops[0].getOpcode() == ISD::STEP_VECTOR) {
6988 if (ISD::isConstantSplatVector(Ops[1].getNode(), RHSVal)) {
6990 ? Ops[0].getConstantOperandAPInt(0) * RHSVal
6991 : Ops[0].getConstantOperandAPInt(0) << RHSVal;
7010 if (!llvm::all_of(Ops, IsBuildVectorSplatVectorOrUndef) ||
7011 !llvm::all_of(Ops, IsScalarOrSameVectorSize))
7041 for (SDValue Op : Ops) {
7098 EVT VT, ArrayRef<SDValue> Ops) {
7100 if (Ops.size() != 2)
7107 SDValue N1 = Ops[0];
7108 SDValue N2 = Ops[1];
7266 SDValue Ops[] = {N1, N2};
7267 if (SDValue V = FoldBUILD_VECTOR(DL, VT, Ops, *this))
7272 SDValue Ops[] = {N1, N2};
7273 if (SDValue V = foldCONCAT_VECTORS(DL, VT, Ops, *this))
7692 SDValue Ops[] = {N1, N2};
7695 AddNodeIDNode(ID, Opcode, VTs, Ops);
7704 createOperands(N, Ops);
7708 createOperands(N, Ops);
7757 SDValue Ops[] = {N1, N2, N3};
7758 if (SDValue V = FoldBUILD_VECTOR(DL, VT, Ops, *this))
7763 SDValue Ops[] = {N1, N2, N3};
7764 if (SDValue V = foldCONCAT_VECTORS(DL, VT, Ops, *this))
7781 SDValue Ops[] = {N1, N2, N3};
7782 if (SDValue V = FoldConstantArithmetic(Opcode, DL, VT, Ops)) {
7890 SDValue Ops[] = {N1, N2, N3};
7893 AddNodeIDNode(ID, Opcode, VTs, Ops);
7902 createOperands(N, Ops);
7906 createOperands(N, Ops);
7918 SDValue Ops[] = { N1, N2, N3, N4 };
7919 return getNode(Opcode, DL, VT, Ops, Flags);
7933 SDValue Ops[] = { N1, N2, N3, N4, N5 };
7934 return getNode(Opcode, DL, VT, Ops, Flags);
8963 SDVTList VTList, ArrayRef<SDValue> Ops,
8967 AddNodeIDNode(ID, Opcode, VTList, Ops);
8978 createOperands(N, Ops);
8993 SDValue Ops[] = {Chain, Ptr, Cmp, Swp};
8994 return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO);
9019 SDValue Ops[] = {Chain, Ptr, Val};
9020 return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO);
9029 SDValue Ops[] = {Chain, Ptr};
9030 return getAtomic(Opcode, dl, MemVT, VTs, Ops, MMO);
9034 SDValue SelectionDAG::getMergeValues(ArrayRef<SDValue> Ops, const SDLoc &dl) {
9035 if (Ops.size() == 1)
9036 return Ops[0];
9039 VTs.reserve(Ops.size());
9040 for (const SDValue &Op : Ops)
9042 return getNode(ISD::MERGE_VALUES, dl, getVTList(VTs), Ops);
9046 unsigned Opcode, const SDLoc &dl, SDVTList VTList, ArrayRef<SDValue> Ops,
9057 return getMemIntrinsicNode(Opcode, dl, VTList, Ops, MemVT, MMO);
9062 ArrayRef<SDValue> Ops, EVT MemVT,
9075 AddNodeIDNode(ID, Opcode, VTList, Ops);
9089 createOperands(N, Ops);
9095 createOperands(N, Ops);
9108 SDValue Ops[2] = {
9115 AddNodeIDNode(ID, Opcode, VTs, Ops);
9125 createOperands(N, Ops);
9138 SDValue Ops[] = {Chain};
9140 AddNodeIDNode(ID, Opcode, VTs, Ops);
9149 createOperands(N, Ops);
9246 SDValue Ops[] = { Chain, Ptr, Offset };
9248 AddNodeIDNode(ID, ISD::LOAD, VTs, Ops);
9261 createOperands(N, Ops);
9347 SDValue Ops[] = { Chain, Val, Ptr, Undef };
9349 AddNodeIDNode(ID, ISD::STORE, VTs, Ops);
9362 createOperands(N, Ops);
9414 SDValue Ops[] = { Chain, Val, Ptr, Undef };
9416 AddNodeIDNode(ID, ISD::STORE, VTs, Ops);
9429 createOperands(N, Ops);
9444 SDValue Ops[] = { ST->getChain(), ST->getValue(), Base, Offset };
9446 AddNodeIDNode(ID, ISD::STORE, VTs, Ops);
9458 createOperands(N, Ops);
9501 SDValue Ops[] = {Chain, Ptr, Offset, Mask, EVL};
9503 AddNodeIDNode(ID, ISD::VP_LOAD, VTs, Ops);
9516 createOperands(N, Ops);
9594 SDValue Ops[] = {Chain, Val, Ptr, Offset, Mask, EVL};
9596 AddNodeIDNode(ID, ISD::VP_STORE, VTs, Ops);
9609 createOperands(N, Ops);
9665 SDValue Ops[] = {Chain, Val, Ptr, Undef, Mask, EVL};
9667 AddNodeIDNode(ID, ISD::VP_STORE, VTs, Ops);
9681 createOperands(N, Ops);
9696 SDValue Ops[] = {ST->getChain(), ST->getValue(), Base,
9699 AddNodeIDNode(ID, ISD::VP_STORE, VTs, Ops);
9711 createOperands(N, Ops);
9727 SDValue Ops[] = {Chain, Ptr, Offset, Stride, Mask, EVL};
9731 AddNodeIDNode(ID, ISD::EXPERIMENTAL_VP_STRIDED_LOAD, VTs, Ops);
9746 createOperands(N, Ops);
9785 SDValue Ops[] = {Chain, Val, Ptr, Offset, Stride, Mask, EVL};
9787 AddNodeIDNode(ID, ISD::EXPERIMENTAL_VP_STRIDED_STORE, VTs, Ops);
9800 createOperands(N, Ops);
9834 SDValue Ops[] = {Chain, Val, Ptr, Undef, Stride, Mask, EVL};
9836 AddNodeIDNode(ID, ISD::EXPERIMENTAL_VP_STRIDED_STORE, VTs, Ops);
9849 createOperands(N, Ops);
9859 ArrayRef<SDValue> Ops, MachineMemOperand *MMO,
9861 assert(Ops.size() == 6 && "Incompatible number of operands");
9864 AddNodeIDNode(ID, ISD::VP_GATHER, VTs, Ops);
9878 createOperands(N, Ops);
9902 ArrayRef<SDValue> Ops,
9905 assert(Ops.size() == 7 && "Incompatible number of operands");
9908 AddNodeIDNode(ID, ISD::VP_SCATTER, VTs, Ops);
9921 createOperands(N, Ops);
9956 SDValue Ops[] = {Chain, Base, Offset, Mask, PassThru};
9958 AddNodeIDNode(ID, ISD::MLOAD, VTs, Ops);
9971 createOperands(N, Ops);
10004 SDValue Ops[] = {Chain, Val, Base, Offset, Mask};
10006 AddNodeIDNode(ID, ISD::MSTORE, VTs, Ops);
10020 createOperands(N, Ops);
10041 ArrayRef<SDValue> Ops,
10045 assert(Ops.size() == 6 && "Incompatible number of operands");
10048 AddNodeIDNode(ID, ISD::MGATHER, VTs, Ops);
10062 createOperands(N, Ops);
10088 ArrayRef<SDValue> Ops,
10092 assert(Ops.size() == 6 && "Incompatible number of operands");
10095 AddNodeIDNode(ID, ISD::MSCATTER, VTs, Ops);
10109 createOperands(N, Ops);
10134 const SDLoc &dl, ArrayRef<SDValue> Ops,
10137 assert(Ops.size() == 7 && "Incompatible number of operands");
10140 AddNodeIDNode(ID, ISD::EXPERIMENTAL_VECTOR_HISTOGRAM, VTs, Ops);
10154 createOperands(N, Ops);
10175 SDValue Ops[] = {Chain, Ptr};
10177 AddNodeIDNode(ID, ISD::GET_FPENV_MEM, VTs, Ops);
10189 createOperands(N, Ops);
10202 SDValue Ops[] = {Chain, Ptr};
10204 AddNodeIDNode(ID, ISD::SET_FPENV_MEM, VTs, Ops);
10216 createOperands(N, Ops);
10323 SDValue Ops[] = { Chain, Ptr, SV, getTargetConstant(Align, dl, MVT::i32) };
10324 return getNode(ISD::VAARG, dl, getVTList(VT, MVT::Other), Ops);
10328 ArrayRef<SDUse> Ops) {
10329 switch (Ops.size()) {
10331 case 1: return getNode(Opcode, DL, VT, static_cast<const SDValue>(Ops[0]));
10332 case 2: return getNode(Opcode, DL, VT, Ops[0], Ops[1]);
10333 case 3: return getNode(Opcode, DL, VT, Ops[0], Ops[1], Ops[2]);
10339 SmallVector<SDValue, 8> NewOps(Ops);
10344 ArrayRef<SDValue> Ops) {
10348 return getNode(Opcode, DL, VT, Ops, Flags);
10352 ArrayRef<SDValue> Ops, const SDNodeFlags Flags) {
10353 unsigned NumOps = Ops.size();
10356 case 1: return getNode(Opcode, DL, VT, Ops[0], Flags);
10357 case 2: return getNode(Opcode, DL, VT, Ops[0], Ops[1], Flags);
10358 case 3: return getNode(Opcode, DL, VT, Ops[0], Ops[1], Ops[2], Flags);
10363 for (const auto &Op : Ops)
10372 if (SDValue V = FoldBUILD_VECTOR(DL, VT, Ops, *this))
10376 if (SDValue V = foldCONCAT_VECTORS(DL, VT, Ops, *this))
10381 assert(Ops[0].getValueType() == Ops[1].getValueType() &&
10383 assert(Ops[2].getValueType() == Ops[3].getValueType() &&
10385 assert(Ops[2].getValueType() == VT &&
10387 assert((!Ops[0].getValueType().isVector() ||
10388 Ops[0].getValueType().getVectorElementCount() ==
10395 assert(Ops[2].getValueType() == Ops[3].getValueType() &&
10441 AddNodeIDNode(ID, Opcode, VTs, Ops);
10450 createOperands(N, Ops);
10455 createOperands(N, Ops);
10466 ArrayRef<EVT> ResultTys, ArrayRef<SDValue> Ops) {
10467 return getNode(Opcode, DL, getVTList(ResultTys), Ops);
10471 ArrayRef<SDValue> Ops) {
10475 return getNode(Opcode, DL, VTList, Ops, Flags);
10479 ArrayRef<SDValue> Ops, const SDNodeFlags Flags) {
10481 return getNode(Opcode, DL, VTList.VTs[0], Ops, Flags);
10484 for (const auto &Op : Ops)
10494 assert(VTList.NumVTs == 2 && Ops.size() == 2 &&
10497 Ops[0].getValueType() == Ops[1].getValueType() &&
10498 Ops[0].getValueType() == VTList.VTs[0] &&
10500 SDValue N1 = Ops[0], N2 = Ops[1];
10537 assert(VTList.NumVTs == 2 && Ops.size() == 3 &&
10540 Ops[0].getValueType() == Ops[1].getValueType() &&
10541 Ops[0].getValueType() == VTList.VTs[0] &&
10542 Ops[2].getValueType() == VTList.VTs[1] &&
10547 assert(VTList.NumVTs == 2 && Ops.size() == 2 && "Invalid mul lo/hi op!");
10549 VTList.VTs[0] == Ops[0].getValueType() &&
10550 VTList.VTs[0] == Ops[1].getValueType() &&
10553 ConstantSDNode *LHS = dyn_cast<ConstantSDNode>(Ops[0]);
10554 ConstantSDNode *RHS = dyn_cast<ConstantSDNode>(Ops[1]);
10577 assert(VTList.NumVTs == 2 && Ops.size() == 1 && "Invalid ffrexp op!");
10579 VTList.VTs[0] == Ops[0].getValueType() && "frexp type mismatch");
10581 if (const ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(Ops[0])) {
10594 assert(VTList.NumVTs == 2 && Ops.size() == 2 &&
10597 Ops[1].getValueType().isFloatingPoint() && "Invalid FP cast!");
10598 assert(VTList.VTs[0].isVector() == Ops[1].getValueType().isVector() &&
10603 Ops[1].getValueType().getVectorElementCount()) &&
10605 assert(Ops[1].getValueType().bitsLT(VTList.VTs[0]) &&
10609 assert(VTList.NumVTs == 2 && Ops.size() == 3 && "Invalid STRICT_FP_ROUND!");
10610 assert(VTList.VTs[0].isVector() == Ops[1].getValueType().isVector() &&
10615 Ops[1].getValueType().getVectorElementCount()) &&
10618 Ops[1].getValueType().isFloatingPoint() &&
10619 VTList.VTs[0].bitsLT(Ops[1].getValueType()) &&
10620 Ops[2].getOpcode() == ISD::TargetConstant &&
10621 (Ops[2]->getAsZExtVal() == 0 || Ops[2]->getAsZExtVal() == 1) &&
10650 AddNodeIDNode(ID, Opcode, VTList, Ops);
10658 createOperands(N, Ops);
10662 createOperands(N, Ops);
10679 SDValue Ops[] = { N1 };
10680 return getNode(Opcode, DL, VTList, Ops);
10685 SDValue Ops[] = { N1, N2 };
10686 return getNode(Opcode, DL, VTList, Ops);
10691 SDValue Ops[] = { N1, N2, N3 };
10692 return getNode(Opcode, DL, VTList, Ops);
10697 SDValue Ops[] = { N1, N2, N3, N4 };
10698 return getNode(Opcode, DL, VTList, Ops);
10704 SDValue Ops[] = { N1, N2, N3, N4, N5 };
10705 return getNode(Opcode, DL, VTList, Ops);
10857 SDValue Ops[] = { Op1, Op2, Op3 };
10858 return UpdateNodeOperands(N, Ops);
10864 SDValue Ops[] = { Op1, Op2, Op3, Op4 };
10865 return UpdateNodeOperands(N, Ops);
10871 SDValue Ops[] = { Op1, Op2, Op3, Op4, Op5 };
10872 return UpdateNodeOperands(N, Ops);
10876 UpdateNodeOperands(SDNode *N, ArrayRef<SDValue> Ops) {
10877 unsigned NumOps = Ops.size();
10882 if (std::equal(Ops.begin(), Ops.end(), N->op_begin()))
10887 if (SDNode *Existing = FindModifiedNodeSlot(N, Ops, InsertPos))
10897 if (N->OperandList[i] != Ops[i])
10898 N->OperandList[i].set(Ops[i]);
10950 SDValue Ops[] = { Op1 };
10951 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10958 SDValue Ops[] = { Op1, Op2 };
10959 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10966 SDValue Ops[] = { Op1, Op2, Op3 };
10967 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10971 EVT VT, ArrayRef<SDValue> Ops) {
10973 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10977 EVT VT1, EVT VT2, ArrayRef<SDValue> Ops) {
10979 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10990 ArrayRef<SDValue> Ops) {
10992 return SelectNodeTo(N, MachineOpc, VTs, Ops);
10999 SDValue Ops[] = { Op1, Op2 };
11000 return SelectNodeTo(N, MachineOpc, VTs, Ops);
11004 SDVTList VTs,ArrayRef<SDValue> Ops) {
11005 SDNode *New = MorphNodeTo(N, ~MachineOpc, VTs, Ops);
11049 SDVTList VTs, ArrayRef<SDValue> Ops) {
11054 AddNodeIDNode(ID, Opc, VTs, Ops);
11084 createOperands(N, Ops);
11121 SmallVector<SDValue, 3> Ops;
11123 Ops.push_back(Node->getOperand(i));
11126 SDNode *Res = MorphNodeTo(Node, NewOpc, VTs, Ops);
11158 SDValue Ops[] = { Op1 };
11159 return getMachineNode(Opcode, dl, VTs, Ops);
11165 SDValue Ops[] = { Op1, Op2 };
11166 return getMachineNode(Opcode, dl, VTs, Ops);
11173 SDValue Ops[] = { Op1, Op2, Op3 };
11174 return getMachineNode(Opcode, dl, VTs, Ops);
11178 EVT VT, ArrayRef<SDValue> Ops) {
11180 return getMachineNode(Opcode, dl, VTs, Ops);
11187 SDValue Ops[] = { Op1, Op2 };
11188 return getMachineNode(Opcode, dl, VTs, Ops);
11195 SDValue Ops[] = { Op1, Op2, Op3 };
11196 return getMachineNode(Opcode, dl, VTs, Ops);
11201 ArrayRef<SDValue> Ops) {
11203 return getMachineNode(Opcode, dl, VTs, Ops);
11210 SDValue Ops[] = { Op1, Op2 };
11211 return getMachineNode(Opcode, dl, VTs, Ops);
11219 SDValue Ops[] = { Op1, Op2, Op3 };
11220 return getMachineNode(Opcode, dl, VTs, Ops);
11225 ArrayRef<SDValue> Ops) {
11227 return getMachineNode(Opcode, dl, VTs, Ops);
11232 ArrayRef<SDValue> Ops) {
11234 return getMachineNode(Opcode, dl, VTs, Ops);
11239 ArrayRef<SDValue> Ops) {
11246 AddNodeIDNode(ID, ~Opcode, VTs, Ops);
11255 createOperands(N, Ops);
11288 ArrayRef<SDValue> Ops) {
11292 return getNodeIfExists(Opcode, VTList, Ops, Flags);
11296 ArrayRef<SDValue> Ops,
11300 AddNodeIDNode(ID, Opcode, VTList, Ops);
11312 ArrayRef<SDValue> Ops) {
11315 AddNodeIDNode(ID, Opcode, VTList, Ops);
13507 SDUse *Ops = OperandRecycler.allocate(
13512 Ops[I].setUser(Node);
13513 Ops[I].setInitial(Vals[I]);
13514 EVT VT = Ops[I].getValueType();
13518 (VT != MVT::Glue || gluePropagatesDivergence(Ops[I].getNode())) &&
13519 Ops[I].getNode()->isDivergent()) {
13524 Node->OperandList = Ops;