CodeGen/SelectionDAG/SelectionDAG.cpp

929                                             SDValue N2,
938         Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs, N1, N2, *Flags);
944       BinarySDNode(Opcode, DL.getIROrder(), DL.getDebugLoc(), VTs, N1, N2);
1479 // commuteShuffle - swaps the values of N1 and N2, and swaps all indices in
1480 // the shuffle mask M that point at N1 to point at N2, and indices that point
1481 // N2 to point at N1.
1482 static void commuteShuffle(SDValue &N1, SDValue &N2, SmallVectorImpl<int> &M) {
1483   std::swap(N1, N2);
1488                                        SDValue N2, const int *Mask) {
1489   assert(VT == N1.getValueType() && VT == N2.getValueType() &&
1493   if (N1.getOpcode() == ISD::UNDEF && N2.getOpcode() == ISD::UNDEF)
1506   if (N1 == N2) {
1507     N2 = getUNDEF(VT);
1514     commuteShuffle(N1, N2, MaskVec);
1541   if (auto *N2BV = dyn_cast<BuildVectorSDNode>(N2))
1547   bool N2Undef = N2.getOpcode() == ISD::UNDEF;
1561     N2 = getUNDEF(VT);
1564     commuteShuffle(N1, N2, MaskVec);
1567   N2Undef = N2.getOpcode() == ISD::UNDEF;
1631   SDValue Ops[2] = { N1, N2 };
1648                                             dl.getDebugLoc(), N1, N2,
1909                                 SDValue N2, ISD::CondCode Cond, SDLoc dl) {
1938   if (ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2)) {
1959     if (ConstantFPSDNode *N2C = dyn_cast<ConstantFPSDNode>(N2)) {
2009       return getSetCC(dl, VT, N2, N1, SwappedCond);
3430                               SDValue N2, const SDNodeFlags *Flags) {
3432   ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2);
3434   ConstantFPSDNode *N2CFP = dyn_cast<ConstantFPSDNode>(N2);
3440       std::swap(N1, N2);
3443       std::swap(N1, N2);
3451            N2.getValueType() == MVT::Other && "Invalid token factor!");
3453     if (N1.getOpcode() == ISD::EntryToken) return N2;
3454     if (N2.getOpcode() == ISD::EntryToken) return N1;
3455     if (N1 == N2) return N1;
3459     SDValue Ops[] = {N1, N2};
3466     assert(N1.getValueType() == N2.getValueType() &&
3471       return N2;
3480     assert(N1.getValueType() == N2.getValueType() &&
3499     assert(N1.getValueType() == N2.getValueType() &&
3519           return N2;
3526     assert(N1.getValueType() == N2.getValueType() &&
3529   case ISD::FCOPYSIGN:   // N1 and result must match.  N1/N2 need not match.
3532            N2.getValueType().isFloatingPoint() &&
3542     assert(VT.isInteger() && N2.getValueType().isInteger() &&
3544     assert((!VT.isVector() || VT == N2.getValueType()) &&
3550     assert(N2.getValueType().getSizeInBits() >=
3563     EVT EVT = cast<VTSDNode>(N2)->getVT();
3575     if (cast<VTSDNode>(N2)->getVT() == VT) return N1;  // Not actually rounding.
3587     EVT EVT = cast<VTSDNode>(N2)->getVT();
3599     EVT EVT = cast<VTSDNode>(N2)->getVT();
3663                                  N2.getValueType()));
3697         return getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, N1.getOperand(0), N2);
3747           FoldConstantArithmetic(Opcode, DL, VT, N1.getNode(), N2.getNode()))
3807       std::swap(N1, N2);
3828         return N2;
3834   if (N2.getOpcode() == ISD::UNDEF) {
3850       return N2;       // fold op(arg1, undef) -> undef
3857         return N2;
3883     SDValue Ops[] = {N1, N2};
3893     N = GetBinarySDNode(Opcode, DL, VTs, N1, N2, Flags);
3897     N = GetBinarySDNode(Opcode, DL, VTs, N1, N2, Flags);
3905                               SDValue N1, SDValue N2, SDValue N3) {
3910     ConstantFPSDNode *N2CFP = dyn_cast<ConstantFPSDNode>(N2);
3925     SDValue Ops[] = {N1, N2, N3};
3932     if (SDValue V = FoldSetCC(VT, N1, N2, cast<CondCodeSDNode>(N3)->get(), DL))
3935     SDValue Ops[] = {N1, N2, N3};
3943        return N2;             // select true, X, Y -> X
3947     if (N2 == N3) return N2;   // select C, X, X -> X
3954         && N2.getValueType().isSimple()) {
3956              N2.getValueType().isVector() &&
3960       assert(N2.getSimpleValueType() <= N1.getSimpleValueType() &&
3963         assert((N2.getValueType().getVectorNumElements() +
3970       if (VT.getSimpleVT() == N2.getSimpleValueType())
3971         return N2;
3986     SDValue Ops[] = { N1, N2, N3 };
3994                                           DL.getDebugLoc(), VTs, N1, N2, N3);
3998                                           DL.getDebugLoc(), VTs, N1, N2, N3);
4006                               SDValue N1, SDValue N2, SDValue N3,
4008   SDValue Ops[] = { N1, N2, N3, N4 };
4013                               SDValue N1, SDValue N2, SDValue N3,
4015   SDValue Ops[] = { N1, N2, N3, N4, N5 };
5536       return getNode(Opcode, DL, VT, N1, N2, N3.getOperand(0));
5543           return getNode(Opcode, DL, VT, N1, N2, N3.getOperand(0));
5607                               SDValue N1, SDValue N2) {
5608   SDValue Ops[] = { N1, N2 };
5613                               SDValue N1, SDValue N2, SDValue N3) {
5614   SDValue Ops[] = { N1, N2, N3 };
5619                               SDValue N1, SDValue N2, SDValue N3,
5621   SDValue Ops[] = { N1, N2, N3, N4 };
5626                               SDValue N1, SDValue N2, SDValue N3,
5628   SDValue Ops[] = { N1, N2, N3, N4, N5 };