|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/CodeGen/SelectionDAG.h 916 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
References
include/llvm/CodeGen/SelectionDAG.h 858 return getNode(ISD::ADD, SL, VT, Op, Offset, Flags);
include/llvm/CodeGen/TargetLowering.h 4232 return DAG.getNode(ISD::BRIND, dl, MVT::Other, Value, Addr);
lib/CodeGen/SelectionDAG/DAGCombiner.cpp 953 return DAG.getNode(Opc, DL, VT, N0.getOperand(0), OpNode);
959 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N0.getOperand(0), N1);
962 return DAG.getNode(Opc, DL, VT, OpNode, N0.getOperand(1));
1119 return DAG.getNode(ISD::AssertSext, DL, PVT, Op0, Op.getOperand(1));
1123 return DAG.getNode(ISD::AssertZext, DL, PVT, Op0, Op.getOperand(1));
1150 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, NewOp.getValueType(), NewOp,
1203 DAG.getNode(ISD::TRUNCATE, DL, VT, DAG.getNode(Opc, DL, PVT, NN0, NN1));
1273 DAG.getNode(ISD::TRUNCATE, DL, VT, DAG.getNode(Opc, DL, PVT, N0, N1));
1975 SDValue NewCT = SelOpNo ? DAG.getNode(BinOpcode, DL, VT, CBO, CT)
1976 : DAG.getNode(BinOpcode, DL, VT, CT, CBO);
1982 SDValue NewCF = SelOpNo ? DAG.getNode(BinOpcode, DL, VT, CBO, CF)
1983 : DAG.getNode(BinOpcode, DL, VT, CF, CBO);
2030 return DAG.getNode(IsAdd ? ISD::SUB : ISD::ADD, DL, VT, C1, LowBit);
2066 SDValue NewShift = DAG.getNode(ShOpcode, DL, VT, Not.getOperand(0), ShAmt);
2068 return DAG.getNode(ISD::ADD, DL, VT, NewShift, DAG.getConstant(NewC, DL, VT));
2102 return DAG.getNode(ISD::ADD, DL, VT, N1, N0);
2119 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), Sub);
2128 return DAG.getNode(ISD::SUB, DL, VT, Add, N0.getOperand(1));
2152 SDValue Add0 = DAG.getNode(ISD::ADD, DL, VT, N1, N0.getOperand(1));
2153 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), Add0);
2167 return DAG.getNode(ISD::SUB, DL, VT, N1, N0.getOperand(1));
2171 return DAG.getNode(ISD::SUB, DL, VT, N0, N1.getOperand(1));
2184 return DAG.getNode(ISD::SUB, DL, VT, N1.getOperand(0),
2190 return DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0),
2196 return DAG.getNode(ISD::SUB, DL, VT, N1.getOperand(0),
2202 return DAG.getNode(ISD::SUB, DL, VT, N1.getOperand(0),
2209 return DAG.getNode(N1.getOpcode(), DL, VT, N1.getOperand(0).getOperand(0),
2220 return DAG.getNode(ISD::SUB, DL, VT,
2221 DAG.getNode(ISD::ADD, SDLoc(N0), VT, N00, N10),
2222 DAG.getNode(ISD::ADD, SDLoc(N1), VT, N01, N11));
2233 return DAG.getNode(ISD::USUBSAT, DL, VT, N0.getOperand(0),
2243 return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
2261 return DAG.getNode(ISD::SUB, DL, VT, A, Xor.getOperand(0));
2270 SDValue Not = DAG.getNode(ISD::XOR, DL, VT, N0.getOperand(0),
2272 return DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(1), Not);
2279 SDValue Xor = DAG.getNode(ISD::XOR, DL, VT, N0.getOperand(1), N1);
2280 return DAG.getNode(ISD::ADD, DL, VT, Xor, N0.getOperand(0));
2310 return DAG.getNode(ISD::OR, DL, VT, N0, N1);
2340 return DAG.getNode(Opcode, DL, VT, N1, N0);
2353 return DAG.getNode(ISD::ADD, DL, VT, N0, N1);
2414 return DAG.getNode(IsAdd ? ISD::SUB : ISD::ADD, DL, VT, N0, N1.getOperand(0));
2426 return DAG.getNode(ISD::SUB, DL, VT, N0,
2427 DAG.getNode(ISD::SHL, DL, VT,
2440 SDValue Not = DAG.getNode(ISD::XOR, DL, VT, N0.getOperand(0),
2442 return DAG.getNode(ISD::SUB, DL, VT, N1, Not);
2450 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), N1);
2451 return DAG.getNode(ISD::SUB, DL, VT, Add, N0.getOperand(1));
2457 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N1, N0.getOperand(1));
2458 return DAG.getNode(ISD::ADD, DL, VT, Sub, N0.getOperand(0));
2468 return DAG.getNode(ISD::SUB, DL, VT, N1, ZExt);
2475 SDValue ZExt = DAG.getNode(ISD::AND, DL, VT, N1.getOperand(0),
2477 return DAG.getNode(ISD::SUB, DL, VT, N0, ZExt);
2505 return CombineTo(N, DAG.getNode(ISD::ADD, DL, VT, N0, N1),
2521 return CombineTo(N, DAG.getNode(ISD::ADD, DL, VT, N0, N1),
2542 return DAG.getNode(ISD::XOR, DL, VT, V, Cst);
2598 return CombineTo(N, DAG.getNode(ISD::ADD, DL, VT, N0, N1),
2613 return CombineTo(N, DAG.getNode(ISD::ADD, DL, VT, N0, N1),
2702 return CombineTo(N, DAG.getNode(ISD::AND, DL, VT, CarryExt,
2887 return DAG.getNode(ISD::ADD, DL, VT, N0,
2902 return DAG.getNode(NewSh, DL, VT, N1.getOperand(0), N1.getOperand(1));
2923 return DAG.getNode(ISD::XOR, DL, VT, N1, N0);
2927 return DAG.getNode(ISD::ADD, DL, VT, N0, N1.getOperand(1));
2948 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), NewC);
2959 return DAG.getNode(ISD::SUB, DL, VT, NewC, N1.getOperand(0));
2970 return DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0), NewC);
2980 return DAG.getNode(ISD::SUB, DL, VT, NewC, N0.getOperand(1));
2988 return DAG.getNode(N0.getOperand(1).getOpcode(), DL, VT, N0.getOperand(0),
2994 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0),
3000 return DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0),
3005 return DAG.getNode(ISD::ADD, DL, VT, N0,
3006 DAG.getNode(ISD::SUB, DL, VT, N1.getOperand(1),
3013 SDValue Mul = DAG.getNode(ISD::MUL, DL, VT,
3016 return DAG.getNode(ISD::ADD, DL, VT, N0, Mul);
3020 SDValue Mul = DAG.getNode(ISD::MUL, DL, VT,
3023 return DAG.getNode(ISD::ADD, DL, VT, N0, Mul);
3044 SDValue Xor = DAG.getNode(ISD::XOR, DL, VT, N0.getOperand(1),
3046 return DAG.getNode(ISD::ADD, DL, VT, Xor, N0.getOperand(0));
3054 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0, N1.getOperand(0));
3055 return DAG.getNode(ISD::ADD, DL, VT, Add, DAG.getConstant(1, DL, VT));
3062 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0), N1);
3063 return DAG.getNode(ISD::ADD, DL, VT, Sub, N0.getOperand(1));
3068 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0, N1.getOperand(0));
3069 return DAG.getNode(ISD::SUB, DL, VT, Sub, N1.getOperand(1));
3075 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0), N1);
3076 return DAG.getNode(ISD::SUB, DL, VT, Sub, N0.getOperand(1));
3081 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(1), N1);
3082 return DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0), Add);
3093 return DAG.getNode(ISD::ADD, DL, VT, N0, SExt);
3129 SDValue ZExt = DAG.getNode(ISD::AND, DL, VT, N1.getOperand(0),
3131 return DAG.getNode(ISD::ADD, DL, VT, N0, ZExt);
3142 SDValue SRA = DAG.getNode(ISD::SRA, DL, VT, N1.getOperand(0), ShAmt);
3143 return DAG.getNode(ISD::ADD, DL, VT, N0, SRA);
3152 SDValue NegX = DAG.getNode(ISD::SUB, DL, VT, Zero, X);
3207 return CombineTo(N, DAG.getNode(ISD::SUB, DL, VT, N0, N1),
3221 return CombineTo(N, DAG.getNode(ISD::XOR, DL, VT, N1, N0),
3238 return CombineTo(N, DAG.getNode(ISD::SUB, DL, VT, N0, N1),
3260 return CombineTo(N, DAG.getNode(ISD::XOR, DL, VT, N1, N0),
3365 return DAG.getNode(ISD::MUL, SDLoc(N), VT, N1, N0);
3379 return DAG.getNode(ISD::SUB, DL, VT,
3390 return DAG.getNode(ISD::SHL, DL, VT, N0, Trunc);
3398 return DAG.getNode(ISD::SUB, DL, VT,
3400 DAG.getNode(ISD::SHL, DL, VT, N0,
3430 DAG.getNode(ISD::SHL, DL, VT, N0, DAG.getConstant(ShAmt, DL, VT));
3431 SDValue R = DAG.getNode(MathOp, DL, VT, Shl, N0);
3433 R = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), R);
3442 SDValue C3 = DAG.getNode(ISD::SHL, SDLoc(N), VT, N1, N0.getOperand(1));
3444 return DAG.getNode(ISD::MUL, SDLoc(N), VT, N0.getOperand(0), C3);
3464 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT, Sh.getOperand(0), Y);
3465 return DAG.getNode(ISD::SHL, SDLoc(N), VT, Mul, Sh.getOperand(1));
3474 return DAG.getNode(ISD::ADD, SDLoc(N), VT,
3475 DAG.getNode(ISD::MUL, SDLoc(N0), VT,
3477 DAG.getNode(ISD::MUL, SDLoc(N1), VT,
3643 return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), N0);
3659 return DAG.getNode(ISD::UDIV, DL, N1.getValueType(), N0, N1);
3666 SDValue Mul = DAG.getNode(ISD::MUL, DL, VT, V, N1);
3667 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0, Mul);
3718 SDValue Inexact = DAG.getNode(ISD::SUB, DL, ShiftAmtTy, Bits, C1);
3723 SDValue Sign = DAG.getNode(ISD::SRA, DL, VT, N0,
3728 SDValue Srl = DAG.getNode(ISD::SRL, DL, VT, Sign, Inexact);
3730 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0, Srl);
3732 SDValue Sra = DAG.getNode(ISD::SRA, DL, VT, Add, C1);
3741 SDValue IsOneOrAllOnes = DAG.getNode(ISD::OR, DL, CCVT, IsOne, IsAllOnes);
3747 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, Zero, Sra);
3804 SDValue Mul = DAG.getNode(ISD::MUL, DL, VT, V, N1);
3805 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0, Mul);
3837 return DAG.getNode(ISD::SRL, DL, VT, N0, Trunc);
3851 SDValue Add = DAG.getNode(ISD::ADD, DL, ADDVT, N1.getOperand(1), Trunc);
3853 return DAG.getNode(ISD::SRL, DL, VT, N0, Add);
3899 return DAG.getNode(ISD::UREM, DL, VT, N0, N1);
3904 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N1, NegOne);
3906 return DAG.getNode(ISD::AND, DL, VT, N0, Add);
3911 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N1, NegOne);
3913 return DAG.getNode(ISD::AND, DL, VT, N0, Add);
3935 SDValue Mul = DAG.getNode(ISD::MUL, DL, VT, OptimizedDiv, N1);
3936 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0, Mul);
3969 return DAG.getNode(ISD::SRA, DL, N0.getValueType(), N0,
3986 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
3987 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
4026 SDValue SRLAmt = DAG.getNode(
4030 return DAG.getNode(ISD::SRL, DL, VT, N0, Trunc);
4042 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
4043 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
4118 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
4120 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
4161 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
4163 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
4223 return DAG.getNode(N->getOpcode(), SDLoc(N), VT, N1, N0);
4241 return DAG.getNode(AltOpcode, SDLoc(N), VT, N0, N1);
4290 SDValue Logic = DAG.getNode(LogicOpcode, DL, XVT, X, Y);
4312 SDValue Logic = DAG.getNode(LogicOpcode, DL, XVT, X, Y);
4324 SDValue Logic = DAG.getNode(LogicOpcode, DL, XVT, X, Y);
4325 return DAG.getNode(HandOpcode, DL, VT, Logic, N0.getOperand(1));
4333 SDValue Logic = DAG.getNode(LogicOpcode, DL, XVT, X, Y);
4350 SDValue Logic = DAG.getNode(LogicOpcode, DL, XVT, X, Y);
4389 SDValue Logic = DAG.getNode(LogicOpcode, DL, VT,
4402 SDValue Logic = DAG.getNode(LogicOpcode, DL, VT, N0.getOperand(1),
4457 SDValue Or = DAG.getNode(ISD::OR, SDLoc(N0), OpVT, LL, RL);
4476 SDValue And = DAG.getNode(ISD::AND, SDLoc(N0), OpVT, LL, RL);
4490 SDValue Add = DAG.getNode(ISD::ADD, SDLoc(N0), OpVT, LL, One);
4502 SDValue XorL = DAG.getNode(ISD::XOR, SDLoc(N0), OpVT, LL, LR);
4503 SDValue XorR = DAG.getNode(ISD::XOR, SDLoc(N1), OpVT, RL, RR);
4504 SDValue Or = DAG.getNode(ISD::OR, DL, OpVT, XorL, XorR);
4527 SDValue Add = DAG.getNode(ISD::ADD, DL, OpVT, LL, OffsetC);
4529 SDValue And = DAG.getNode(ISD::AND, DL, OpVT, Add, MaskC);
4593 DAG.getNode(ISD::ADD, DL0, VT,
4646 SDValue Shift = DAG.getNode(ISD::SRL, SL, HalfVT, Trunc, ShiftK);
4647 SDValue And = DAG.getNode(ISD::AND, SL, HalfVT, Shift, NewMask);
4885 SDValue And = DAG.getNode(ISD::AND, SDLoc(FixupNode),
4901 SDValue And = DAG.getNode(ISD::AND, SDLoc(Op1), Op1.getValueType(),
4910 SDValue And = DAG.getNode(ISD::AND, SDLoc(Load), Load->getValueType(0),
4974 SDValue T0 = DAG.getNode(InnerShift, DL, VT, X, Y);
4976 SDValue T1 = DAG.getNode(OuterShift, DL, VT, T0, Y);
5028 SDValue NewAnd = DAG.getNode(ISD::AND, DL, VT, X, Mask);
5073 return DAG.getNode(ISD::AND, SDLoc(N), VT, N1, N0);
5430 Res = DAG.getNode(ISD::SRL, DL, VT, Res,
5594 return DAG.getNode(ISD::ROTL, DL, VT, BSwap, ShAmt);
5596 return DAG.getNode(ISD::ROTR, DL, VT, BSwap, ShAmt);
5597 return DAG.getNode(ISD::OR, DL, VT,
5598 DAG.getNode(ISD::SHL, DL, VT, BSwap, ShAmt),
5599 DAG.getNode(ISD::SRL, DL, VT, BSwap, ShAmt));
5632 SDValue X = DAG.getNode(ISD::OR, SDLoc(N0), VT,
5634 return DAG.getNode(ISD::AND, DL, VT, X,
5647 SDValue X = DAG.getNode(ISD::OR, SDLoc(N0), VT,
5649 return DAG.getNode(ISD::AND, DL, VT, N0.getOperand(0), X);
5662 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0.getOperand(0), N1);
5666 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0.getOperand(1), N1);
5772 return DAG.getNode(ISD::OR, SDLoc(N), VT, N1, N0);
5809 SDValue IOR = DAG.getNode(ISD::OR, SDLoc(N0), VT, N0.getOperand(0), N1);
5811 return DAG.getNode(ISD::AND, SDLoc(N), VT, COR, IOR);
5912 return DAG.getNode(ISD::SHL, DL, ShiftedVT, OppShiftLHS,
5992 return DAG.getNode(Opcode, DL, ResVT, OppShiftLHS, NewShiftNode);
6126 return DAG.getNode(HasPos ? PosOpcode : NegOpcode, DL, VT, Shifted,
6221 SDValue Rot = DAG.getNode(HasROTL ? ISD::ROTL : ISD::ROTR, DL, VT,
6230 SDValue RHSBits = DAG.getNode(ISD::SRL, DL, VT, AllOnes, RHSShiftAmt);
6231 Mask = DAG.getNode(ISD::AND, DL, VT, Mask,
6232 DAG.getNode(ISD::OR, DL, VT, LHSMask, RHSBits));
6235 SDValue LHSBits = DAG.getNode(ISD::SHL, DL, VT, AllOnes, LHSShiftAmt);
6236 Mask = DAG.getNode(ISD::AND, DL, VT, Mask,
6237 DAG.getNode(ISD::OR, DL, VT, RHSMask, LHSBits));
6240 Rot = DAG.getNode(ISD::AND, DL, VT, Rot, Mask);
6843 SDValue LHS = DAG.getNode(ISD::AND, DL, VT, NotX, M);
6845 SDValue RHS = DAG.getNode(ISD::OR, DL, VT, M, Y);
6846 return DAG.getNode(ISD::AND, DL, VT, NotLHS, RHS);
6849 SDValue LHS = DAG.getNode(ISD::AND, DL, VT, X, M);
6851 SDValue RHS = DAG.getNode(ISD::AND, DL, VT, Y, NotM);
6853 return DAG.getNode(ISD::OR, DL, VT, LHS, RHS);
6890 return DAG.getNode(ISD::XOR, DL, VT, N1, N0);
6927 V = DAG.getNode(ISD::XOR, DL0, V.getValueType(), V,
6939 N00 = DAG.getNode(ISD::XOR, SDLoc(N00), VT, N00, N1); // N00 = ~N00
6940 N01 = DAG.getNode(ISD::XOR, SDLoc(N01), VT, N01, N1); // N01 = ~N01
6942 return DAG.getNode(NewOpcode, DL, VT, N00, N01);
6951 N00 = DAG.getNode(ISD::XOR, SDLoc(N00), VT, N00, N1); // N00 = ~N00
6952 N01 = DAG.getNode(ISD::XOR, SDLoc(N01), VT, N01, N1); // N01 = ~N01
6954 return DAG.getNode(NewOpcode, DL, VT, N00, N01);
6963 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(1),
6972 return DAG.getNode(ISD::AND, DL, VT, NotX, N1);
6991 return DAG.getNode(N0Opcode, DL, VT, Not, N0.getOperand(1));
7037 return DAG.getNode(ISD::ROTL, DL, VT, DAG.getConstant(~1, DL, VT),
7118 SDValue NewShift1 = DAG.getNode(ShiftOpcode, DL, VT, X, ShiftSumC);
7119 SDValue NewShift2 = DAG.getNode(ShiftOpcode, DL, VT, Y, C1);
7120 return DAG.getNode(LogicOpcode, DL, VT, NewShift1, NewShift2);
7191 SDValue NewRHS = DAG.getNode(N->getOpcode(), DL, VT, LHS.getOperand(1),
7195 SDValue NewShift = DAG.getNode(N->getOpcode(), DL, VT, LHS.getOperand(0),
7197 return DAG.getNode(LHS.getOpcode(), DL, VT, NewShift, NewRHS);
7216 return DAG.getNode(ISD::AND, DL, TruncVT, Trunc00, Trunc01);
7246 return DAG.getNode(N->getOpcode(), dl, VT, N0,
7255 return DAG.getNode(N->getOpcode(), dl, VT, N0, NewOp1);
7273 return DAG.getNode(N->getOpcode(), dl, VT, N0->getOperand(0),
7310 return DAG.getNode(ISD::AND, SDLoc(N), VT, N00, C);
7336 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0, NewOp1);
7364 SDValue Sum = DAG.getNode(ISD::ADD, DL, ShiftVT, N1, N0.getOperand(1));
7365 return DAG.getNode(ISD::SHL, DL, VT, N0.getOperand(0), Sum);
7410 Sum = DAG.getNode(ISD::ADD, DL, ShiftVT, Sum, N1);
7411 return DAG.getNode(ISD::SHL, DL, VT, Ext, Sum);
7435 NewSHL = DAG.getNode(ISD::SHL, DL, N0Op0.getValueType(), N0Op0, NewSHL);
7451 return DAG.getNode(ISD::SHL, DL, VT, N0.getOperand(0),
7453 return DAG.getNode(N0.getOpcode(), DL, VT, N0.getOperand(0),
7475 Shift = DAG.getNode(ISD::SHL, DL, VT, N0.getOperand(0),
7480 Shift = DAG.getNode(ISD::SRL, DL, VT, N0.getOperand(0),
7484 return DAG.getNode(ISD::AND, DL, VT, Shift,
7495 SDValue HiBitsMask = DAG.getNode(ISD::SHL, DL, VT, AllBits, N1);
7496 return DAG.getNode(ISD::AND, DL, VT, N0.getOperand(0), HiBitsMask);
7508 SDValue Shl0 = DAG.getNode(ISD::SHL, SDLoc(N0), VT, N0.getOperand(0), N1);
7509 SDValue Shl1 = DAG.getNode(ISD::SHL, SDLoc(N1), VT, N0.getOperand(1), N1);
7512 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, Shl0, Shl1);
7519 SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(N1), VT, N0.getOperand(1), N1);
7521 return DAG.getNode(ISD::MUL, SDLoc(N), VT, N0.getOperand(0), Shl);
7572 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
7600 return DAG.getNode(ISD::SRA, DL, VT, N0.getOperand(0), ShiftValue);
7634 SDValue Shift = DAG.getNode(ISD::SRL, DL, VT,
7669 SDValue Add = DAG.getNode(ISD::ADD, DL, TruncVT, Trunc, ShiftC);
7679 return DAG.getNode(ISD::SRA, SDLoc(N), VT, N0, NewOp1);
7700 DAG.getNode(ISD::SRA, DL, LargeVT, N0Op0.getOperand(0), Amt);
7713 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, N1);
7774 SDValue Sum = DAG.getNode(ISD::ADD, DL, ShiftVT, N1, N0.getOperand(1));
7775 return DAG.getNode(ISD::SRL, DL, VT, N0.getOperand(0), Sum);
7795 DAG.getNode(ISD::SRL, DL, InnerShiftVT,
7809 DAG.getNode(ISD::SRL, DL, VT, DAG.getAllOnesConstant(DL, VT), N1);
7811 return DAG.getNode(ISD::AND, DL, VT, N0.getOperand(0), Mask);
7826 SDValue SmallShift = DAG.getNode(ISD::SRL, DL0, SmallVT,
7833 return DAG.getNode(ISD::AND, DL, VT,
7843 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0), N1);
7871 Op = DAG.getNode(ISD::SRL, DL, VT, Op,
7878 return DAG.getNode(ISD::XOR, DL, VT,
7887 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, NewOp1);
7975 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N1,
7979 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0,
7991 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N1, N2);
7993 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0, N2);
8002 return DAG.getNode(RotOpc, SDLoc(N), VT, N0, N2);
8151 return DAG.getNode(IEEEOpcode, DL, VT, LHS, RHS);
8155 return DAG.getNode(Opcode, DL, VT, LHS, RHS);
8166 return DAG.getNode(IEEEOpcode, DL, VT, LHS, RHS);
8170 return DAG.getNode(Opcode, DL, VT, LHS, RHS);
8202 SDValue Sra = DAG.getNode(ISD::SRA, DL, VT, X, ShAmtC);
8203 return DAG.getNode(ISD::OR, DL, VT, Sra, C1);
8209 SDValue Sra = DAG.getNode(ISD::SRA, DL, VT, X, ShAmtC);
8210 return DAG.getNode(ISD::AND, DL, VT, Sra, C1);
8274 return DAG.getNode(ISD::ADD, DL, VT, Cond, N2);
8280 return DAG.getNode(ISD::ADD, DL, VT, Cond, N2);
8288 return DAG.getNode(ISD::SHL, DL, VT, Cond, ShAmtC);
8314 DAG.getNode(ISD::XOR, DL, CondVT, Cond, DAG.getConstant(1, DL, CondVT));
8338 return DAG.getNode(ISD::OR, DL, VT, N0, N2);
8347 return DAG.getNode(ISD::AND, DL, VT, NOTNode, N2);
8353 return DAG.getNode(ISD::OR, DL, VT, NOTNode, N1);
8358 return DAG.getNode(ISD::AND, DL, VT, N0, N1);
8411 SDValue And = DAG.getNode(ISD::AND, DL, N0.getValueType(), N0, N1_0);
8430 SDValue Or = DAG.getNode(ISD::OR, DL, N0.getValueType(), N0, N2_0);
8559 return DAG.getNode(
8656 return DAG.getNode(ISD::ADD, DL, VT, ExtendedCond, N2);
8665 return DAG.getNode(ISD::SHL, DL, VT, ZextCond, ShAmtC);
8715 SDValue Shift = DAG.getNode(ISD::SRA, DL, VT, LHS,
8718 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, LHS, Shift);
8721 return DAG.getNode(ISD::XOR, DL, VT, Add, Shift);
9130 BasePtr = DAG.getNode(ISD::ADD, DL, BasePtr.getValueType(), BasePtr,
9207 SDValue Shift = DAG.getNode(N1.getOpcode(), DL1, VT, ExtLoad,
9213 SDValue And = DAG.getNode(N0.getOpcode(), DL0, VT, Shift,
9268 CastA = DAG.getNode(CastOpcode, DL, VT, A, Cast->getOperand(1));
9269 CastB = DAG.getNode(CastOpcode, DL, VT, B, Cast->getOperand(1));
9405 return DAG.getNode(ShiftOpcode, DL, VT, NotX, ShiftAmount);
9468 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT, Op,
9515 SDValue And = DAG.getNode(N0.getOpcode(), DL, VT,
9628 return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Zext);
9637 return DAG.getNode(ISD::ADD, DL, VT, Zext, DAG.getAllOnesConstant(DL, VT));
9785 return DAG.getNode(ISD::AND, DL, VT,
9840 SDValue And = DAG.getNode(N0.getOpcode(), DL, VT,
9896 return DAG.getNode(ISD::AND, DL, VT, VSetCC, VecOnes);
9906 return DAG.getNode(ISD::AND, DL, VT, DAG.getSExtOrTrunc(VsetCC, DL, VT),
9941 return DAG.getNode(N0.getOpcode(), DL, VT,
10000 return DAG.getNode(ISD::AND, DL, VT,
10131 SDValue NewAssert = DAG.getNode(Opcode, DL, BigA.getValueType(),
10150 SDValue NewAssert = DAG.getNode(Opcode, DL, BigA.getValueType(),
10314 SDValue NewPtr = DAG.getNode(ISD::ADD, DL,
10348 Result = DAG.getNode(ISD::SHL, DL, VT,
10363 Result = DAG.getNode(ISD::SHL, DL, VT, Result, ShiftC);
10384 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, N0, N1);
10393 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
10426 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N00, N1);
10453 return DAG.getNode(ISD::SRA, SDLoc(N), VT, N0.getOperand(0),
10498 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
10606 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, TrTy,
10640 return DAG.getNode(ISD::SHL, SL, VT, Trunc, Amt);
10777 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, VT, VecSrc,
10813 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N0->getOperand(0)), VT,
10842 return DAG.getNode(N0.getOpcode(), DL, VT, NarrowL, NarrowR);
11052 DAG.getNode(ISD::EXTRACT_ELEMENT, SDLoc(NewConv), MVT::i64, NewConv,
11056 FlipBit = DAG.getNode(ISD::AND, SDLoc(N0), MVT::i64, Hi, SignBit);
11060 DAG.getNode(ISD::BUILD_PAIR, SDLoc(N0), VT, FlipBit, FlipBit);
11062 return DAG.getNode(ISD::XOR, DL, VT, NewConv, FlipBits);
11066 return DAG.getNode(ISD::XOR, DL, VT,
11069 return DAG.getNode(ISD::AND, DL, VT,
11102 X = DAG.getNode(ISD::SRL, DL,
11117 SDValue XorResult = DAG.getNode(ISD::XOR, SDLoc(N0), VT, Cst, X);
11119 SDValue XorResult64 = DAG.getNode(
11125 DAG.getNode(ISD::AND, SDLoc(XorResult64), MVT::i64, XorResult64,
11129 DAG.getNode(ISD::BUILD_PAIR, SDLoc(N0), VT, FlipBit, FlipBit);
11131 return DAG.getNode(ISD::XOR, SDLoc(N), VT, Cst, FlipBits);
11134 X = DAG.getNode(ISD::AND, SDLoc(X), VT,
11139 Cst = DAG.getNode(ISD::AND, SDLoc(Cst), VT,
11143 return DAG.getNode(ISD::OR, SDLoc(N), VT, X, Cst);
11936 return DAG.getNode(ISD::FADD, DL, VT, N0, N1, Flags);
11940 return DAG.getNode(ISD::FADD, DL, VT, N1, N0, Flags);
11954 return DAG.getNode(
11961 return DAG.getNode(
11975 SDValue Add = DAG.getNode(ISD::FADD, DL, VT, B, B, Flags);
11976 return DAG.getNode(ISD::FSUB, DL, VT, N1, Add, Flags);
11981 SDValue Add = DAG.getNode(ISD::FADD, DL, VT, B, B, Flags);
11982 return DAG.getNode(ISD::FSUB, DL, VT, N0, Add, Flags);
12009 SDValue NewC = DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(1), N1, Flags);
12010 return DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(0), NewC, Flags);
12023 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(1),
12025 return DAG.getNode(ISD::FMUL, DL, VT, N1, NewCFP, Flags);
12032 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(1),
12034 return DAG.getNode(ISD::FMUL, DL, VT, N0.getOperand(0), NewCFP, Flags);
12044 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N1.getOperand(1),
12046 return DAG.getNode(ISD::FMUL, DL, VT, N0, NewCFP, Flags);
12053 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N1.getOperand(1),
12055 return DAG.getNode(ISD::FMUL, DL, VT, N1.getOperand(0), NewCFP, Flags);
12064 return DAG.getNode(ISD::FMUL, DL, VT,
12074 return DAG.getNode(ISD::FMUL, DL, VT,
12084 return DAG.getNode(ISD::FMUL, DL, VT, N0.getOperand(0),
12115 return DAG.getNode(ISD::FSUB, DL, VT, N0, N1, Flags);
12162 return DAG.getNode(
12209 return DAG.getNode(ISD::FMUL, DL, VT, N0, N1, Flags);
12214 return DAG.getNode(ISD::FMUL, DL, VT, N1, N0, Flags);
12236 SDValue MulConsts = DAG.getNode(ISD::FMUL, DL, VT, N01, N1, Flags);
12237 return DAG.getNode(ISD::FMUL, DL, VT, N00, MulConsts, Flags);
12246 SDValue MulConsts = DAG.getNode(ISD::FMUL, DL, VT, Two, N1, Flags);
12247 return DAG.getNode(ISD::FMUL, DL, VT, N0.getOperand(0), MulConsts, Flags);
12253 return DAG.getNode(ISD::FADD, DL, VT, N0, N0, Flags);
12266 return DAG.getNode(ISD::FMUL, DL, VT, NegN0, NegN1, Flags);
12362 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N1, N2);
12364 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N2);
12376 return DAG.getNode(ISD::FMUL, DL, VT, N0,
12377 DAG.getNode(ISD::FADD, DL, VT, N1, N2.getOperand(1),
12387 DAG.getNode(ISD::FMUL, DL, VT, N1, N0.getOperand(1),
12398 return DAG.getNode(ISD::FADD, DL, VT, N0, N2);
12405 return DAG.getNode(ISD::FADD, DL, VT, N2, RHSNeg);
12421 return DAG.getNode(ISD::FMUL, DL, VT, N0,
12422 DAG.getNode(ISD::FADD, DL, VT, N1,
12429 return DAG.getNode(ISD::FMUL, DL, VT, N0,
12430 DAG.getNode(ISD::FADD, DL, VT, N1,
12495 SDValue Reciprocal = DAG.getNode(ISD::FDIV, DL, VT, FPOne, N1, Flags);
12501 SDValue NewNode = DAG.getNode(ISD::FMUL, SDLoc(U), VT, Dividend,
12530 return DAG.getNode(ISD::FDIV, SDLoc(N), VT, N0, N1, Flags);
12554 return DAG.getNode(ISD::FMUL, DL, VT, N0,
12562 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV, Flags);
12569 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV, Flags);
12575 RV = DAG.getNode(ISD::FP_ROUND, SDLoc(N1), VT, RV, N1.getOperand(1));
12577 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV, Flags);
12595 RV = DAG.getNode(ISD::FDIV, SDLoc(N1), VT, RV, OtherOp, Flags);
12597 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV, Flags);
12609 return DAG.getNode(
12626 return DAG.getNode(ISD::FREM, SDLoc(N), VT, N0, N1, N->getFlags());
12673 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT, N0, N1);
12694 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT, N0.getOperand(0), N1);
12702 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT, N0, N1.getOperand(1));
12707 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT, N0, N1.getOperand(0));
12782 return DAG.getNode(ISD::FMUL, DL, VT, Sqrt, SqrtSqrt, Flags);
13010 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT, N0, N1);
13038 return DAG.getNode(ISD::FP_ROUND, DL, VT, N0.getOperand(0),
13045 SDValue Tmp = DAG.getNode(ISD::FP_ROUND, SDLoc(N0), VT,
13048 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
13083 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT,
13098 DAG.getNode(ISD::FP_ROUND, SDLoc(N0),
13188 Int = DAG.getNode(ISD::XOR, DL0, IntVT, Int,
13205 return DAG.getNode(
13232 return DAG.getNode(N->getOpcode(), SDLoc(N), VT, N1, N0);
13286 Int = DAG.getNode(ISD::AND, DL, IntVT, Int,
13713 SDValue NewUse = DAG.getNode(Opcode,
13874 return DAG.getNode(Opc, SDLoc(LD), BP.getSimpleValueType(), BP, Inc);
13970 SDValue Idx = DAG.getNode(Opc, SDLoc(LD), LD->getOperand(1).getValueType(),
13994 auto Val = DAG.getNode(ISD::AND, SDLoc(LD), LDType, ST->getValue(), Mask);
14134 SDValue Token = DAG.getNode(ISD::TokenFactor, SDLoc(N),
14392 BaseAddr = DAG->getNode(ISD::ADD, DL, ArithType, BaseAddr,
14803 IVal = DAG.getNode(ISD::SRL, DL, IVal.getValueType(), IVal,
14820 Ptr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(),
14932 SDValue NewPtr = DAG.getNode(ISD::ADD, SDLoc(LD),
14940 SDValue NewVal = DAG.getNode(Opc, SDLoc(Value), NewVT, NewLD,
15181 Val = DAG.getNode(OpC, SDLoc(Val), MemVT, Vec, Idx);
16034 SDValue Token = DAG.getNode(ISD::TokenFactor, SL,
16109 Ptr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
16115 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
16486 DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
16706 Offset = DAG.getNode(
16713 NewPtr = DAG.getNode(ISD::ADD, DL, PtrType, NewPtr, Offset);
16786 SDValue Ext0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Op0, Index);
16787 SDValue Ext1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Op1, Index);
16788 return DAG.getNode(Vec.getOpcode(), DL, VT, Ext0, Ext1);
16929 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ScalarVT, SVInVec,
17204 VecIn2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, VecIn1,
17206 VecIn1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, VecIn1, ZeroIdx);
17277 Shuffle = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Shuffle, ZeroIdx);
17464 SDValue VecIn2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SplitVT, Vec,
17466 SDValue VecIn1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SplitVT, Vec,
17618 In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, InVT, In,
17689 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N), N->getValueType(0),
18064 return DAG.getNode(BinOpcode, SDLoc(Extract), SubVT, Sub0, Sub1,
18131 SDValue X = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NarrowBVT,
18133 SDValue Y = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NarrowBVT,
18135 SDValue NarrowBinOp = DAG.getNode(BOpcode, DL, NarrowBVT, X, Y,
18172 : DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NarrowBVT,
18176 : DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NarrowBVT,
18179 SDValue NarrowBinOp = DAG.getNode(BOpcode, DL, NarrowBVT, X, Y);
18242 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N), NVT, V.getOperand(0),
18264 SDValue NewExtract = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NewExtVT,
18345 return DAG.getNode(
18405 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Shuf0, Shuf1);
18436 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, N0, N1);
18909 SDValue ExtL = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, L, Index);
18910 SDValue ExtR = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, R, Index);
18911 SDValue NewBO = DAG.getNode(N0.getOpcode(), DL, EltVT, ExtL, ExtR,
19231 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N), SubVT,
19419 SDValue Res = DAG.getNode(
19558 SDValue X = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, N0, IndexC);
19559 SDValue Y = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, N1, IndexC);
19560 SDValue ScalarBO = DAG.getNode(Opcode, DL, EltVT, X, Y, N->getFlags());
19611 SDValue NewBinOp = DAG.getNode(Opcode, DL, VT, LHS.getOperand(0),
19635 DAG.getNode(Opcode, DL, VT, DAG.getUNDEF(VT), DAG.getUNDEF(VT));
19636 SDValue NarrowBO = DAG.getNode(Opcode, DL, NarrowVT, X, Y);
19666 ConcatOps.push_back(DAG.getNode(Opcode, DL, NarrowVT, LHS.getOperand(i),
19941 SDValue Shift = DAG.getNode(ISD::SRL, DL, XType, N0, ShiftAmt);
19952 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
19956 SDValue Shift = DAG.getNode(ISD::SRA, DL, XType, N0, ShiftAmt);
19967 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
20020 CPIdx = DAG.getNode(ISD::ADD, DL, CPIdx.getValueType(), CPIdx, CstOffset);
20080 SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(N0), VT, AndLHS, ShlAmt);
20087 SDValue Shr = DAG.getNode(ISD::SRA, SDLoc(N0), VT, Shl, ShrAmt);
20089 return DAG.getNode(ISD::AND, DL, VT, Shr, N3);
20132 return DAG.getNode(ISD::SHL, DL, N2.getValueType(), Temp,
20253 SDValue LogBase2 = DAG.getNode(ISD::SUB, DL, VT, Base, Ctlz);
20297 MulEst = DAG.getNode(ISD::FMUL, DL, VT, N, Est, Flags);
20301 SDValue NewEst = DAG.getNode(ISD::FMUL, DL, VT, Op, MulEst, Flags);
20304 NewEst = DAG.getNode(ISD::FSUB, DL, VT,
20308 NewEst = DAG.getNode(ISD::FMUL, DL, VT, Est, NewEst, Flags);
20311 Est = DAG.getNode(ISD::FADD, DL, VT, MulEst, NewEst, Flags);
20316 Est = DAG.getNode(ISD::FMUL, DL, VT, Est, N, Flags);
20341 SDValue HalfArg = DAG.getNode(ISD::FMUL, DL, VT, ThreeHalves, Arg, Flags);
20342 HalfArg = DAG.getNode(ISD::FSUB, DL, VT, HalfArg, Arg, Flags);
20346 SDValue NewEst = DAG.getNode(ISD::FMUL, DL, VT, Est, Est, Flags);
20347 NewEst = DAG.getNode(ISD::FMUL, DL, VT, HalfArg, NewEst, Flags);
20348 NewEst = DAG.getNode(ISD::FSUB, DL, VT, ThreeHalves, NewEst, Flags);
20349 Est = DAG.getNode(ISD::FMUL, DL, VT, Est, NewEst, Flags);
20354 Est = DAG.getNode(ISD::FMUL, DL, VT, Est, Arg, Flags);
20379 SDValue AE = DAG.getNode(ISD::FMUL, DL, VT, Arg, Est, Flags);
20380 SDValue AEE = DAG.getNode(ISD::FMUL, DL, VT, AE, Est, Flags);
20381 SDValue RHS = DAG.getNode(ISD::FADD, DL, VT, AEE, MinusThree, Flags);
20389 LHS = DAG.getNode(ISD::FMUL, DL, VT, Est, MinusHalf, Flags);
20392 LHS = DAG.getNode(ISD::FMUL, DL, VT, AE, MinusHalf, Flags);
20395 Est = DAG.getNode(ISD::FMUL, DL, VT, LHS, RHS, Flags);
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp 469 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
475 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
580 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
583 Hi = DAG.getNode(
595 Hi = DAG.getNode(
604 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
614 SDValue Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
759 Result = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl,
764 Result = DAG.getNode(ISD::AssertZext, dl,
796 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
806 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
810 Hi = DAG.getNode(
816 Value = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi);
827 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
837 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
841 Hi = DAG.getNode(
847 Value = DAG.getNode(ISD::OR, dl, Node->getValueType(0), Lo, Hi);
936 ValRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl,
1411 Idx = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr, Idx);
1474 IntPtr = DAG.getNode(ISD::ADD, DL, StackPtr.getValueType(), StackPtr,
1513 SDValue SignBit = DAG.getNode(ISD::AND, DL, IntVT, SignAsInt.IntValue,
1532 SDValue ClearedSign = DAG.getNode(ISD::AND, DL, MagVT, MagAsInt.IntValue,
1544 SignBit = DAG.getNode(ISD::SRL, DL, ShiftVT, SignBit, ShiftCnst);
1547 SignBit = DAG.getNode(ISD::SHL, DL, ShiftVT, SignBit, ShiftCnst);
1554 SDValue CopiedSign = DAG.getNode(ISD::OR, DL, MagVT, ClearedSign, SignBit);
1566 return DAG.getNode(ISD::FCOPYSIGN, DL, FloatVT, Value, Zero);
1574 SDValue ClearedSign = DAG.getNode(ISD::AND, DL, IntVT, ValueAsInt.IntValue,
1601 Tmp1 = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
1603 Tmp1 = DAG.getNode(ISD::AND, dl, VT, Tmp1,
1725 LHS = DAG.getNode(Opc, dl, VT, SetCC1, SetCC2);
2366 SDValue Lo = DAG.getNode(ISD::ADD, dl, StackSlot.getValueType(),
2376 Op0Mapped = DAG.getNode(ISD::XOR, dl, MVT::i32, Op0, SignBit);
2397 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Load, Bias);
2433 CPIdx = DAG.getNode(ISD::ADD, dl, CPIdx.getValueType(), CPIdx, CstOffset);
2451 return DAG.getNode(ISD::FADD, dl, DestVT, Tmp1, FudgeInReg);
2561 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp, DAG.getConstant(MaskHi4, dl, VT));
2562 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp, DAG.getConstant(MaskLo4, dl, VT));
2563 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Tmp2, DAG.getConstant(4, dl, SHVT));
2564 Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Tmp3, DAG.getConstant(4, dl, SHVT));
2565 Tmp = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
2568 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp, DAG.getConstant(MaskHi2, dl, VT));
2569 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp, DAG.getConstant(MaskLo2, dl, VT));
2570 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Tmp2, DAG.getConstant(2, dl, SHVT));
2571 Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Tmp3, DAG.getConstant(2, dl, SHVT));
2572 Tmp = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
2575 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp, DAG.getConstant(MaskHi1, dl, VT));
2576 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp, DAG.getConstant(MaskLo1, dl, VT));
2577 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Tmp2, DAG.getConstant(1, dl, SHVT));
2578 Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Tmp3, DAG.getConstant(1, dl, SHVT));
2579 Tmp = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
2587 DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(J - I, dl, SHVT));
2590 DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(I - J, dl, SHVT));
2594 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(Shift, dl, VT));
2595 Tmp = DAG.getNode(ISD::OR, dl, VT, Tmp, Tmp2);
2610 return DAG.getNode(ISD::ROTL, dl, VT, Op, DAG.getConstant(8, dl, SHVT));
2612 Tmp4 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, dl, SHVT));
2613 Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, dl, SHVT));
2614 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, dl, SHVT));
2615 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, dl, SHVT));
2616 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3,
2618 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(0xFF00, dl, VT));
2619 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3);
2620 Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1);
2621 return DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2);
2623 Tmp8 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(56, dl, SHVT));
2624 Tmp7 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(40, dl, SHVT));
2625 Tmp6 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, dl, SHVT));
2626 Tmp5 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, dl, SHVT));
2627 Tmp4 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, dl, SHVT));
2628 Tmp3 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, dl, SHVT));
2629 Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(40, dl, SHVT));
2630 Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(56, dl, SHVT));
2631 Tmp7 = DAG.getNode(ISD::AND, dl, VT, Tmp7,
2633 Tmp6 = DAG.getNode(ISD::AND, dl, VT, Tmp6,
2635 Tmp5 = DAG.getNode(ISD::AND, dl, VT, Tmp5,
2637 Tmp4 = DAG.getNode(ISD::AND, dl, VT, Tmp4,
2639 Tmp3 = DAG.getNode(ISD::AND, dl, VT, Tmp3,
2641 Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2,
2643 Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp7);
2644 Tmp6 = DAG.getNode(ISD::OR, dl, VT, Tmp6, Tmp5);
2645 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp3);
2646 Tmp2 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp1);
2647 Tmp8 = DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp6);
2648 Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp2);
2649 return DAG.getNode(ISD::OR, dl, VT, Tmp8, Tmp4);
2692 SDValue Offset = DAG.getNode(ISD::ADD, dl,
2700 Results.push_back(DAG.getNode(ISD::ADD, dl, FA.getValueType(),
2769 LHS = DAG.getNode(ISD::AssertSext, dl, OuterType, Res,
2771 RHS = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, OuterType,
2776 LHS = DAG.getNode(ISD::AssertZext, dl, OuterType, Res,
2866 SDValue And = DAG.getNode(ISD::AND, dl, VT, Node->getOperand(0), One);
2868 SDValue Neg = DAG.getNode(ISD::SUB, dl, VT, Zero, And);
2879 Tmp1 = DAG.getNode(ISD::SHL, dl, Node->getValueType(0),
2881 Tmp1 = DAG.getNode(ISD::SRA, dl, Node->getValueType(0), Tmp1, ShiftCst);
3014 Ops.push_back(DAG.getNode(
3018 Ops.push_back(DAG.getNode(
3034 Tmp1 = DAG.getNode(ISD::SRL, dl, OpTy, Node->getOperand(0),
3081 Tmp1 = DAG.getNode(ISD::FSUB, dl, Node->getValueType(0), Tmp1,
3152 SDValue FloatVal = DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, Op,
3179 Tmp1 = DAG.getNode(ISD::FADD, dl, VT, Node->getOperand(0), Tmp1, Flags);
3189 Tmp1 = DAG.getNode(ISD::XOR, dl, VT, Node->getOperand(1),
3192 Tmp1 = DAG.getNode(ISD::ADD, dl, VT, Tmp1, DAG.getConstant(1, dl, VT));
3193 Results.push_back(DAG.getNode(ISD::ADD, dl, VT, Node->getOperand(0), Tmp1));
3210 Tmp1 = DAG.getNode(DivOpc, dl, VT, Tmp2, Tmp3);
3211 Tmp1 = DAG.getNode(ISD::MUL, dl, VT, Tmp1, Tmp3);
3212 Tmp1 = DAG.getNode(ISD::SUB, dl, VT, Tmp2, Tmp1);
3251 Results.push_back(DAG.getNode(ISD::MUL, dl, VT, LHS, RHS));
3252 Results.push_back(DAG.getNode(MULHOpcode, dl, VT, LHS, RHS));
3268 Hi = DAG.getNode(ISD::SHL, dl, VT, Hi, Shift);
3269 Results.push_back(DAG.getNode(ISD::OR, dl, VT, Lo, Hi));
3316 Hi = DAG.getNode(ISD::SHL, dl, VT, Hi, Shift);
3317 Results.push_back(DAG.getNode(ISD::OR, dl, VT, Lo, Hi));
3354 SDValue Sum = DAG.getNode(Op, dl, VT, LHS, RHS);
3365 SDValue Sum2 = DAG.getNode(Op, dl, VT, Sum, CarryExt);
3375 Overflow2 = DAG.getNode(ISD::AND, dl, SetCCType, Overflow2,
3379 DAG.getNode(ISD::OR, dl, SetCCType, Overflow, Overflow2);
3414 Tmp2 = DAG.getNode(
3418 Results.push_back(DAG.getNode(ISD::OR, dl, PairTy, Tmp1, Tmp2));
3453 Index = DAG.getNode(
3457 Index = DAG.getNode(ISD::MUL, dl, Index.getValueType(), Index,
3459 SDValue Addr = DAG.getNode(ISD::ADD, dl, Index.getValueType(),
3471 Addr = DAG.getNode(ISD::ADD, dl, PTy, Addr,
3497 Tmp3 = DAG.getNode(ISD::AND, dl, Tmp2.getValueType(), Tmp2,
3669 SDValue Ex = DAG.getNode(
3672 SDValue Sh = DAG.getNode(
3675 Scalars.push_back(DAG.getNode(Node->getOpcode(), dl,
4151 Tmp1 = DAG.getNode(ISD::OR, dl, NVT, Tmp1,
4160 Tmp1 = DAG.getNode(ISD::SUB, dl, NVT, Tmp1,
4171 Tmp1 = DAG.getNode(
4256 Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2);
4267 Tmp1 = DAG.getNode(ISD::MUL, dl, NVT, Tmp1, Tmp2);
4271 Tmp2 = DAG.getNode(
4301 Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1,
4356 Tmp3 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2,
4358 Results.push_back(DAG.getNode(ISD::FP_ROUND, dl, OVT,
4366 DAG.getNode(ISD::FP_ROUND, dl, OVT,
4374 Tmp3 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1, Tmp2);
4382 Results.push_back(DAG.getNode(ISD::FP_ROUND, dl, OVT,
4404 Results.push_back(DAG.getNode(ISD::FP_ROUND, dl, OVT,
4461 SDValue NewBaseIdx = DAG.getNode(ISD::MUL, SL, IdxVT, Idx, Factor);
4468 SDValue TmpIdx = DAG.getNode(ISD::ADD, SL, IdxVT, NewBaseIdx, IdxOffset);
4470 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, NewEltVT,
4509 SDValue NewBaseIdx = DAG.getNode(ISD::MUL, SL, IdxVT, Idx, Factor);
4517 SDValue InEltIdx = DAG.getNode(ISD::ADD, SL, IdxVT, NewBaseIdx, IdxOffset);
4519 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, NewEltVT,
lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp 127 return DAG.getNode(ISD::BUILD_PAIR, SDLoc(N),
160 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
174 return DAG.getNode(ISD::AND, SDLoc(N), NVT, Op, Mask);
270 SDValue SignBit = DAG.getNode(
274 SignBit = DAG.getNode(ISD::AND, dl, RVT, RHS, SignBit);
280 DAG.getNode(ISD::SRL, dl, RVT, SignBit,
288 DAG.getNode(ISD::SHL, dl, LVT, SignBit,
295 SDValue Mask = DAG.getNode(
299 Mask = DAG.getNode(ISD::SUB, dl, LVT, Mask, DAG.getConstant(1, dl, LVT));
300 LHS = DAG.getNode(ISD::AND, dl, LVT, LHS, Mask);
303 return DAG.getNode(ISD::OR, dl, LVT, LHS, SignBit);
487 return DAG.getNode(ISD::XOR, dl, NVT, GetSoftenedFloat(N->getOperand(0)),
1026 Val = BitConvertToInteger(DAG.getNode(ISD::FP_ROUND, dl, ST->getMemoryVT(),
1584 Hi = DAG.getNode(ISD::BUILD_PAIR, dl, VT, Lo, Hi);
1608 Lo = DAG.getNode(ISD::FADD, dl, VT, Hi,
1698 Tmp3 = DAG.getNode(ISD::AND, dl, Tmp1.getValueType(), Tmp1, Tmp2);
1703 Tmp1 = DAG.getNode(ISD::AND, dl, Tmp1.getValueType(), Tmp1, Tmp2);
1704 NewLHS = DAG.getNode(ISD::OR, dl, Tmp1.getValueType(), Tmp1, Tmp3);
1733 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N),
1743 return DAG.getNode(ISD::FP_ROUND, SDLoc(N),
1954 return DAG.getNode(N->getOpcode(), SDLoc(N), N->getValueType(0),
2164 SDValue Res = DAG.getNode(N->getOpcode(), DL, EltVT, Vec, Idx);
2175 Res = DAG.getNode(N->getOpcode(), DL, EltVT, Lo, Idx);
2177 Res = DAG.getNode(N->getOpcode(), DL, EltVT, Hi,
2192 SDValue NewVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, IVT,
2211 return DAG.getNode(N->getOpcode(), SDLoc(N), NVT, Op0, Op1);
2233 return DAG.getNode(N->getOpcode(), SDLoc(N), NVT, Op0, Op1, N->getFlags());
2253 return DAG.getNode(N->getOpcode(), SDLoc(N), NVT, Op0, Op1);
2324 DAG.getNode(ISD::FP_ROUND, DL, VT, NV, DAG.getIntPtrConstant(0, DL)));
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp 212 return DAG.getNode(ISD::AssertSext, SDLoc(N),
219 return DAG.getNode(ISD::AssertZext, SDLoc(N),
356 InOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OutVT, InOp,
389 return DAG.getNode(ISD::SRL, dl, NVT, DAG.getNode(ISD::BSWAP, dl, NVT, Op),
401 return DAG.getNode(ISD::SRL, dl, NVT,
437 return DAG.getNode(
460 Op = DAG.getNode(ISD::OR, dl, NVT, Op, DAG.getConstant(TopBit, dl, NVT));
482 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT, In, Op1);
487 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NVT, Op0, Op1);
526 return DAG.getNode((N->getOpcode() == ISD::FP_TO_UINT ||
560 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
692 DAG.getNode(ISD::SHL, dl, PromotedType, Op1Promoted, ShiftAmount);
694 DAG.getNode(ISD::SHL, dl, PromotedType, Op2Promoted, ShiftAmount);
697 DAG.getNode(Opcode, dl, PromotedType, Op1Promoted, Op2Promoted);
698 return DAG.getNode(ShiftOp, dl, PromotedType, Result, ShiftAmount);
702 DAG.getNode(ISD::UMAX, dl, PromotedType, Op1Promoted, Op2Promoted);
703 return DAG.getNode(ISD::SUB, dl, PromotedType, Max, Op2Promoted);
710 DAG.getNode(ISD::ADD, dl, PromotedType, Op1Promoted, Op2Promoted);
711 return DAG.getNode(ISD::UMIN, dl, PromotedType, Add, SatMax);
720 DAG.getNode(AddOp, dl, PromotedType, Op1Promoted, Op2Promoted);
721 Result = DAG.getNode(ISD::SMIN, dl, PromotedType, Result, SatMax);
722 Result = DAG.getNode(ISD::SMAX, dl, PromotedType, Result, SatMin);
753 Op1Promoted = DAG.getNode(ISD::SHL, dl, PromotedType, Op1Promoted,
758 return DAG.getNode(ShiftOp, dl, PromotedType, Result,
779 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
783 SDValue Ofl = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
854 return DAG.getNode(ISD::SHL, SDLoc(N), LHS.getValueType(), LHS, RHS);
859 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N),
869 return DAG.getNode(N->getOpcode(), SDLoc(N),
877 return DAG.getNode(N->getOpcode(), SDLoc(N),
885 return DAG.getNode(N->getOpcode(), SDLoc(N),
895 return DAG.getNode(ISD::SRA, SDLoc(N), LHS.getValueType(), LHS, RHS);
904 return DAG.getNode(ISD::SRL, SDLoc(N), LHS.getValueType(), LHS, RHS);
939 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, EOp1, EOp2);
958 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NVT, WideExt, ZeroIdx);
980 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
1062 SDValue Hi = DAG.getNode(ISD::SRL, DL, Mul.getValueType(), Mul,
1069 SDValue SExt = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, Mul.getValueType(),
1076 Overflow = DAG.getNode(ISD::OR, DL, N->getValueType(1), Overflow,
1116 Part = DAG.getNode(ISD::SHL, dl, NVT, Part,
1119 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
1341 Hi = DAG.getNode(ISD::SHL, dl, N->getValueType(0), Hi,
1344 return DAG.getNode(ISD::OR, dl, N->getValueType(0), Lo, Hi);
1458 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(),
1849 Hi = DAG.getNode(ISD::SHL, DL,
1855 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, DL, ShTy));
1856 Hi = DAG.getNode(ISD::OR, DL, NVT,
1857 DAG.getNode(ISD::SHL, DL, NVT, InH,
1859 DAG.getNode(ISD::SRL, DL, NVT, InL,
1869 Lo = DAG.getNode(ISD::SRL, DL,
1876 Lo = DAG.getNode(ISD::OR, DL, NVT,
1877 DAG.getNode(ISD::SRL, DL, NVT, InL,
1879 DAG.getNode(ISD::SHL, DL, NVT, InH,
1881 Hi = DAG.getNode(ISD::SRL, DL, NVT, InH, DAG.getConstant(Amt, DL, ShTy));
1888 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1891 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1893 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1897 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1900 Lo = DAG.getNode(ISD::OR, DL, NVT,
1901 DAG.getNode(ISD::SRL, DL, NVT, InL,
1903 DAG.getNode(ISD::SHL, DL, NVT, InH,
1905 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH, DAG.getConstant(Amt, DL, ShTy));
1939 Amt = DAG.getNode(ISD::AND, dl, ShTy, Amt,
1946 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1950 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1953 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
1955 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1966 SDValue Amt2 = DAG.getNode(ISD::XOR, dl, ShTy, Amt,
1983 SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, dl, ShTy));
1985 SDValue Sh2 = DAG.getNode(Op2, dl, NVT, Sh1, Amt2);
1987 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
1988 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
1988 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
2015 SDValue AmtExcess = DAG.getNode(ISD::SUB, dl, ShTy, Amt, NVBitsNode);
2016 SDValue AmtLack = DAG.getNode(ISD::SUB, dl, ShTy, NVBitsNode, Amt);
2028 LoS = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt);
2029 HiS = DAG.getNode(ISD::OR, dl, NVT,
2030 DAG.getNode(ISD::SHL, dl, NVT, InH, Amt),
2031 DAG.getNode(ISD::SRL, dl, NVT, InL, AmtLack));
2035 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
2043 HiS = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt);
2044 LoS = DAG.getNode(ISD::OR, dl, NVT,
2045 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
2048 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
2052 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
2060 HiS = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt);
2061 LoS = DAG.getNode(ISD::OR, dl, NVT,
2062 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
2063 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
2066 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
2068 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
2201 OVF = DAG.getNode(ISD::AND, dl, OvfVT, DAG.getConstant(1, dl, OvfVT), OVF);
2205 Hi = DAG.getNode(N->getOpcode(), dl, NVT, Hi, OVF);
2209 Hi = DAG.getNode(RevOpc, dl, NVT, Hi, OVF);
2222 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry);
2233 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry2);
2248 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
2343 SDValue Sum = DAG.getNode(NoCarryOp, dl, LHS.getValueType(), LHS, RHS);
2409 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
2413 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
2415 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2431 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
2435 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
2477 SDValue Neg = DAG.getNode(ISD::SUB, dl, VT,
2504 DAG.getNode(ISD::ADD, dl, NVT, LoLZ,
2516 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
2535 DAG.getNode(ISD::ADD, dl, NVT, HiLZ,
2550 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2677 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2699 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
2707 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
2724 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
2734 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
2739 Lo = DAG.getNode(
2741 DAG.getNode(ISD::SHL, dl, NVT, Hi,
2745 Hi = DAG.getNode(ExtType == ISD::SEXTLOAD ? ISD::SRA : ISD::SRL, dl, NVT,
2763 Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), LL, RL);
2764 Hi = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), LH, RH);
2802 SDValue LLL = DAG.getNode(ISD::AND, dl, NVT, LL, Mask);
2803 SDValue RLL = DAG.getNode(ISD::AND, dl, NVT, RL, Mask);
2805 SDValue T = DAG.getNode(ISD::MUL, dl, NVT, LLL, RLL);
2806 SDValue TL = DAG.getNode(ISD::AND, dl, NVT, T, Mask);
2815 SDValue TH = DAG.getNode(ISD::SRL, dl, NVT, T, Shift);
2816 SDValue LLH = DAG.getNode(ISD::SRL, dl, NVT, LL, Shift);
2817 SDValue RLH = DAG.getNode(ISD::SRL, dl, NVT, RL, Shift);
2819 SDValue U = DAG.getNode(ISD::ADD, dl, NVT,
2820 DAG.getNode(ISD::MUL, dl, NVT, LLH, RLL), TH);
2821 SDValue UL = DAG.getNode(ISD::AND, dl, NVT, U, Mask);
2822 SDValue UH = DAG.getNode(ISD::SRL, dl, NVT, U, Shift);
2824 SDValue V = DAG.getNode(ISD::ADD, dl, NVT,
2825 DAG.getNode(ISD::MUL, dl, NVT, LLL, RLH), UL);
2826 SDValue VH = DAG.getNode(ISD::SRL, dl, NVT, V, Shift);
2828 SDValue W = DAG.getNode(ISD::ADD, dl, NVT,
2829 DAG.getNode(ISD::MUL, dl, NVT, LLH, RLH),
2830 DAG.getNode(ISD::ADD, dl, NVT, UH, VH));
2831 Lo = DAG.getNode(ISD::ADD, dl, NVT, TL,
2832 DAG.getNode(ISD::SHL, dl, NVT, V, Shift));
2834 Hi = DAG.getNode(ISD::ADD, dl, NVT, W,
2835 DAG.getNode(ISD::ADD, dl, NVT,
2836 DAG.getNode(ISD::MUL, dl, NVT, RH, LL),
2837 DAG.getNode(ISD::MUL, dl, NVT, RL, LH)));
2887 Result = DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
3000 SDValue HLAdjusted = DAG.getNode(ISD::SRL, dl, NVT, ResultHL,
3002 SDValue Tmp = DAG.getNode(ISD::OR, dl, NVT, HLAdjusted, ResultHH);
3009 SDValue HLAdjusted = DAG.getNode(ISD::SRL, dl, NVT, ResultHL,
3038 SatMax = DAG.getNode(ISD::OR, dl, BoolNVT, HHGT0,
3039 DAG.getNode(ISD::AND, dl, BoolNVT, HHEQ0, HLUGT));
3044 SatMin = DAG.getNode(ISD::OR, dl, BoolNVT, HHLT,
3045 DAG.getNode(ISD::AND, dl, BoolNVT, HHEQ, HLULT));
3051 SatMax = DAG.getNode(ISD::OR, dl, BoolNVT, HHGT0,
3052 DAG.getNode(ISD::AND, dl, BoolNVT, HHEQ0, HLNeg));
3057 SatMin = DAG.getNode(ISD::OR, dl, BoolNVT, HHLT,
3058 DAG.getNode(ISD::AND, dl, BoolNVT, HHEQ, HLPos));
3091 SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::SADDO ?
3119 SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE);
3269 Hi = DAG.getNode(
3284 Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Hi.getValueType(), Hi,
3298 Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Lo.getValueType(), Lo,
3303 Hi = DAG.getNode(ISD::SRA, dl, Hi.getValueType(), Lo,
3310 Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Hi.getValueType(), Hi,
3349 Hi = DAG.getNode(ISD::SRL, dl, N->getOperand(0).getValueType(),
3384 SDValue Overflow = DAG.getNode(ISD::AND, dl, BitVT,
3389 Overflow = DAG.getNode(ISD::OR, dl, BitVT, Overflow, One.getValue(1));
3390 SDValue OneInHigh = DAG.getNode(ISD::BUILD_PAIR, dl, VT, HalfZero,
3394 Overflow = DAG.getNode(ISD::OR, dl, BitVT, Overflow, Two.getValue(1));
3395 SDValue TwoInHigh = DAG.getNode(ISD::BUILD_PAIR, dl, VT, HalfZero,
3404 SDValue Three = DAG.getNode(ISD::MUL, dl, VT,
3407 SDValue Four = DAG.getNode(ISD::ADD, dl, VT, OneInHigh, TwoInHigh);
3409 Overflow = DAG.getNode(ISD::OR, dl, BitVT, Overflow, Five.getValue(1));
3657 NewLHS = DAG.getNode(ISD::AND, dl,
3665 NewLHS = DAG.getNode(ISD::XOR, dl, LHSLo.getValueType(), LHSLo, RHSLo);
3666 NewRHS = DAG.getNode(ISD::XOR, dl, LHSLo.getValueType(), LHSHi, RHSHi);
3667 NewLHS = DAG.getNode(ISD::OR, dl, NewLHS.getValueType(), NewLHS, NewRHS);
3932 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
3948 Hi = DAG.getNode(ISD::SHL, dl, NVT, Hi,
3951 Hi = DAG.getNode(
3953 DAG.getNode(ISD::SRL, dl, NVT, Lo,
3969 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
4035 FudgePtr = DAG.getNode(ISD::ADD, dl, FudgePtr.getValueType(),
4045 return DAG.getNode(ISD::FADD, dl, DstVT, SignedConv, Fudge);
4090 SDValue Index = DAG.getNode(ISD::ADD, dl, BaseIdx.getValueType(),
4092 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
4206 SDValue Ext = DAG.getNode(
4280 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
4295 SDValue Ext = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OutVT, V0, N->getOperand(1));
4316 SDValue Ex = DAG.getNode(
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp 953 Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, NVT, Pair,
955 Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, NVT, Pair,
972 Hi = DAG.getNode(ISD::SHL, dlHi, NVT, Hi,
974 return DAG.getNode(ISD::OR, dlHi, NVT, Lo, Hi);
1066 Hi = DAG.getNode(ISD::SRL, dl, Op.getValueType(), Op,
lib/CodeGen/SelectionDAG/LegalizeTypes.h 262 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(), Op,
283 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, Op.getValueType(), Op,
lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp 122 Vals.push_back(DAG.getNode(
137 Vals.push_back(DAG.getNode(
172 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
234 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx);
235 Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx);
237 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx,
239 Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, NewVec, Idx);
265 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
274 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
431 Idx = DAG.getNode(ISD::ADD, dl, Idx.getValueType(), Idx, Idx);
433 Idx = DAG.getNode(ISD::ADD, dl,
487 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp 564 return DAG.getNode(ISD::FP_ROUND, dl, VT, Op, DAG.getIntPtrConstant(0, dl));
615 Promoted = DAG.getNode(Op->getOpcode() == ISD::FP_TO_UINT ? ISD::AssertZext
705 SDValue Lo = DAG.getNode(ISD::SRL, dl, WideVT, LoadVals[WideIdx], ShAmt);
716 DAG.getNode(ISD::SHL, dl, WideVT, LoadVals[WideIdx], ShAmt);
717 Lo = DAG.getNode(ISD::OR, dl, WideVT, Lo, Hi);
721 Lo = DAG.getNode(ISD::AND, dl, WideVT, Lo, SrcEltBitMask);
735 Lo = DAG.getNode(ISD::SHL, dl, WideVT, Lo, ShAmt);
736 Lo = DAG.getNode(ISD::SRA, dl, WideVT, Lo, ShAmt);
934 SDValue NotMask = DAG.getNode(ISD::XOR, DL, MaskTy, Mask, AllOnes);
936 Op1 = DAG.getNode(ISD::AND, DL, MaskTy, Op1, Mask);
937 Op2 = DAG.getNode(ISD::AND, DL, MaskTy, Op2, NotMask);
938 SDValue Val = DAG.getNode(ISD::OR, DL, MaskTy, Op1, Op2);
958 Op = DAG.getNode(ISD::SHL, DL, VT, Op, ShiftSz);
959 return DAG.getNode(ISD::SRA, DL, VT, Op, ShiftSz);
1016 return DAG.getNode(ISD::SRA, DL, VT,
1017 DAG.getNode(ISD::SHL, DL, VT, Op, ShiftAmount),
1171 SDValue NotMask = DAG.getNode(ISD::XOR, DL, VT, Mask, AllOnes);
1173 Op1 = DAG.getNode(ISD::AND, DL, VT, Op1, Mask);
1174 Op2 = DAG.getNode(ISD::AND, DL, VT, Op2, NotMask);
1175 SDValue Val = DAG.getNode(ISD::OR, DL, VT, Op1, Op2);
1233 SDValue HI = DAG.getNode(ISD::SRL, DL, VT, Op.getOperand(0), HalfWord);
1234 SDValue LO = DAG.getNode(ISD::AND, DL, VT, Op.getOperand(0), HalfWordMask);
1240 fHI = DAG.getNode(ISD::FMUL, DL, Op.getValueType(), fHI, TWOHW);
1244 return DAG.getNode(ISD::FADD, DL, Op.getValueType(), fHI, fLO);
1252 return DAG.getNode(ISD::FSUB, DL, Op.getValueType(),
1394 Oper = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
1424 SDValue LHSElem = DAG.getNode(
1427 SDValue RHSElem = DAG.getNode(
lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp 202 return DAG.getNode(N->getOpcode(), SDLoc(N),
317 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
325 return DAG.getNode(ISD::FP_ROUND, SDLoc(N),
343 return DAG.getNode(ISD::FPOWI, SDLoc(N),
392 Op = DAG.getNode(
403 return DAG.getNode(N->getOpcode(), SDLoc(N), EltVT,
418 Op = DAG.getNode(
456 Cond = DAG.getNode(
491 Cond = DAG.getNode(ISD::AND, SDLoc(N), CondVT,
498 Cond = DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), CondVT,
558 LHS = DAG.getNode(
561 RHS = DAG.getNode(
790 SDValue Res = DAG.getNode(ISD::FP_ROUND, SDLoc(N),
1024 Lo = DAG.getNode(Opcode, dl, LHSLo.getValueType(), LHSLo, RHSLo, Flags);
1025 Hi = DAG.getNode(Opcode, dl, LHSHi.getValueType(), LHSHi, RHSHi, Flags);
1157 Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, LoVT, Vec, Idx);
1159 Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, HiVT, Vec,
1210 DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
1222 Lo = DAG.getNode(ISD::FPOWI, dl, Lo.getValueType(), Lo, N->getOperand(1));
1223 Hi = DAG.getNode(ISD::FPOWI, dl, Hi.getValueType(), Hi, N->getOperand(1));
1241 Lo = DAG.getNode(ISD::FCOPYSIGN, DL, LHSLo.getValueType(), LHSLo, RHSLo);
1242 Hi = DAG.getNode(ISD::FCOPYSIGN, DL, LHSHi.getValueType(), LHSHi, RHSHi);
1255 Lo = DAG.getNode(N->getOpcode(), dl, LHSLo.getValueType(), LHSLo,
1257 Hi = DAG.getNode(N->getOpcode(), dl, LHSHi.getValueType(), LHSHi,
1341 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1378 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, OperandEltVT, Operand,
1440 SDValue OtherVal = DAG.getNode(
1509 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
1565 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1629 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1695 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1748 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo, N->getOperand(1));
1749 Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi, N->getOperand(1));
1755 SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1765 SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1909 SVOps.push_back(DAG.getNode(
2104 return DAG.getNode(ISD::CONCAT_VECTORS, DL, Src0VT, LoSelect, HiSelect);
2145 SDValue Partial = DAG.getNode(CombineOpc, dl, LoOpVT, Lo, Hi, N->getFlags());
2168 SDValue Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
2179 return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResVT, Lo, Hi);
2212 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Lo, Idx);
2214 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Hi,
2284 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), N->getValueType(0), Lo, Hi);
2345 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
2352 SDValue Res = DAG.getNode(ISD::CONCAT_VECTORS, dl, MGT->getValueType(0), Lo,
2413 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
2522 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
2538 Elts.push_back(DAG.getNode(
2613 SDValue InterVec = DAG.getNode(ISD::CONCAT_VECTORS, DL, InterVT, HalfLo,
2620 ? DAG.getNode(ISD::FP_ROUND, DL, OutVT, InterVec,
2641 SDValue Con = DAG.getNode(ISD::CONCAT_VECTORS, DL, WideResVT, LoRes, HiRes);
2668 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
2672 Lo = DAG.getNode(ISD::FP_ROUND, DL, OutVT, Lo, N->getOperand(1));
2673 Hi = DAG.getNode(ISD::FP_ROUND, DL, OutVT, Hi, N->getOperand(1));
2676 return DAG.getNode(ISD::CONCAT_VECTORS, DL, ResVT, Lo, Hi);
2923 return DAG.getNode(N->getOpcode(), dl, WidenVT, InOp1, InOp2, N->getFlags());
3036 return DAG.getNode(N->getOpcode(), dl, WidenVT, InOp1, InOp2, Flags);
3060 SDValue EOp1 = DAG.getNode(
3063 SDValue EOp2 = DAG.getNode(
3066 ConcatOps[ConcatEnd++] = DAG.getNode(Opcode, dl, VT, EOp1, EOp2, Flags);
3077 SDValue EOp1 = DAG.getNode(
3080 SDValue EOp2 = DAG.getNode(
3083 ConcatOps[ConcatEnd++] = DAG.getNode(Opcode, dl, WidenEltVT,
3150 Op = DAG.getNode(
3177 Op = DAG.getNode(
3249 SDValue OtherVal = DAG.getNode(
3278 return DAG.getNode(Opcode, DL, WidenVT, InOp, N->getOperand(1), Flags);
3307 return DAG.getNode(Opcode, DL, WidenVT, InVec, N->getOperand(1), Flags);
3311 SDValue InVal = DAG.getNode(
3317 return DAG.getNode(Opcode, DL, WidenVT, InVal, N->getOperand(1), Flags);
3328 SDValue Val = DAG.getNode(
3334 Ops[i] = DAG.getNode(Opcode, DL, EltVT, Val, N->getOperand(1), Flags);
3365 NewOps[1] = DAG.getNode(
3406 SDValue Val = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, InSVT, InOp,
3445 return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp, ShOp);
3464 return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp, ShOp);
3481 return DAG.getNode(N->getOpcode(), SDLoc(N),
3651 Ops[Idx++] = DAG.getNode(
3682 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, WidenVT, InOp, Idx);
3692 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
3878 Mask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(Mask), ToMaskVT, Mask,
3994 Cond = DAG.getNode(Cond->getOpcode(), SDLoc(Cond), MaskVT, SETCC0, SETCC1);
4244 InOp = DAG.getNode(
4307 return DAG.getNode(
4320 NewOps[1] = DAG.getNode(
4332 DAG.getNode(
4355 return DAG.getNode(
4373 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, BitOp,
4415 Ops[Idx++] = DAG.getNode(
4424 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N),
4430 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
4573 SDValue CC = DAG.getNode(
4653 return DAG.getNode(
4990 SDValue EOp = DAG.getNode(
5010 SDValue EOp = DAG.getNode(
5054 SDValue EOp = DAG.getNode(
5063 SDValue EOp = DAG.getNode(
5103 return DAG.getNode(
5113 Ops[Idx] = DAG.getNode(
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 1101 : getNode(ISD::FP_ROUND, DL, VT, Op, getIntPtrConstant(0, DL));
1139 return getNode(ISD::AND, DL, Op.getValueType(), Op,
1160 return getNode(ISD::XOR, DL, VT, Val, NegOne);
1165 return getNode(ISD::XOR, DL, VT, Val, TrueValue);
1910 VAList = getNode(ISD::ADD, dl, VAList.getValueType(), VAList,
1914 getNode(ISD::AND, dl, VAList.getValueType(), VAList,
1919 Tmp1 = getNode(ISD::ADD, dl, VAList.getValueType(), VAList,
2173 return getNode(ISD::SRL, SDLoc(V), V.getValueType(), SimplifyLHS,
2376 return getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(V),
4656 return getNode(ISD::FSUB, DL, VT, Operand.getOperand(1),
4860 SDValue ScalarResult = getNode(Opcode, DL, SVT, V1, V2);
5248 return getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT,
5285 return getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, N1.getOperand(0), N2);
5294 return getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, N1.getOperand(0),
5654 Value = DAG.getNode(ISD::MUL, dl, IntVT, Value,
5714 return getNode(ISD::ADD, DL, VT, Base, getConstant(Offset, DL, VT));
7191 case 2: return getNode(Opcode, DL, VT, Ops[0], Ops[1]);
7208 case 2: return getNode(Opcode, DL, VT, Ops[0], Ops[1], Flags);
8634 getNode(ISD::TokenFactor, SDLoc(OldLoad), MVT::Other, OldChain, NewChain);
9056 return getNode(
9137 getNode(ISD::EXTRACT_VECTOR_ELT, dl, OperandEltVT, Operand,
9159 Scalars.push_back(getNode(N->getOpcode(), dl, EltVT, Operands[0],
9165 Scalars.push_back(getNode(N->getOpcode(), dl, EltVT,
9316 Lo = getNode(ISD::EXTRACT_SUBVECTOR, DL, LoVT, N,
9318 Hi = getNode(ISD::EXTRACT_SUBVECTOR, DL, HiVT, N,
9344 Args.push_back(getNode(ISD::EXTRACT_VECTOR_ELT, SL, EltVT,
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 242 Val = DAG.getNode(ISD::BUILD_PAIR, DL, RoundVT, Lo, Hi);
258 DAG.getNode(ISD::SHL, DL, TotalVT, Hi,
262 Val = DAG.getNode(ISD::OR, DL, TotalVT, Lo, Hi);
273 Val = DAG.getNode(ISD::BUILD_PAIR, DL, ValueVT, Lo, Hi);
310 Val = DAG.getNode(*AssertOp, DL, PartEVT, Val,
320 return DAG.getNode(
437 return DAG.getNode(
471 return DAG.getNode(
585 SDValue OddVal = DAG.getNode(ISD::SRL, DL, ValueVT, Val,
614 Part1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL,
616 Part0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL,
685 Val = DAG.getNode(
742 Ops[i] = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, IntermediateVT, Val,
745 Ops[i] = DAG.getNode(
873 Parts[i] = DAG.getNode(isSExt ? ISD::AssertSext : ISD::AssertZext, dl,
1608 DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(), MVT::Other,
2235 DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(),
2321 DAG.setRoot(DAG.getNode(ISD::BR, dl, MVT::Other, getControlRoot(),
2340 Cond = DAG.getNode(ISD::XOR, dl, CondLHS.getValueType(), CondLHS, True);
2366 SDValue SUB = DAG.getNode(ISD::SUB, dl,
2386 Cond = DAG.getNode(ISD::XOR, dl, Cond.getValueType(), Cond, True);
2396 BrCond = DAG.getNode(ISD::BR, dl, MVT::Other, BrCond,
2426 SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, SwitchOp,
2458 BrCond = DAG.getNode(ISD::BR, dl, MVT::Other, BrCond,
2465 DAG.setRoot(DAG.getNode(ISD::BR, dl, MVT::Other, CopyTo,
2571 SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, Guard, GuardVal);
2584 SDValue Br = DAG.getNode(ISD::BR, dl,
2626 DAG.getNode(ISD::SUB, dl, VT, SwitchOp, DAG.getConstant(B.First, dl, VT));
2674 Root = DAG.getNode(ISD::BR, dl, MVT::Other, Root, DAG.getBasicBlock(MBB));
2707 SDValue SwitchVal = DAG.getNode(ISD::SHL, dl, VT,
2711 SDValue AndOp = DAG.getNode(ISD::AND, dl,
2733 BrAnd = DAG.getNode(ISD::BR, dl, MVT::Other, BrAnd,
2821 DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(), MVT::Other, getControlRoot(),
2850 DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(),
2936 DAG.setRoot(DAG.getNode(ISD::BRIND, getCurSDLoc(),
3127 SDValue BinNodeValue = DAG.getNode(Opcode, getCurSDLoc(), Op1.getValueType(),
3180 SDValue Res = DAG.getNode(Opcode, getCurSDLoc(), Op1.getValueType(), Op1, Op2,
3192 setValue(&I, DAG.getNode(ISD::SDIV, getCurSDLoc(), Op1.getValueType(), Op1,
3410 setValue(&I, DAG.getNode(ISD::FP_ROUND, dl, DestVT, N,
3534 setValue(&I, DAG.getNode(ISD::EXTRACT_VECTOR_ELT, getCurSDLoc(),
3551 SDValue FirstElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL,
3648 Result = DAG.getNode(
3694 Src = DAG.getNode(
3730 Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL,
3871 N = DAG.getNode(ISD::ADD, dl, N.getValueType(), N,
3902 N = DAG.getNode(ISD::ADD, dl, N.getValueType(), N, OffsVal, Flags);
3923 IdxN = DAG.getNode(ISD::SHL, dl,
3929 IdxN = DAG.getNode(ISD::MUL, dl,
3934 N = DAG.getNode(ISD::ADD, dl,
3965 AllocSize = DAG.getNode(ISD::MUL, dl, IntPtr,
3982 AllocSize = DAG.getNode(ISD::ADD, dl, AllocSize.getValueType(), AllocSize,
3987 DAG.getNode(ISD::AND, dl, AllocSize.getValueType(), AllocSize,
4087 SDValue A = DAG.getNode(ISD::ADD, dl,
4249 SDValue Add = DAG.getNode(ISD::ADD, dl, PtrVT, Ptr,
4865 SDValue t1 = DAG.getNode(ISD::AND, dl, MVT::i32, Op,
4867 SDValue t2 = DAG.getNode(ISD::OR, dl, MVT::i32, t1,
4879 SDValue t0 = DAG.getNode(ISD::AND, dl, MVT::i32, Op,
4881 SDValue t1 = DAG.getNode(
4884 SDValue t2 = DAG.getNode(ISD::SUB, dl, MVT::i32, t1,
4905 SDValue X = DAG.getNode(ISD::FSUB, dl, MVT::f32, t0, t1);
4908 IntegerPartOfX = DAG.getNode(
4922 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4924 SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
4926 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4927 TwoToFractionalPartOfX = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
4938 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4940 SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
4942 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4943 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
4945 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
4946 TwoToFractionalPartOfX = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
4959 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4961 SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
4963 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4964 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
4966 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
4967 SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
4969 SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
4970 SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
4972 SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
4973 SDValue t11 = DAG.getNode(ISD::FADD, dl, MVT::f32, t10,
4975 SDValue t12 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t11, X);
4976 TwoToFractionalPartOfX = DAG.getNode(ISD::FADD, dl, MVT::f32, t12,
4983 DAG.getNode(ISD::ADD, dl, MVT::i32, t13, IntegerPartOfX));
4999 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, Op,
5021 DAG.getNode(ISD::FMUL, dl, MVT::f32, Exp,
5037 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
5039 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
5041 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
5042 LogOfMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
5054 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
5056 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
5058 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
5059 SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
5061 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
5062 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
5064 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
5065 LogOfMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
5079 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
5081 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
5083 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
5084 SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
5086 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
5087 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
5089 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
5090 SDValue t7 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
5092 SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
5093 SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
5095 SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
5096 LogOfMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t10,
5100 return DAG.getNode(ISD::FADD, dl, MVT::f32, LogOfExponent, LogOfMantissa);
5133 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
5135 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
5137 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
5138 Log2ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
5150 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
5152 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
5154 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
5155 SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
5157 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
5158 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
5160 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
5161 Log2ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
5176 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
5178 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
5180 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
5181 SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
5183 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
5184 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
5186 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
5187 SDValue t7 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
5189 SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
5190 SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
5192 SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
5193 Log2ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t10,
5197 return DAG.getNode(ISD::FADD, dl, MVT::f32, LogOfExponent, Log2ofMantissa);
5216 SDValue LogOfExponent = DAG.getNode(ISD::FMUL, dl, MVT::f32, Exp,
5232 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
5234 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
5236 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
5237 Log10ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
5248 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
5250 SDValue t1 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t0,
5252 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
5253 SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
5255 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
5256 Log10ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t4,
5269 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
5271 SDValue t1 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t0,
5273 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
5274 SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
5276 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
5277 SDValue t5 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t4,
5279 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
5280 SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
5282 SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
5283 Log10ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t8,
5287 return DAG.getNode(ISD::FADD, dl, MVT::f32, LogOfExponent, Log10ofMantissa);
5326 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, RHS,
5332 return DAG.getNode(ISD::FPOW, dl, LHS.getValueType(), LHS, RHS);
5367 Res = DAG.getNode(ISD::FMUL, DL,Res.getValueType(), Res, CurSquare);
5372 CurSquare = DAG.getNode(ISD::FMUL, DL, CurSquare.getValueType(),
5379 Res = DAG.getNode(ISD::FDIV, DL, LHS.getValueType(),
5386 return DAG.getNode(ISD::FPOWI, DL, LHS.getValueType(), LHS, RHS);
5974 DAG.setRoot(DAG.getNode(ISD::EH_SJLJ_LONGJMP, sdl, MVT::Other,
6073 setValue(&I, DAG.getNode(ISD::FMINNUM, sdl,
6079 setValue(&I, DAG.getNode(ISD::FMAXNUM, sdl,
6085 setValue(&I, DAG.getNode(ISD::FMINIMUM, sdl,
6091 setValue(&I, DAG.getNode(ISD::FMAXIMUM, sdl,
6097 setValue(&I, DAG.getNode(ISD::FCOPYSIGN, sdl,
6154 SDValue Mul = DAG.getNode(ISD::FMUL, sdl,
6158 SDValue Add = DAG.getNode(ISD::FADD, sdl,
6168 DAG.getNode(ISD::FP_ROUND, sdl, MVT::f16,
6181 DAG.setRoot(DAG.getNode(ISD::PCMARKER, sdl, MVT::Other, getRoot(), Tmp));
6233 SDValue ShAmt = DAG.getNode(ISD::UREM, sdl, VT, Z, BitWidthC);
6247 setValue(&I, DAG.getNode(RotateOpcode, sdl, VT, X, Z));
6255 SDValue NegShAmt = DAG.getNode(ISD::SUB, sdl, VT, Zero, Z);
6256 setValue(&I, DAG.getNode(RotateOpcode, sdl, VT, X, NegShAmt));
6262 SDValue NegZ = DAG.getNode(ISD::SUB, sdl, VT, Zero, Z);
6263 SDValue NShAmt = DAG.getNode(ISD::UREM, sdl, VT, NegZ, BitWidthC);
6264 SDValue ShX = DAG.getNode(ISD::SHL, sdl, VT, X, IsFSHL ? ShAmt : NShAmt);
6265 SDValue ShY = DAG.getNode(ISD::SRL, sdl, VT, X, IsFSHL ? NShAmt : ShAmt);
6266 setValue(&I, DAG.getNode(ISD::OR, sdl, VT, ShX, ShY));
6272 SDValue InvShAmt = DAG.getNode(ISD::SUB, sdl, VT, BitWidthC, ShAmt);
6273 SDValue ShX = DAG.getNode(ISD::SHL, sdl, VT, X, IsFSHL ? ShAmt : InvShAmt);
6274 SDValue ShY = DAG.getNode(ISD::SRL, sdl, VT, Y, IsFSHL ? InvShAmt : ShAmt);
6275 SDValue Or = DAG.getNode(ISD::OR, sdl, VT, ShX, ShY);
6292 setValue(&I, DAG.getNode(ISD::SADDSAT, sdl, Op1.getValueType(), Op1, Op2));
6298 setValue(&I, DAG.getNode(ISD::UADDSAT, sdl, Op1.getValueType(), Op1, Op2));
6304 setValue(&I, DAG.getNode(ISD::SSUBSAT, sdl, Op1.getValueType(), Op1, Op2));
6310 setValue(&I, DAG.getNode(ISD::USUBSAT, sdl, Op1.getValueType(), Op1, Op2));
6349 DAG.setRoot(DAG.getNode(ISD::STACKRESTORE, sdl, MVT::Other, getRoot(), Res));
6688 SDValue Add = DAG.getNode(ISD::ADD, sdl, PtrVT, FPVal, OffsetVal);
6873 setValue(&I, DAG.getNode(ISD::AND, getCurSDLoc(), DestVT, Ptr,
7405 SDValue DstPlusSize = DAG.getNode(ISD::ADD, sdl, Dst.getValueType(),
7530 setValue(&I, DAG.getNode(Opcode, getCurSDLoc(), VT, Tmp0, Tmp1));
7572 setValue(&I, DAG.getNode(ISD::FCOPYSIGN, getCurSDLoc(),
8599 SDValue ZExt = DAG.getNode(ISD::AssertZext, SL, Op.getValueType(), Op,
8916 Res = DAG.getNode(ISD::FADD, dl, VT, Op1,
8919 Res = DAG.getNode(ISD::VECREDUCE_STRICT_FADD, dl, VT, Op1, Op2);
8923 Res = DAG.getNode(ISD::FMUL, dl, VT, Op1,
8926 Res = DAG.getNode(ISD::VECREDUCE_STRICT_FMUL, dl, VT, Op1, Op2);
9310 SDValue Add = CLI.DAG.getNode(ISD::ADD, CLI.DL, PtrVT, DemoteStackSlot,
10078 SDValue Or = DAG.getNode(ISD::OR, DL, VT, CondLHS,
10101 BrCond = DAG.getNode(ISD::BR, DL, MVT::Other, BrCond,
10526 DAG.setRoot(DAG.getNode(ISD::BR, getCurSDLoc(), MVT::Other,
lib/CodeGen/SelectionDAG/TargetLowering.cpp 402 NewLHS = DAG.getNode(ISD::OR, dl, Tmp.getValueType(), Tmp, NewLHS);
496 SDValue NewOp = TLO.DAG.getNode(Opcode, DL, VT, Op.getOperand(0), NewC);
542 SDValue X = DAG.getNode(
1035 SDValue Xor = TLO.DAG.getNode(ISD::XOR, dl, VT, Op0.getOperand(0), Op1);
1058 SDValue NewOp = TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Op1);
1107 SDValue NewOp = TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Op1);
1153 SDValue NewOp = TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Op1);
1172 return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::OR, dl, VT, Op0, Op1));
1188 return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::AND, dl, VT, Op0, ANDC));
1305 Op, TLO.DAG.getNode(Opc, dl, VT, Op0.getOperand(0), NewSA));
1333 TLO.DAG.getNode(ISD::SHL, dl, InnerVT, InnerOp,
1357 Op, TLO.DAG.getNode(ISD::SHL, dl, VT, NewExt, NewSA));
1411 Op, TLO.DAG.getNode(Opc, dl, VT, Op0.getOperand(0), NewSA));
1438 return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::SRL, dl, VT, Op0, Op1));
1475 Op, TLO.DAG.getNode(ISD::SRL, dl, VT, Op0, Op1, Flags));
1483 return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::SRL, dl, VT, Op0, NewSA));
1562 TLO.DAG.getNode(ISD::SHL, dl, VT, Op0, ShiftAmt));
1777 Op, TLO.DAG.getNode(ISD::SRL, dl, VT, NewTrunc, Shift));
1851 TLO.DAG.getNode(ISD::SHL, dl, VT, Sign, ShAmt));
1939 TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Op1, Flags);
1957 TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Op1, Flags);
1976 SDValue NewOp = TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Neg1, Flags);
2077 if (DAG.getNode(BO.getOpcode(), SDLoc(BO), EltVT, C0, C1).isUndef())
2830 SDValue NewAnd = DAG.getNode(ISD::AND, SDLoc(N0), OpVT, NotX, Y);
2927 SDValue T0 = DAG.getNode(ISD::SHL, DL, XVT, X, ShiftAmt);
2928 SDValue T1 = DAG.getNode(ISD::SRA, DL, XVT, T0, ShiftAmt);
2999 SDValue T0 = DAG.getNode(NewShiftOpcode, DL, VT, X, Y);
3000 SDValue T1 = DAG.getNode(ISD::AND, DL, VT, T0, C);
3042 SDValue YShl1 = DAG.getNode(ISD::SHL, DL, N1.getValueType(), Y, One);
3122 SDValue Add = DAG.getNode(ISD::ADD, dl, CTVT, CTOp, NegOne);
3123 SDValue And = DAG.getNode(ISD::AND, dl, CTVT, CTOp, Add);
3136 SDValue Add = DAG.getNode(ISD::ADD, dl, CTVT, CTOp, NegOne);
3137 SDValue And = DAG.getNode(ISD::AND, dl, CTVT, CTOp, Add);
3141 return DAG.getNode(LogicOpcode, dl, VT, LHS, RHS);
3278 Ptr = DAG.getNode(ISD::ADD, dl, PtrType, Lod->getBasePtr(),
3285 DAG.getNode(ISD::AND, dl, newVT, NewLoad,
3366 ZextOp = DAG.getNode(ISD::AND, dl, Op0Ty, N0.getOperand(0),
3418 Val = DAG.getNode(ISD::AND, dl, N0.getValueType(),
3447 Op0 = DAG.getNode(ISD::AND, dl, VT,
3451 Op0 = DAG.getNode(ISD::AND, dl, VT,
3626 DAG.getNode(ISD::SRL, dl, ShValTy, N0,
3636 DAG.getNode(ISD::SRL, dl, ShValTy, N0,
3656 SDValue Shift = DAG.getNode(ISD::SRL, dl, CmpTy, N0.getOperand(0),
3687 SDValue Shift = DAG.getNode(ISD::SRL, dl, CmpTy, N0,
3883 Temp = DAG.getNode(ISD::XOR, dl, OpVT, N0, N1);
3889 N0 = DAG.getNode(ISD::XOR, dl, OpVT, N0, N1);
3894 N0 = DAG.getNode(ISD::AND, dl, OpVT, N1, Temp);
3901 N0 = DAG.getNode(ISD::AND, dl, OpVT, N0, Temp);
3908 N0 = DAG.getNode(ISD::OR, dl, OpVT, N1, Temp);
3915 N0 = DAG.getNode(ISD::OR, dl, OpVT, N0, Temp);
4614 Res = DAG.getNode(ISD::SRA, dl, VT, Res, Shift, Flags);
4618 return DAG.getNode(ISD::MUL, dl, VT, Res, Factor);
4711 Q = DAG.getNode(ISD::MULHS, dl, VT, N0, MagicFactor);
4722 Factor = DAG.getNode(ISD::MUL, dl, VT, N0, Factor);
4724 Q = DAG.getNode(ISD::ADD, dl, VT, Q, Factor);
4728 Q = DAG.getNode(ISD::SRA, dl, VT, Q, Shift);
4733 SDValue T = DAG.getNode(ISD::SRL, dl, VT, Q, SignShift);
4735 T = DAG.getNode(ISD::AND, dl, VT, T, ShiftMask);
4737 return DAG.getNode(ISD::ADD, dl, VT, Q, T);
4824 Q = DAG.getNode(ISD::SRL, dl, VT, Q, PreShift);
4831 return DAG.getNode(ISD::MULHU, dl, VT, X, Y);
4849 SDValue NPQ = DAG.getNode(ISD::SUB, dl, VT, N0, Q);
4857 NPQ = DAG.getNode(ISD::SRL, dl, VT, NPQ, DAG.getConstant(1, dl, ShVT));
4861 Q = DAG.getNode(ISD::ADD, dl, VT, NPQ, Q);
4865 Q = DAG.getNode(ISD::SRL, dl, VT, Q, PostShift);
5047 SDValue Op0 = DAG.getNode(ISD::MUL, DL, VT, N, PVal);
5059 Op0 = DAG.getNode(ISD::ROTR, DL, VT, Op0, KVal, Flags);
5256 SDValue Op0 = DAG.getNode(ISD::MUL, DL, VT, N, PVal);
5265 Op0 = DAG.getNode(ISD::ADD, DL, VT, Op0, AVal);
5278 Op0 = DAG.getNode(ISD::ROTR, DL, VT, Op0, KVal, Flags);
5316 SDValue Masked = DAG.getNode(ISD::AND, DL, VT, N, IntMax);
5497 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
5503 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
5516 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
5524 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
5531 return DAG.getNode(
5572 return DAG.getNode(ISD::FP_ROUND, SDLoc(Op), Op.getValueType(),
5625 Lo = DAG.getNode(ISD::MUL, dl, HiLoVT, L, R);
5626 Hi = DAG.getNode(Signed ? ISD::MULHS : ISD::MULHU, dl, HiLoVT, L, R);
5683 LH = DAG.getNode(ISD::SRL, dl, VT, LHS, Shift);
5685 RH = DAG.getNode(ISD::SRL, dl, VT, RHS, Shift);
5698 RH = DAG.getNode(ISD::MUL, dl, HiLoVT, LL, RH);
5699 LH = DAG.getNode(ISD::MUL, dl, HiLoVT, LH, RL);
5700 Hi = DAG.getNode(ISD::ADD, dl, HiLoVT, Hi, RH);
5701 Hi = DAG.getNode(ISD::ADD, dl, HiLoVT, Hi, LH);
5710 Hi = DAG.getNode(ISD::SHL, dl, VT, Hi, Shift);
5711 return DAG.getNode(ISD::OR, dl, VT, Lo, Hi);
5720 Next = DAG.getNode(ISD::ADD, dl, VT, Next, Merge(Lo, Hi));
5739 Next = DAG.getNode(ISD::SRL, dl, VT, Next, Shift);
5751 Next = DAG.getNode(ISD::ADD, dl, VT, Next, Merge(Lo, Hi));
5754 SDValue NextSub = DAG.getNode(ISD::SUB, dl, VT, Next,
5758 NextSub = DAG.getNode(ISD::SUB, dl, VT, Next,
5764 Next = DAG.getNode(ISD::SRL, dl, VT, Next, Shift);
5812 ShAmt = DAG.getNode(ISD::AND, DL, ShVT, Z, Mask);
5814 ShAmt = DAG.getNode(ISD::UREM, DL, ShVT, Z, BitWidthC);
5817 SDValue InvShAmt = DAG.getNode(ISD::SUB, DL, ShVT, BitWidthC, ShAmt);
5818 SDValue ShX = DAG.getNode(ISD::SHL, DL, VT, X, IsFSHL ? ShAmt : InvShAmt);
5819 SDValue ShY = DAG.getNode(ISD::SRL, DL, VT, Y, IsFSHL ? InvShAmt : ShAmt);
5820 SDValue Or = DAG.getNode(ISD::OR, DL, VT, ShX, ShY);
5849 SDValue Sub = DAG.getNode(ISD::SUB, DL, ShVT, BitWidthC, Op1);
5850 Result = DAG.getNode(RevRot, DL, VT, Op0, Sub);
5870 SDValue NegOp1 = DAG.getNode(ISD::SUB, DL, ShVT, BitWidthC, Op1);
5871 SDValue And0 = DAG.getNode(ISD::AND, DL, ShVT, Op1, BitWidthMinusOneC);
5872 SDValue And1 = DAG.getNode(ISD::AND, DL, ShVT, NegOp1, BitWidthMinusOneC);
5873 Result = DAG.getNode(ISD::OR, DL, VT, DAG.getNode(ShOpc, DL, VT, Op0, And0),
5873 Result = DAG.getNode(ISD::OR, DL, VT, DAG.getNode(ShOpc, DL, VT, Op0, And0),
5874 DAG.getNode(HsOpc, DL, VT, Op0, And1));
5913 SDValue ExponentBits = DAG.getNode(
5914 ISD::SRL, dl, IntVT, DAG.getNode(ISD::AND, dl, IntVT, Bits, ExponentMask),
5916 SDValue Exponent = DAG.getNode(ISD::SUB, dl, IntVT, ExponentBits, Bias);
5918 SDValue Sign = DAG.getNode(ISD::SRA, dl, IntVT,
5919 DAG.getNode(ISD::AND, dl, IntVT, Bits, SignMask),
5923 SDValue R = DAG.getNode(ISD::OR, dl, IntVT,
5924 DAG.getNode(ISD::AND, dl, IntVT, Bits, MantissaMask),
5931 DAG.getNode(ISD::SHL, dl, DstVT, R,
5933 DAG.getNode(ISD::SUB, dl, IntVT, Exponent, ExponentLoBit),
5935 DAG.getNode(ISD::SRL, dl, DstVT, R,
5937 DAG.getNode(ISD::SUB, dl, IntVT, ExponentLoBit, Exponent),
5941 SDValue Ret = DAG.getNode(ISD::SUB, dl, DstVT,
5942 DAG.getNode(ISD::XOR, dl, DstVT, R, Sign), Sign);
6005 SrcBiased = DAG.getNode(ISD::FSUB, dl, SrcVT, Src, Cst);
6016 Result = DAG.getNode(ISD::XOR, dl, DstVT, SInt, Ofs);
6026 DAG.getNode(ISD::FSUB, dl, SrcVT, Src, Cst));
6027 False = DAG.getNode(ISD::XOR, dl, DstVT, False,
6062 SDValue Shr = DAG.getNode(ISD::SRL, dl, SrcVT, Src, ShiftConst);
6064 SDValue And = DAG.getNode(ISD::AND, dl, SrcVT, Src, AndConst);
6065 SDValue Or = DAG.getNode(ISD::OR, dl, SrcVT, And, Shr);
6068 SDValue Slow = DAG.getNode(ISD::FADD, dl, DstVT, SignCvt, SignCvt);
6105 SDValue Lo = DAG.getNode(ISD::AND, dl, SrcVT, Src, LoMask);
6106 SDValue Hi = DAG.getNode(ISD::SRL, dl, SrcVT, Src, HiShift);
6107 SDValue LoOr = DAG.getNode(ISD::OR, dl, SrcVT, Lo, TwoP52);
6108 SDValue HiOr = DAG.getNode(ISD::OR, dl, SrcVT, Hi, TwoP84);
6111 SDValue HiSub = DAG.getNode(ISD::FSUB, dl, DstVT, HiFlt, TwoP84PlusTwoP52);
6112 Result = DAG.getNode(ISD::FADD, dl, DstVT, LoFlt, HiSub);
6142 return DAG.getNode(NewOp, dl, VT, Quiet0, Quiet1, Node->getFlags());
6151 return DAG.getNode(IEEE2018Op, dl, VT, Node->getOperand(0),
6192 Op = DAG.getNode(ISD::SUB, dl, VT, Op,
6193 DAG.getNode(ISD::AND, dl, VT,
6194 DAG.getNode(ISD::SRL, dl, VT, Op,
6198 Op = DAG.getNode(ISD::ADD, dl, VT, DAG.getNode(ISD::AND, dl, VT, Op, Mask33),
6198 Op = DAG.getNode(ISD::ADD, dl, VT, DAG.getNode(ISD::AND, dl, VT, Op, Mask33),
6199 DAG.getNode(ISD::AND, dl, VT,
6200 DAG.getNode(ISD::SRL, dl, VT, Op,
6204 Op = DAG.getNode(ISD::AND, dl, VT,
6205 DAG.getNode(ISD::ADD, dl, VT, Op,
6206 DAG.getNode(ISD::SRL, dl, VT, Op,
6212 DAG.getNode(ISD::SRL, dl, VT, DAG.getNode(ISD::MUL, dl, VT, Op, Mask01),
6212 DAG.getNode(ISD::SRL, dl, VT, DAG.getNode(ISD::MUL, dl, VT, Op, Mask01),
6264 Op = DAG.getNode(ISD::OR, dl, VT, Op,
6265 DAG.getNode(ISD::SRL, dl, VT, Op, Tmp));
6311 SDValue Tmp = DAG.getNode(
6313 DAG.getNode(ISD::SUB, dl, VT, Op, DAG.getConstant(1, dl, VT)));
6318 DAG.getNode(ISD::SUB, dl, VT, DAG.getConstant(NumBitsPerElt, dl, VT),
6341 DAG.getNode(ISD::SRA, dl, VT, Op,
6343 SDValue Add = DAG.getNode(ISD::ADD, dl, VT, Op, Shift);
6344 Result = DAG.getNode(ISD::XOR, dl, VT, Add, Shift);
6418 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, RegSclVT, Value,
6427 DAG.getNode(ISD::SHL, SL, IntVT, ExtElt, ShiftAmount);
6428 CurrVal = DAG.getNode(ISD::OR, SL, IntVT, CurrVal, ShiftedElt);
6443 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, RegSclVT, Value,
6606 SDValue Result = DAG.getNode(ISD::SHL, dl, VT, Hi, ShiftAmount);
6607 Result = DAG.getNode(ISD::OR, dl, VT, Result, Lo);
6609 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
6720 SDValue Hi = DAG.getNode(ISD::SRL, dl, VT, Val, ShiftAmount);
6737 DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store1, Store2);
6766 Increment = DAG.getNode(ISD::MUL, DL, AddrVT, Increment, Scale);
6770 return DAG.getNode(ISD::ADD, DL, AddrVT, Addr, Increment);
6785 return DAG.getNode(ISD::AND, dl, IdxVT, Idx,
6789 return DAG.getNode(ISD::UMIN, dl, IdxVT, Idx,
6811 Index = DAG.getNode(ISD::MUL, dl, IdxVT, Index,
6813 return DAG.getNode(ISD::ADD, dl, IdxVT, VecPtr, Index);
6874 SDValue Scc = DAG.getNode(ISD::SRL, dl, VT, Clz,
6894 SDValue Max = DAG.getNode(ISD::UMAX, dl, VT, LHS, RHS);
6895 return DAG.getNode(ISD::SUB, dl, VT, Max, RHS);
6900 SDValue Min = DAG.getNode(ISD::UMIN, dl, VT, LHS, InvRHS);
6901 return DAG.getNode(ISD::ADD, dl, VT, Min, RHS);
6936 return DAG.getNode(ISD::OR, dl, VT, SumDiff, OverflowMask);
6945 return DAG.getNode(ISD::AND, dl, VT, SumDiff, Not);
6986 return DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
7028 Lo = DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
7029 Hi = DAG.getNode(HiOp, dl, VT, LHS, RHS);
7074 SDValue Sign = DAG.getNode(ISD::SRA, dl, VT, Lo,
7120 Result = DAG.getNode(IsAdd ? ISD::ADD : ISD::SUB, dl,
7138 Result = DAG.getNode(IsAdd ? ISD::ADD : ISD::SUB, dl,
7148 SDValue Sat = DAG.getNode(OpcSat, dl, LHS.getValueType(), LHS, RHS);
7167 DAG.getNode(ISD::XOR, dl, OType, ConditionRHS, ResultLowerThanLHS), dl,
7189 Result = DAG.getNode(ISD::SHL, dl, VT, LHS, ShiftAmt);
7191 DAG.getNode(UseArithShift ? ISD::SRA : ISD::SRL,
7209 BottomHalf = DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
7210 TopHalf = DAG.getNode(Ops[isSigned][0], dl, VT, LHS, RHS);
7218 SDValue Mul = DAG.getNode(ISD::MUL, dl, WideVT, LHS, RHS);
7223 DAG.getNode(ISD::SRL, dl, WideVT, Mul, ShiftAmt));
7250 DAG.getNode(ISD::SRA, dl, VT, LHS,
7254 DAG.getNode(ISD::SRA, dl, VT, RHS,
7298 SDValue Sign = DAG.getNode(ISD::SRA, dl, VT, BottomHalf, ShiftAmt);
7352 Op = DAG.getNode(BaseOpcode, dl, HalfVT, Lo, Hi);
7365 Res = DAG.getNode(BaseOpcode, dl, EltVT, Res, Ops[i], Node->getFlags());
lib/Target/AArch64/AArch64ISelDAGToDAG.cpp 1050 N = CurDAG->getNode(ISD::ADD, DL, MVT::i64, LHS, MOVIV);
lib/Target/AArch64/AArch64ISelLowering.cpp 994 New = TLO.DAG.getNode(Op.getOpcode(), DL, VT, Op.getOperand(0),
1615 return DAG.getNode(AArch64ISD::FCMP, dl, VT, LHS, RHS);
2076 DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, LHS.getValueType(), LHS,
2142 SDValue Mul = DAG.getNode(ISD::MUL, DL, MVT::i64, LHS, RHS);
2143 SDValue Add = DAG.getNode(ISD::ADD, DL, MVT::i64, Mul,
2156 SDValue UpperBits = DAG.getNode(ISD::SRL, DL, MVT::i64, Add,
2159 SDValue LowerBits = DAG.getNode(ISD::SRA, DL, MVT::i32, Value,
2172 SDValue UpperBits = DAG.getNode(ISD::SRL, DL, MVT::i64, Mul,
2184 Value = DAG.getNode(ISD::MUL, DL, MVT::i64, LHS, RHS);
2186 SDValue UpperBits = DAG.getNode(ISD::MULHS, DL, MVT::i64, LHS, RHS);
2187 SDValue LowerBits = DAG.getNode(ISD::SRA, DL, MVT::i64, Value,
2195 SDValue UpperBits = DAG.getNode(ISD::MULHU, DL, MVT::i64, LHS, RHS);
2302 TVal = DAG.getNode(ISD::XOR, dl, Other.getValueType(), Other,
2518 return DAG.getNode(ISD::FP_ROUND, dl, VT, In, DAG.getIntPtrConstant(0, dl));
2541 return DAG.getNode(
2742 SDValue FltRounds = DAG.getNode(ISD::ADD, dl, MVT::i32, FPCR_32,
2744 SDValue RMODE = DAG.getNode(ISD::SRL, dl, MVT::i32, FltRounds,
2746 return DAG.getNode(ISD::AND, dl, MVT::i32, RMODE,
2804 return DAG.getNode(NewOpc, DL, VT, Op0, Op1);
2812 return DAG.getNode(N0->getOpcode(), DL, VT,
2813 DAG.getNode(NewOpc, DL, VT,
2815 DAG.getNode(NewOpc, DL, VT,
2843 return DAG.getNode(ISD::SMAX, dl, Op.getValueType(),
2846 return DAG.getNode(ISD::UMAX, dl, Op.getValueType(),
2849 return DAG.getNode(ISD::SMIN, dl, Op.getValueType(),
2852 return DAG.getNode(ISD::UMIN, dl, Op.getValueType(),
2916 SDValue TruncExt = DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v8i16,
2921 SDValue ExtractTrunc = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32,
3251 ArgValue = DAG.getNode(ISD::SRL, DL, RegVT, ArgValue,
3304 ArgValue = DAG.getNode(ISD::AssertZext, DL, ArgValue.getValueType(),
3359 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Copy, Chain);
3434 DAG.getNode(ISD::ADD, DL, PtrVT, FIN, DAG.getConstant(8, DL, PtrVT));
3462 FIN = DAG.getNode(ISD::ADD, DL, PtrVT, FIN,
3525 Val = DAG.getNode(ISD::SRL, DL, VA.getLocVT(), Val,
3889 Arg = DAG.getNode(ISD::SHL, DL, VA.getLocVT(), Arg,
3927 Bits = DAG.getNode(ISD::OR, DL, Bits.getValueType(), Bits, Arg);
3963 PtrOff = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr, PtrOff);
3980 DstAddr = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr, PtrOff);
4208 Arg = DAG.getNode(ISD::SHL, DL, VA.getLocVT(), Arg,
4220 Bits = DAG.getNode(ISD::OR, DL, Bits.getValueType(), Bits, Arg);
4344 return DAG.getNode(AArch64ISD::ADDlow, DL, Ty, ADRP, Lo);
4598 return DAG.getNode(ISD::ADD, DL, PtrVT, ThreadBase, TPOff);
4615 DAG.getNode(ISD::ADD, DL, PtrVT, TEB, DAG.getIntPtrConstant(0x58, DL));
4629 DAG.getNode(AArch64ISD::ADDlow, DL, PtrVT, ADRP, TLSIndexLo);
4636 SDValue Slot = DAG.getNode(ISD::SHL, DL, PtrVT, TLSIndex,
4639 DAG.getNode(ISD::ADD, DL, PtrVT, TLSArray, Slot),
4656 Addr = DAG.getNode(AArch64ISD::ADDlow, DL, PtrVT, Addr, TGALo);
4823 In2 = DAG.getNode(ISD::FP_ROUND, DL, VT, In2, DAG.getIntPtrConstant(0, DL));
4911 SDValue UaddLV = DAG.getNode(
4935 Val = DAG.getNode(
5280 return DAG.getNode(ISD::BRIND, DL, MVT::Other, Op.getOperand(0),
5367 DAG.getNode(ISD::ADD, DL, PtrVT, VAList, DAG.getConstant(8, DL, PtrVT));
5370 GRTop = DAG.getNode(ISD::ADD, DL, PtrVT, GRTop,
5382 VRTopAddr = DAG.getNode(ISD::ADD, DL, PtrVT, VAList,
5386 VRTop = DAG.getNode(ISD::ADD, DL, PtrVT, VRTop,
5396 DAG.getNode(ISD::ADD, DL, PtrVT, VAList, DAG.getConstant(24, DL, PtrVT));
5403 DAG.getNode(ISD::ADD, DL, PtrVT, VAList, DAG.getConstant(28, DL, PtrVT));
5460 VAList = DAG.getNode(ISD::ADD, DL, PtrVT, VAList,
5462 VAList = DAG.getNode(ISD::AND, DL, PtrVT, VAList,
5482 SDValue VANext = DAG.getNode(ISD::ADD, DL, PtrVT, VAList,
5496 SDValue NarrowFP = DAG.getNode(ISD::FP_ROUND, DL, VT, WideFP.getValue(0),
5521 FrameAddr = DAG.getNode(ISD::AssertZext, DL, MVT::i64, FrameAddr,
5568 return DAG.getNode(ISD::ADD, DL, VT, FrameAddr, Offset);
5584 DAG.getNode(ISD::ADD, DL, VT, FrameAddr, Offset),
5608 SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i64,
5610 SDValue HiBitsForLo = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, RevShAmt);
5621 SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i64, ShAmt,
5624 SDValue LoBitsForLo = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, ShAmt);
5626 DAG.getNode(ISD::OR, dl, VT, LoBitsForLo, HiBitsForLo);
5631 SDValue LoForBigShift = DAG.getNode(Opc, dl, VT, ShOpHi, ExtraShAmt);
5637 SDValue HiForNormalShift = DAG.getNode(Opc, dl, VT, ShOpHi, ShAmt);
5640 ? DAG.getNode(Opc, dl, VT, ShOpHi,
5663 SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i64,
5665 SDValue LoBitsForHi = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, RevShAmt);
5676 SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i64, ShAmt,
5678 SDValue HiBitsForHi = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, ShAmt);
5680 DAG.getNode(ISD::OR, dl, VT, LoBitsForHi, HiBitsForHi);
5682 SDValue HiForBigShift = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ExtraShAmt);
5693 SDValue LoForNormalShift = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ShAmt);
5789 SDValue Step = DAG.getNode(ISD::FMUL, DL, VT, Estimate, Estimate,
5791 Step = DAG.getNode(AArch64ISD::FRSQRTS, DL, VT, Operand, Step, Flags);
5792 Estimate = DAG.getNode(ISD::FMUL, DL, VT, Estimate, Step, Flags);
5800 Estimate = DAG.getNode(ISD::FMUL, DL, VT, Operand, Estimate, Flags);
5828 SDValue Step = DAG.getNode(AArch64ISD::FRECPS, DL, VT, Operand,
5830 Estimate = DAG.getNode(ISD::FMUL, DL, VT, Estimate, Step, Flags);
6353 DAG.getNode(ISD::CONCAT_VECTORS, dl, DestVT, Src.ShuffleVec,
6369 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
6375 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
6380 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
6383 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
6735 V0 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, CastVT, V0,
6739 V1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, CastVT, V1,
6742 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, V0, V1);
6819 return DAG.getNode(Opcode, dl, VT, OpLHS, Lane);
6880 V1Cst = DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v16i8, V1Cst, V1Cst);
6888 V1Cst = DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v16i8, V1Cst, V2Cst);
6971 return DAG.getNode(Opcode, dl, VT, V1, DAG.getConstant(Lane, dl, MVT::i64));
6975 return DAG.getNode(AArch64ISD::REV64, dl, V1.getValueType(), V1, V2);
6977 return DAG.getNode(AArch64ISD::REV32, dl, V1.getValueType(), V1, V2);
6979 return DAG.getNode(AArch64ISD::REV16, dl, V1.getValueType(), V1, V2);
6998 return DAG.getNode(Opc, dl, V1.getValueType(), V1, V2);
7002 return DAG.getNode(Opc, dl, V1.getValueType(), V1, V2);
7006 return DAG.getNode(Opc, dl, V1.getValueType(), V1, V2);
7011 return DAG.getNode(Opc, dl, V1.getValueType(), V1, V1);
7015 return DAG.getNode(Opc, dl, V1.getValueType(), V1, V1);
7019 return DAG.getNode(Opc, dl, V1.getValueType(), V1, V1);
7047 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ScalarVT, SrcVec, SrcLaneV),
7191 Mov = DAG.getNode(NewOp, dl, MovTy,
7231 Mov = DAG.getNode(NewOp, dl, MovTy,
7263 SDValue Mov = DAG.getNode(NewOp, dl, MovTy,
7674 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, SDValue(Vector, 0),
7677 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, SDValue(Vector, 0),
7712 return DAG.getNode(Opcode, dl, VT, Value, Lane);
7890 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ExtrTy, WideVec,
8017 return DAG.getNode(AArch64ISD::VSHL, DL, VT, Op.getOperand(0),
8029 return DAG.getNode(Opc, DL, VT, Op.getOperand(0),
8072 Fcmeq = DAG.getNode(AArch64ISD::FCMEQ, dl, VT, LHS, RHS);
8078 return DAG.getNode(AArch64ISD::FCMEQ, dl, VT, LHS, RHS);
8082 return DAG.getNode(AArch64ISD::FCMGE, dl, VT, LHS, RHS);
8086 return DAG.getNode(AArch64ISD::FCMGT, dl, VT, LHS, RHS);
8090 return DAG.getNode(AArch64ISD::FCMGE, dl, VT, RHS, LHS);
8099 return DAG.getNode(AArch64ISD::FCMGT, dl, VT, RHS, LHS);
8111 Cmeq = DAG.getNode(AArch64ISD::CMEQ, dl, VT, LHS, RHS);
8117 return DAG.getNode(AArch64ISD::CMEQ, dl, VT, LHS, RHS);
8121 return DAG.getNode(AArch64ISD::CMGE, dl, VT, LHS, RHS);
8125 return DAG.getNode(AArch64ISD::CMGT, dl, VT, LHS, RHS);
8129 return DAG.getNode(AArch64ISD::CMGE, dl, VT, RHS, LHS);
8131 return DAG.getNode(AArch64ISD::CMHS, dl, VT, RHS, LHS);
8133 return DAG.getNode(AArch64ISD::CMHI, dl, VT, RHS, LHS);
8137 return DAG.getNode(AArch64ISD::CMGT, dl, VT, RHS, LHS);
8139 return DAG.getNode(AArch64ISD::CMHI, dl, VT, LHS, RHS);
8141 return DAG.getNode(AArch64ISD::CMHS, dl, VT, LHS, RHS);
8198 Cmp = DAG.getNode(ISD::OR, dl, CmpVT, Cmp, Cmp2);
8213 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ScalarOp.getValueType(), Rdx,
8233 return DAG.getNode(
8240 return DAG.getNode(
8261 RHS = DAG.getNode(ISD::SUB, dl, VT, DAG.getConstant(0, dl, VT), RHS);
8278 RHS = DAG.getNode(ISD::XOR, dl, VT, DAG.getConstant(-1ULL, dl, VT), RHS);
8295 Size = DAG.getNode(ISD::SRL, dl, MVT::i64, Size,
8307 Size = DAG.getNode(ISD::SHL, dl, MVT::i64, Size,
8329 SP = DAG.getNode(ISD::SUB, dl, MVT::i64, SP, Size);
8331 SP = DAG.getNode(ISD::AND, dl, VT, SP.getValue(0),
8344 SP = DAG.getNode(ISD::SUB, dl, MVT::i64, SP, Size);
8346 SP = DAG.getNode(ISD::AND, dl, VT, SP.getValue(0),
9307 SDValue Neg = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
9355 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0, Pow2MinusOne);
9364 DAG.getNode(ISD::SRA, DL, VT, CSel, DAG.getConstant(Lg2, DL, MVT::i64));
9372 return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), SRA);
9457 SDValue ShiftedVal = DAG.getNode(ISD::SHL, DL, VT, N0,
9462 SDValue Res = DAG.getNode(AddSubOpc, DL, VT, AddSubN0, AddSubN1);
9467 return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Res);
9470 return DAG.getNode(ISD::SHL, DL, VT, Res,
9512 SDValue NewAnd = DAG.getNode(ISD::AND, DL, IntVT,
9892 return DAG.getNode(ISD::ROTR, DL, VT, N0, N1);
9895 return DAG.getNode(ISD::ROTR, DL, VT, N0, N1);
9960 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, Source, HalfIdx);
10019 return DAG.getNode(AArch64ISD::DUPLANE64, dl, VT, WidenVector(N0, DAG),
10046 DAG.getNode(ISD::CONCAT_VECTORS, dl, ConcatTy,
10093 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ResTy, Convert, Lane);
10143 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NarrowTy,
10281 LHS = DAG.getNode(ISD::ADD, dl, VT, RHS, DAG.getConstant(1, dl, VT));
10335 return DAG.getNode(N->getOpcode(), SDLoc(N), VT, LHS, RHS);
10431 return DAG.getNode(Opcode, dl, N->getValueType(0), N->getOperand(1),
10435 return DAG.getNode(Opcode, dl, N->getValueType(0), N->getOperand(1),
10461 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0),
10492 return DAG.getNode(ISD::FMAXIMUM, SDLoc(N), N->getValueType(0),
10495 return DAG.getNode(ISD::FMINIMUM, SDLoc(N), N->getValueType(0),
10498 return DAG.getNode(ISD::FMAXNUM, SDLoc(N), N->getValueType(0),
10501 return DAG.getNode(ISD::FMINNUM, SDLoc(N), N->getValueType(0),
10612 Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, InNVT, Src,
10614 Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, InNVT, Src,
10621 return DAG.getNode(ISD::CONCAT_VECTORS, DL, ResVT, Lo, Hi);
10654 DAG.getNode(ISD::ADD, DL, MVT::i64, BasePtr,
10850 SDValue SubVector0 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, HalfVT, StVal,
10852 SDValue SubVector1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, HalfVT, StVal,
10858 SDValue OffsetPtr = DAG.getNode(ISD::ADD, DL, MVT::i64, BasePtr,
11711 return DAG.getNode(ISD::SUB, DL, MVT::i64, Result,
11953 SDValue InterVal = DAG.getNode(InterOp, dl, LoVT, Lo, Hi);
11962 DAG.getNode(ISD::SRL, DL, MVT::i128, N,
11972 DAG.getNode(ISD::SRL, dl, MVT::i128, V, DAG.getConstant(64, dl, MVT::i64)),
lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp 1190 SDValue Sub = CurDAG->getNode(ISD::SUB, DL, MVT::i32,
1271 SDValue Sub = CurDAG->getNode(ISD::SUB, DL, MVT::i32,
lib/Target/AMDGPU/AMDGPUISelLowering.cpp 1286 return DAG.getNode(AMDGPUISD::FMIN_LEGACY, DL, VT, RHS, LHS);
1287 return DAG.getNode(AMDGPUISD::FMAX_LEGACY, DL, VT, LHS, RHS);
1305 return DAG.getNode(AMDGPUISD::FMIN_LEGACY, DL, VT, LHS, RHS);
1306 return DAG.getNode(AMDGPUISD::FMAX_LEGACY, DL, VT, RHS, LHS);
1311 return DAG.getNode(AMDGPUISD::FMAX_LEGACY, DL, VT, RHS, LHS);
1312 return DAG.getNode(AMDGPUISD::FMIN_LEGACY, DL, VT, LHS, RHS);
1323 return DAG.getNode(AMDGPUISD::FMAX_LEGACY, DL, VT, LHS, RHS);
1324 return DAG.getNode(AMDGPUISD::FMIN_LEGACY, DL, VT, RHS, LHS);
1341 SDValue Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Vec, Zero);
1342 SDValue Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Vec, One);
1352 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Vec, Zero);
1360 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Vec, One);
1390 SDValue Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, LoVT, N,
1392 SDValue Hi = DAG.getNode(
1440 Join = DAG.getNode(ISD::CONCAT_VECTORS, SL, VT, LoLoad, HiLoad);
1450 SDValue Ops[] = {Join, DAG.getNode(ISD::TokenFactor, SL, MVT::Other,
1476 {DAG.getNode(ISD::EXTRACT_SUBVECTOR, SL, VT, WideLoad,
1520 return DAG.getNode(ISD::TokenFactor, SL, MVT::Other, LoStore, HiStore);
1556 jq = DAG.getNode(ISD::XOR, DL, VT, LHS, RHS);
1559 jq = DAG.getNode(ISD::SRA, DL, VT, jq,
1563 jq = DAG.getNode(ISD::OR, DL, VT, jq, DAG.getConstant(1, DL, VT));
1578 SDValue fq = DAG.getNode(ISD::FMUL, DL, FltVT,
1611 SDValue Div = DAG.getNode(ISD::ADD, DL, VT, iq, jq);
1614 SDValue Rem = DAG.getNode(ISD::MUL, DL, VT, Div, RHS);
1615 Rem = DAG.getNode(ISD::SUB, DL, VT, LHS, Rem);
1621 Div = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT, Div, InRegSize);
1622 Rem = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT, Rem, InRegSize);
1625 Div = DAG.getNode(ISD::AND, DL, VT, Div, TruncMask);
1626 Rem = DAG.getNode(ISD::AND, DL, VT, Rem, TruncMask);
1647 SDValue LHS_Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, LHS, Zero);
1648 SDValue LHS_Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, LHS, One);
1651 SDValue RHS_Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, RHS, Zero);
1652 SDValue RHS_Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, RHS, One);
1680 SDValue Mul1 = DAG.getNode(ISD::FMUL, DL, MVT::f32, Rcp,
1682 SDValue Mul2 = DAG.getNode(ISD::FMUL, DL, MVT::f32, Mul1,
1698 SDValue Neg_RHS = DAG.getNode(ISD::SUB, DL, VT, Zero64, RHS);
1699 SDValue Mullo1 = DAG.getNode(ISD::MUL, DL, VT, Neg_RHS, Rcp64);
1700 SDValue Mulhi1 = DAG.getNode(ISD::MULHU, DL, VT, Rcp64, Mullo1);
1701 SDValue Mulhi1_Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, Mulhi1,
1703 SDValue Mulhi1_Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, Mulhi1,
1710 SDValue Add1_HiNc = DAG.getNode(ISD::ADD, DL, HalfVT, Rcp_Hi, Mulhi1_Hi);
1714 SDValue Mullo2 = DAG.getNode(ISD::MUL, DL, VT, Neg_RHS, Add1);
1715 SDValue Mulhi2 = DAG.getNode(ISD::MULHU, DL, VT, Add1, Mullo2);
1716 SDValue Mulhi2_Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, Mulhi2,
1718 SDValue Mulhi2_Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, Mulhi2,
1729 SDValue Mulhi3 = DAG.getNode(ISD::MULHU, DL, VT, LHS, Add2);
1731 SDValue Mul3 = DAG.getNode(ISD::MUL, DL, VT, RHS, Mulhi3);
1733 SDValue Mul3_Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, Mul3, Zero);
1734 SDValue Mul3_Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, Mul3, One);
1739 SDValue Sub1_Mi = DAG.getNode(ISD::SUB, DL, HalfVT, LHS_Hi, Mul3_Hi);
1764 SDValue Add3 = DAG.getNode(ISD::ADD, DL, VT, Mulhi3, One64);
1773 SDValue Add4 = DAG.getNode(ISD::ADD, DL, VT, Add3, One64);
1801 SDValue DIV_Part = DAG.getNode(ISD::UDIV, DL, HalfVT, LHS_Hi, RHS_Lo);
1802 SDValue REM_Part = DAG.getNode(ISD::UREM, DL, HalfVT, LHS_Hi, RHS_Lo);
1817 SDValue HBit = DAG.getNode(ISD::SRL, DL, HalfVT, LHS_Lo, POS);
1818 HBit = DAG.getNode(ISD::AND, DL, HalfVT, HBit, One);
1822 REM = DAG.getNode(ISD::SHL, DL, VT, REM, DAG.getConstant(1, DL, VT));
1824 REM = DAG.getNode(ISD::OR, DL, VT, REM, HBit);
1829 DIV_Lo = DAG.getNode(ISD::OR, DL, HalfVT, DIV_Lo, realBIT);
1832 SDValue REM_sub = DAG.getNode(ISD::SUB, DL, VT, REM, RHS);
1866 SDValue RCP_LO = DAG.getNode(ISD::MUL, DL, VT, RCP, Den);
1869 SDValue RCP_HI = DAG.getNode(ISD::MULHU, DL, VT, RCP, Den);
1872 SDValue NEG_RCP_LO = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
1881 SDValue E = DAG.getNode(ISD::MULHU, DL, VT, ABS_RCP_LO, RCP);
1884 SDValue RCP_A_E = DAG.getNode(ISD::ADD, DL, VT, RCP, E);
1887 SDValue RCP_S_E = DAG.getNode(ISD::SUB, DL, VT, RCP, E);
1894 SDValue Quotient = DAG.getNode(ISD::MULHU, DL, VT, Tmp0, Num);
1897 SDValue Num_S_Remainder = DAG.getNode(ISD::MUL, DL, VT, Quotient, Den);
1900 SDValue Remainder = DAG.getNode(ISD::SUB, DL, VT, Num, Num_S_Remainder);
1914 SDValue Tmp1 = DAG.getNode(ISD::AND, DL, VT, Remainder_GE_Den,
1920 SDValue Quotient_A_One = DAG.getNode(ISD::ADD, DL, VT, Quotient,
1924 SDValue Quotient_S_One = DAG.getNode(ISD::SUB, DL, VT, Quotient,
1938 SDValue Remainder_S_Den = DAG.getNode(ISD::SUB, DL, VT, Remainder, Den);
1941 SDValue Remainder_A_Den = DAG.getNode(ISD::ADD, DL, VT, Remainder, Den);
1979 SDValue LHS_Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, LHS, Zero);
1980 SDValue RHS_Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, HalfVT, RHS, Zero);
1992 SDValue DSign = DAG.getNode(ISD::XOR, DL, VT, LHSign, RHSign);
1995 LHS = DAG.getNode(ISD::ADD, DL, VT, LHS, LHSign);
1996 RHS = DAG.getNode(ISD::ADD, DL, VT, RHS, RHSign);
1998 LHS = DAG.getNode(ISD::XOR, DL, VT, LHS, LHSign);
1999 RHS = DAG.getNode(ISD::XOR, DL, VT, RHS, RHSign);
2004 Div = DAG.getNode(ISD::XOR, DL, VT, Div, DSign);
2005 Rem = DAG.getNode(ISD::XOR, DL, VT, Rem, RSign);
2007 Div = DAG.getNode(ISD::SUB, DL, VT, Div, DSign);
2008 Rem = DAG.getNode(ISD::SUB, DL, VT, Rem, RSign);
2026 SDValue Div = DAG.getNode(ISD::FDIV, SL, VT, X, Y);
2028 SDValue Mul = DAG.getNode(ISD::FMUL, SL, VT, Floor, Y);
2030 return DAG.getNode(ISD::FSUB, SL, VT, X, Mul);
2051 SDValue And = DAG.getNode(ISD::AND, SL, SetCCVT, Lt0, NeTrunc);
2055 return DAG.getNode(ISD::FADD, SL, MVT::f64, Trunc, Add);
2067 SDValue Exp = DAG.getNode(ISD::SUB, SL, MVT::i32, ExpPart,
2086 SDValue Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, VecSrc, One);
2094 SDValue SignBit = DAG.getNode(ISD::AND, SL, MVT::i32, Hi, SignBitMask);
2104 SDValue Shr = DAG.getNode(ISD::SRA, SL, MVT::i64, FractMask, Exp);
2106 SDValue Tmp0 = DAG.getNode(ISD::AND, SL, MVT::i64, BcInt, Not);
2130 SDValue CopySign = DAG.getNode(ISD::FCOPYSIGN, SL, MVT::f64, C1, Src);
2134 SDValue Tmp1 = DAG.getNode(ISD::FADD, SL, MVT::f64, Src, CopySign);
2135 SDValue Tmp2 = DAG.getNode(ISD::FSUB, SL, MVT::f64, Tmp1, CopySign);
2170 SDValue Diff = DAG.getNode(ISD::FSUB, SL, VT, X, T);
2178 SDValue SignOne = DAG.getNode(ISD::FCOPYSIGN, SL, VT, One, X);
2187 return DAG.getNode(ISD::FADD, SL, VT, T, Sel);
2205 SDValue Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, BC, One);
2212 SDValue M = DAG.getNode(ISD::SRA, SL, MVT::i64, Mask, Exp);
2213 SDValue D = DAG.getNode(ISD::SRA, SL, MVT::i64,
2218 SDValue Tmp0 = DAG.getNode(ISD::AND, SL, MVT::i64, L, M);
2225 SDValue K = DAG.getNode(ISD::ADD, SL, MVT::i64, L, Tmp2);
2227 K = DAG.getNode(ISD::AND, SL, MVT::i64, K, DAG.getNOT(SL, M, MVT::i64));
2239 SDValue S = DAG.getNode(ISD::FCOPYSIGN, SL, MVT::f64, Mag, X);
2277 SDValue And = DAG.getNode(ISD::AND, SL, SetCCVT, Lt0, NeTrunc);
2281 return DAG.getNode(ISD::FADD, SL, MVT::f64, Trunc, Add);
2293 return DAG.getNode(ISD::FMUL, SL, VT, Log2Operand, Log2BaseInvertedOperand);
2303 SDValue Mul = DAG.getNode(ISD::FMUL, SL, VT, Src, K, Op->getFlags());
2340 SDValue Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Vec, Zero);
2341 SDValue Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Vec, One);
2355 Add = DAG.getNode(ISD::ADD, SL, MVT::i32, OprLo, Bits32);
2359 Add = DAG.getNode(ISD::ADD, SL, MVT::i32, OprHi, Bits32);
2371 SDValue SrcIsZero = DAG.getNode(ISD::AND, SL, SetCCVT, Lo0OrHi0, Hi0orLo0);
2417 S = DAG.getNode(ISD::SRA, SL, MVT::i64, L, SignBit);
2419 SDValue LPlusS = DAG.getNode(ISD::ADD, SL, MVT::i64, L, S);
2420 L = DAG.getNode(ISD::XOR, SL, MVT::i64, LPlusS, S);
2435 DAG.getNode(ISD::SUB, SL, MVT::i32, K, LZ),
2438 SDValue U = DAG.getNode(ISD::AND, SL, MVT::i64,
2439 DAG.getNode(ISD::SHL, SL, MVT::i64, L, LZ),
2442 SDValue T = DAG.getNode(ISD::AND, SL, MVT::i64, U,
2445 SDValue UShl = DAG.getNode(ISD::SRL, SL, MVT::i64,
2448 SDValue V = DAG.getNode(ISD::OR, SL, MVT::i32,
2449 DAG.getNode(ISD::SHL, SL, MVT::i32, E, DAG.getConstant(23, SL, MVT::i32)),
2458 SDValue VTrunc1 = DAG.getNode(ISD::AND, SL, MVT::i32, V, One);
2464 R = DAG.getNode(ISD::ADD, SL, MVT::i32, V, R);
2481 SDValue Lo = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, BC,
2483 SDValue Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, BC,
2491 SDValue LdExp = DAG.getNode(AMDGPUISD::LDEXP, SL, MVT::f64, CvtHi,
2494 return DAG.getNode(ISD::FADD, SL, MVT::f64, LdExp, CvtLo);
2512 DAG.getNode(ISD::FP_ROUND, DL, MVT::f16, IntToFp32, FPRoundFlag);
2539 DAG.getNode(ISD::FP_ROUND, DL, MVT::f16, IntToFp32, FPRoundFlag);
2564 SDValue Mul = DAG.getNode(ISD::FMUL, SL, MVT::f64, Trunc, K0);
2602 SDValue UH = DAG.getNode(ISD::SRL, DL, MVT::i64, U,
2606 SDValue E = DAG.getNode(ISD::SRL, DL, MVT::i32, UH,
2608 E = DAG.getNode(ISD::AND, DL, MVT::i32, E,
2612 E = DAG.getNode(ISD::ADD, DL, MVT::i32, E,
2615 SDValue M = DAG.getNode(ISD::SRL, DL, MVT::i32, UH,
2617 M = DAG.getNode(ISD::AND, DL, MVT::i32, M,
2620 SDValue MaskedSig = DAG.getNode(ISD::AND, DL, MVT::i32, UH,
2622 MaskedSig = DAG.getNode(ISD::OR, DL, MVT::i32, MaskedSig, U);
2625 M = DAG.getNode(ISD::OR, DL, MVT::i32, M, Lo40Set);
2628 SDValue I = DAG.getNode(ISD::OR, DL, MVT::i32,
2633 SDValue N = DAG.getNode(ISD::OR, DL, MVT::i32, M,
2634 DAG.getNode(ISD::SHL, DL, MVT::i32, E,
2638 SDValue OneSubExp = DAG.getNode(ISD::SUB, DL, MVT::i32,
2640 SDValue B = DAG.getNode(ISD::SMAX, DL, MVT::i32, OneSubExp, Zero);
2641 B = DAG.getNode(ISD::SMIN, DL, MVT::i32, B,
2644 SDValue SigSetHigh = DAG.getNode(ISD::OR, DL, MVT::i32, M,
2647 SDValue D = DAG.getNode(ISD::SRL, DL, MVT::i32, SigSetHigh, B);
2648 SDValue D0 = DAG.getNode(ISD::SHL, DL, MVT::i32, D, B);
2650 D = DAG.getNode(ISD::OR, DL, MVT::i32, D, D1);
2653 SDValue VLow3 = DAG.getNode(ISD::AND, DL, MVT::i32, V,
2655 V = DAG.getNode(ISD::SRL, DL, MVT::i32, V,
2661 V1 = DAG.getNode(ISD::OR, DL, MVT::i32, V0, V1);
2662 V = DAG.getNode(ISD::ADD, DL, MVT::i32, V, V1);
2670 SDValue Sign = DAG.getNode(ISD::SRL, DL, MVT::i32, UH,
2672 Sign = DAG.getNode(ISD::AND, DL, MVT::i32, Sign,
2675 V = DAG.getNode(ISD::OR, DL, MVT::i32, Sign, V);
2743 Args[I] = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, ScalarVT, Args[I], VTOp);
2968 SDValue NewInReg = DAG.getNode(N->getOpcode(), SL, SrcVT, Src, N1);
3001 SDValue LoAnd = DAG.getNode(Opc, SL, MVT::i32, Lo, LoRHS);
3002 SDValue HiAnd = DAG.getNode(Opc, SL, MVT::i32, Hi, HiRHS);
3054 SDValue Shl = DAG.getNode(ISD::SHL, SL, XVT, X, SDValue(RHS, 0));
3073 SDValue NewShift = DAG.getNode(ISD::SHL, SL, MVT::i32, Lo, ShiftAmt);
3097 SDValue NewShift = DAG.getNode(ISD::SRA, SL, MVT::i32, Hi,
3107 SDValue NewShift = DAG.getNode(ISD::SRA, SL, MVT::i32, Hi,
3134 return DAG.getNode(
3136 DAG.getNode(ISD::SRL, SL, VT, LHS.getOperand(0), N->getOperand(1)),
3137 DAG.getNode(ISD::SRL, SL, VT, LHS.getOperand(1), N->getOperand(1)));
3155 SDValue Hi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, VecOp, One);
3158 SDValue NewShift = DAG.getNode(ISD::SRL, SL, MVT::i32, Hi, NewConst);
3240 SDValue ShrunkShift = DAG.getNode(Src.getOpcode(), SL, MidVT,
3258 return DAG.getNode(MulOpc, SL, MVT::i32, N0, N1);
3270 return DAG.getNode(ISD::BUILD_PAIR, SL, MVT::i64,
3340 SDValue Mulhi = DAG.getNode(AMDGPUISD::MULHI_I24, DL, MVT::i32, N0, N1);
3364 SDValue Mulhi = DAG.getNode(AMDGPUISD::MULHI_U24, DL, MVT::i32, N0, N1);
3387 SDValue MulLo = DAG.getNode(MulLoOpc, SL, MVT::i32, N0, N1);
3388 SDValue MulHi = DAG.getNode(MulHiOpc, SL, MVT::i32, N0, N1);
3674 SDValue Res = DAG.getNode(ISD::FADD, SL, VT, LHS, RHS, N0->getFlags());
3695 SDValue Res = DAG.getNode(Opc, SL, VT, LHS, RHS, N0->getFlags());
3754 SDValue Res = DAG.getNode(Opposite, SL, VT, NegLHS, NegRHS, N0->getFlags());
3803 return DAG.getNode(ISD::FP_ROUND, SL, VT,
3812 return DAG.getNode(ISD::FP_ROUND, SL, VT, Neg, N0.getOperand(1));
3824 SDValue IntFNeg = DAG.getNode(ISD::XOR, SL, SrcVT, Src,
3849 SDValue IntFAbs = DAG.getNode(ISD::AND, SL, SrcVT, Src,
3919 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, SL, MVT::v2i32,
3930 SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, SL, MVT::v2i32,
4019 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, MVT::i32, BitsFrom,
4045 return DAG.getNode(Signed ? ISD::SRA : ISD::SRL, DL, MVT::i32,
4167 V = DAG.getNode(ISD::SRL, SL, VT, V,
4169 return DAG.getNode(ISD::AND, SL, VT, V,
lib/Target/AMDGPU/R600ISelLowering.cpp 571 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
573 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
575 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
577 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
579 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
581 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
583 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(1),
585 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, Op.getOperand(2),
700 Args.push_back(DAG.getNode(
719 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, Op.getValueType(),
764 DAG.getNode(ISD::FADD, DL, VT,
765 DAG.getNode(ISD::FMUL, DL, VT, Arg,
780 DAG.getNode(ISD::FADD, DL, VT, FractPart,
785 return DAG.getNode(ISD::FMUL, DL, VT, TrigVal,
801 SDValue BigShift = DAG.getNode(ISD::SUB, DL, VT, Shift, Width);
802 SDValue CompShift = DAG.getNode(ISD::SUB, DL, VT, Width1, Shift);
809 SDValue Overflow = DAG.getNode(ISD::SRL, DL, VT, Lo, CompShift);
810 Overflow = DAG.getNode(ISD::SRL, DL, VT, Overflow, One);
812 SDValue HiSmall = DAG.getNode(ISD::SHL, DL, VT, Hi, Shift);
813 HiSmall = DAG.getNode(ISD::OR, DL, VT, HiSmall, Overflow);
814 SDValue LoSmall = DAG.getNode(ISD::SHL, DL, VT, Lo, Shift);
816 SDValue HiBig = DAG.getNode(ISD::SHL, DL, VT, Lo, BigShift);
839 SDValue BigShift = DAG.getNode(ISD::SUB, DL, VT, Shift, Width);
840 SDValue CompShift = DAG.getNode(ISD::SUB, DL, VT, Width1, Shift);
847 SDValue Overflow = DAG.getNode(ISD::SHL, DL, VT, Hi, CompShift);
848 Overflow = DAG.getNode(ISD::SHL, DL, VT, Overflow, One);
850 SDValue HiSmall = DAG.getNode(SRA ? ISD::SRA : ISD::SRL, DL, VT, Hi, Shift);
851 SDValue LoSmall = DAG.getNode(ISD::SRL, DL, VT, Lo, Shift);
852 LoSmall = DAG.getNode(ISD::OR, DL, VT, LoSmall, Overflow);
854 SDValue LoBig = DAG.getNode(SRA ? ISD::SRA : ISD::SRL, DL, VT, Hi, BigShift);
855 SDValue HiBig = SRA ? DAG.getNode(ISD::SRA, DL, VT, Hi, Width1) : Zero;
871 SDValue OVF = DAG.getNode(ovf, DL, VT, Lo, Hi);
873 OVF = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT, OVF,
876 SDValue Res = DAG.getNode(mainop, DL, VT, Lo, Hi);
1105 return DAG.getNode(ISD::SRL, DL, Ptr.getValueType(), Ptr,
1167 LoadPtr = DAG.getNode(ISD::ADD, DL, MVT::i32, BasePtr, Offset);
1172 SDValue Ptr = DAG.getNode(ISD::AND, DL, MVT::i32, LoadPtr,
1184 SDValue ByteIdx = DAG.getNode(ISD::AND, DL, MVT::i32, LoadPtr,
1188 SDValue ShiftAmt = DAG.getNode(ISD::SHL, DL, MVT::i32, ByteIdx,
1200 SDValue ShiftedValue = DAG.getNode(ISD::SHL, DL, MVT::i32,
1204 SDValue DstMask = DAG.getNode(ISD::SHL, DL, MVT::i32, Mask, ShiftAmt);
1211 Dst = DAG.getNode(ISD::AND, DL, MVT::i32, Dst, DstMask);
1214 SDValue Value = DAG.getNode(ISD::OR, DL, MVT::i32, Dst, ShiftedValue);
1270 SDValue DWordAddr = DAG.getNode(ISD::SRL, DL, PtrVT, Ptr,
1287 SDValue ByteIndex = DAG.getNode(ISD::AND, DL, PtrVT, Ptr,
1289 SDValue BitShift = DAG.getNode(ISD::SHL, DL, VT, ByteIndex,
1293 SDValue Mask = DAG.getNode(ISD::SHL, DL, VT, MaskConstant, BitShift);
1296 SDValue TruncValue = DAG.getNode(ISD::AND, DL, VT, Value, MaskConstant);
1297 SDValue ShiftedValue = DAG.getNode(ISD::SHL, DL, VT, TruncValue, BitShift);
1398 LoadPtr = DAG.getNode(ISD::ADD, DL, MVT::i32, BasePtr, Offset);
1403 SDValue Ptr = DAG.getNode(ISD::AND, DL, MVT::i32, LoadPtr,
1413 SDValue ByteIdx = DAG.getNode(ISD::AND, DL, MVT::i32,
1417 SDValue ShiftAmt = DAG.getNode(ISD::SHL, DL, MVT::i32, ByteIdx,
1421 SDValue Ret = DAG.getNode(ISD::SRL, DL, MVT::i32, Read, ShiftAmt);
1428 Ret = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, MVT::i32, Ret, MemEltVTNode);
1475 Result = DAG.getNode(AMDGPUISD::CONST_ADDRESS, DL, MVT::v4i32,
1476 DAG.getNode(ISD::SRL, DL, MVT::i32, Ptr,
1484 Result = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, Result,
1508 SDValue Res = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT, NewLoad,
1522 Ptr = DAG.getNode(ISD::SRL, DL, MVT::i32, Ptr, DAG.getConstant(2, DL, MVT::i32));
1697 NewBldVec[i] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltTy, VectorEntry,
1747 NewBldVec[i] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltTy, VectorEntry,
1825 SDValue NewPtr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
1837 Result = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, Result,
lib/Target/AMDGPU/SIISelLowering.cpp 1436 Val = DAG.getNode(ISD::EXTRACT_SUBVECTOR, SL, NarrowedVT, Val,
1444 Val = DAG.getNode(Opc, SL, MemVT, Val, DAG.getValueType(VT));
1484 SDValue Extract = DAG.getNode(ISD::SRL, SL, MVT::i32, Load, ShiftAmt);
2150 Arg = DAG.getNode(ISD::AssertZext, DL, Arg.getValueType(), Arg,
2181 Val = DAG.getNode(ISD::AssertZext, DL, VT, Val,
2195 Val = DAG.getNode(ISD::AssertSext, DL, VT, Val,
2200 Val = DAG.getNode(ISD::AssertZext, DL, VT, Val,
2402 Val = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), Val,
2407 Val = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), Val,
2536 Y = DAG.getNode(ISD::SHL, SL, MVT::i32, Y,
2539 DAG.getNode(ISD::OR, SL, MVT::i32, InputReg, Y) : Y;
2544 Z = DAG.getNode(ISD::SHL, SL, MVT::i32, Z,
2547 DAG.getNode(ISD::OR, SL, MVT::i32, InputReg, Z) : Z;
3963 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(Op), VT, OpLo, OpHi);
3981 SDValue OpLo = DAG.getNode(Opc, SL, Lo0.getValueType(), Lo0, Lo1,
3983 SDValue OpHi = DAG.getNode(Opc, SL, Hi0.getValueType(), Hi0, Hi1,
3986 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(Op), VT, OpLo, OpHi);
4009 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(Op), VT, OpLo, OpHi);
4270 SDValue Cvt = DAG.getNode(AMDGPUISD::CVT_PKRTZ_F16_F32, SL, MVT::i32,
4295 Results.push_back(DAG.getNode(Opcode, SL, VT, Src0, Src1));
4297 SDValue Cvt = DAG.getNode(Opcode, SL, MVT::i32, Src0, Src1);
4349 SDValue Op = DAG.getNode(ISD::XOR, SL, MVT::i32,
4362 SDValue Op = DAG.getNode(ISD::AND, SL, MVT::i32,
4670 return DAG.getNode(ISD::SHL, DL, MVT::i32, ApertureReg, ShiftAmount);
4741 = DAG.getNode(ISD::BUILD_VECTOR, SL, MVT::v2i32, Src, Aperture);
4777 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, EltVT, Ins,
4805 SDValue LoHalf = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, BCVec,
4807 SDValue HiHalf = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, BCVec,
4846 SDValue ScaledIdx = DAG.getNode(ISD::SHL, SL, MVT::i32, Idx, ScaleFactor);
4849 SDValue BFM = DAG.getNode(ISD::SHL, SL, IntVT,
4853 SDValue LHS = DAG.getNode(ISD::AND, SL, IntVT, BFM, ExtVal);
4854 SDValue RHS = DAG.getNode(ISD::AND, SL, IntVT,
4857 SDValue BFI = DAG.getNode(ISD::OR, SL, IntVT, LHS, RHS);
4889 SDValue ScaledIdx = DAG.getNode(ISD::SHL, SL, MVT::i32, Idx, ScaleFactor);
4892 SDValue Elt = DAG.getNode(ISD::SRL, SL, IntVT, BC, ScaledIdx);
4933 SDValue SubVec = DAG.getNode(ISD::EXTRACT_SUBVECTOR, SL,
4946 SDValue Elt0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, EltVT,
4950 SDValue Elt1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, EltVT,
4997 SDValue ShlHi = DAG.getNode(ISD::SHL, SL, MVT::i32, Hi,
5005 SDValue Or = DAG.getNode(ISD::OR, SL, MVT::i32, Lo, ShlHi);
5061 return DAG.getNode(AMDGPUISD::PC_ADD_REL_OFFSET, DL, PtrVT, PtrLo, PtrHi);
5131 return DAG.getNode(ISD::AssertZext, SL, MVT::i32, Param,
5771 SDValue Tmp = DAG.getNode(ISD::FMINNUM, DL, VT, Rsq,
5773 return DAG.getNode(ISD::FMAXNUM, DL, VT, Tmp,
5937 return DAG.getNode(AMDGPUISD::MUL_U24, DL, VT, Op.getOperand(1), Op.getOperand(2));
5939 return DAG.getNode(AMDGPUISD::MUL_I24, DL, VT, Op.getOperand(1), Op.getOperand(2));
5952 return DAG.getNode(AMDGPUISD::LDEXP, DL, VT,
5959 return DAG.getNode(AMDGPUISD::FP_CLASS, DL, VT,
5971 return DAG.getNode(AMDGPUISD::TRIG_PREOP, DL, VT,
6010 return DAG.getNode(AMDGPUISD::FMUL_LEGACY, DL, VT,
6041 return DAG.getNode(Opcode, DL, VT, Op.getOperand(1), Op.getOperand(2));
6043 SDValue Node = DAG.getNode(Opcode, DL, MVT::i32,
6076 SDValue SrcHi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, SrcVec,
6732 auto Extract = DAG.getNode(
7295 Cvt = DAG.getNode(ISD::SIGN_EXTEND_INREG, SL, MVT::i32, NewLoad,
7353 SDValue Elt = DAG.getNode(ISD::SRL, DL, MVT::i32, NewLD,
7500 SDValue Lo0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, LHS, Zero);
7501 SDValue Lo1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, RHS, Zero);
7505 SDValue Hi0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, LHS, One);
7506 SDValue Hi1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32, RHS, One);
7562 return DAG.getNode(ISD::FMUL, SL, VT, LHS, Recip, Flags);
7571 return DAG.getNode(Opcode, SL, VT, A, B);
7621 SDValue Quot = DAG.getNode(ISD::FMUL, SL, MVT::f32, CvtSrc0, RcpSrc1);
7624 SDValue BestQuot = DAG.getNode(ISD::FP_ROUND, SL, MVT::f16, Quot, FPRoundFlag);
7653 r1 = DAG.getNode(ISD::FMUL, SL, MVT::f32, RHS, r3);
7658 SDValue Mul = DAG.getNode(ISD::FMUL, SL, MVT::f32, LHS, r0);
7660 return DAG.getNode(ISD::FMUL, SL, MVT::f32, r3, Mul);
7767 SDValue OutputChain = DAG.getNode(ISD::TokenFactor, SL, MVT::Other,
7806 SDValue Mul = DAG.getNode(ISD::FMUL, SL, MVT::f64, DivScale1, Fma3);
7825 SDValue NumHi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, NumBC, Hi);
7826 SDValue DenHi = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, DenBC, Hi);
7829 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Scale0BC, Hi);
7831 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Scale1BC, Hi);
7835 Scale = DAG.getNode(ISD::XOR, SL, MVT::i1, CmpNum, CmpDen);
7956 SDValue MulVal = DAG.getNode(ISD::FMUL, DL, VT, Arg, OneOver2Pi);
7959 TrigVal = DAG.getNode(ISD::FMUL, DL, VT, Arg, OneOver2Pi);
8081 SDValue ShlX = DAG.getNode(ISD::SHL, SL, VT, N0.getOperand(0), N1);
8089 return DAG.getNode(ISD::ADD, SL, VT, ShlX, COffset, Flags);
8266 SDValue Ext = DAG.getNode(ISD::AssertZext, SL, VT, BFE,
8268 SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(LHS), VT, Ext,
8324 return DAG.getNode(AMDGPUISD::FP_CLASS, DL, MVT::i1,
8348 return DAG.getNode(AMDGPUISD::FP_CLASS, DL, MVT::i1, RHS.getOperand(0),
8439 return DAG.getNode(AMDGPUISD::FP_CLASS, DL, MVT::i1,
8519 SDValue LowOr = DAG.getNode(ISD::OR, SL, MVT::i32, LowLHS, ExtSrc);
8524 SDValue Vec = DAG.getNode(ISD::BUILD_VECTOR, SL, MVT::v2i32,
8983 return DAG.getNode(N0.getOpcode(), SL, VT, Canon0, Canon1);
9263 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, EltVT,
9295 SDValue Elt0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, EltVT,
9297 SDValue Elt1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, EltVT,
9302 return DAG.getNode(Opc, SL, EltVT, Elt0, Elt1, Vec->getFlags());
9323 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, EltVT, Vec, IC);
9355 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, MVT::i32, Cast,
9358 SDValue Srl = DAG.getNode(ISD::SRL, SL, MVT::i32, Elt,
9398 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, EltVT, Vec, IC);
9466 SDValue Add1 = DAG.getNode(Opc, SL, VT, Op0, Op1);
9467 return DAG.getNode(Opc, SL, VT, Add1, Op2);
9799 return DAG.getNode(ISD::XOR, SL, MVT::i1, LHS.getOperand(0),
9825 return DAG.getNode(ISD::XOR, SL, MVT::i1, LHS.getOperand(0),
9857 return DAG.getNode(AMDGPUISD::FP_CLASS, SL, MVT::i1, LHS.getOperand(0),
lib/Target/ARC/ARCISelLowering.cpp 172 SDValue Cmp = DAG.getNode(ARCISD::CMP, dl, MVT::Glue, LHS, RHS);
190 SDValue LS = DAG.getNode(ISD::SHL, dl, MVT::i32, Op0,
192 SDValue SR = DAG.getNode(ISD::SRA, dl, MVT::i32, LS,
294 SDValue PtrOff = DAG.getNode(
401 SDValue SpLoc = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr,
542 SDValue VAObj = DAG.getNode(ISD::ADD, dl, MVT::i32, FIN,
lib/Target/ARM/ARMISelDAGToDAG.cpp 416 Srl = CurDAG->getNode(ISD::SRL, SDLoc(Srl), MVT::i32,
420 N1 = CurDAG->getNode(ISD::AND, SDLoc(N1), MVT::i32,
423 N1 = CurDAG->getNode(ISD::SHL, SDLoc(N1), MVT::i32,
lib/Target/ARM/ARMISelLowering.cpp 1963 Val = DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi);
1980 Val = DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi);
2013 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(DAG.getDataLayout()),
2159 SDValue Op0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
2161 SDValue Op1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
2213 SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
2232 SDValue Dst = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, StkPtrOff);
2234 SDValue Src = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, SrcOffset);
2366 Callee = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVt, Callee, PICLabel);
2789 SDValue Half = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
2808 Arg = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Arg,
2965 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, WriteValue,
2967 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, WriteValue,
3048 return DAG.getNode(ARMISD::PIC_ADD, DL, PtrVT, Result, PICLabel);
3146 DAG.getNode(ISD::ADD, DL, PtrVT, TEB, DAG.getIntPtrConstant(0x2c, DL));
3158 SDValue Slot = DAG.getNode(ISD::SHL, DL, PtrVT, TLSIndex,
3161 DAG.getNode(ISD::ADD, DL, PtrVT, TLSArray, Slot),
3172 return DAG.getNode(ISD::ADD, DL, PtrVT, TLS, Offset);
3196 Argument = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Argument, PICLabel);
3247 Offset = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Offset, PICLabel);
3266 return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
3481 SDValue Result = DAG.getNode(ISD::ADD, dl, PtrVT, SB, RelAddr);
3639 DAG.getNode(ISD::SRA, dl, VTy, Operand, DAG.getConstant(31, dl, VTy));
3640 SDValue XOR = DAG.getNode(ISD::XOR, dl, VTy, SRA, Operand);
3642 DAG.getNode(ISD::SHL, dl, VTy, XOR, DAG.getConstant(1, dl, VTy));
3644 DAG.getNode(ISD::OR, dl, VTy, SHL, DAG.getConstant(1, dl, VTy));
3654 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VTy, Operand,
3656 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VTy, Operand,
3661 SDValue SRAHi = DAG.getNode(ISD::SRA, dl, VTy, Hi, Constant31);
3662 SDValue XORHi = DAG.getNode(ISD::XOR, dl, VTy, SRAHi, Hi);
3663 SDValue SHLHi = DAG.getNode(ISD::SHL, dl, VTy, XORHi, Constant1);
3664 SDValue ORHi = DAG.getNode(ISD::OR, dl, VTy, SHLHi, Constant1);
3675 DAG.getNode(ISD::ADD, dl, VTy, CLZAdjustedLo, Constant31), CLSHi);
3697 Result = DAG.getNode(ARMISD::PIC_ADD, dl, PtrVT, Result, PICLabel);
3708 return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
3715 return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
3724 return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
3733 return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
3738 return DAG.getNode(NewOpc, SDLoc(Op), Op.getValueType(),
3742 return DAG.getNode(ARMISD::VTBL1, SDLoc(Op), Op.getValueType(),
3768 return DAG.getNode(ARMISD::MEMBARRIER_MCR, dl, MVT::Other, Op.getOperand(0),
3866 return DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, ArgValue, ArgValue2);
3922 FIN = DAG.getNode(ISD::ADD, dl, PtrVT, FIN, DAG.getConstant(4, dl, PtrVT));
4089 ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
4094 ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
4260 LHS = DAG.getNode(ISD::SHL, dl, MVT::i32, LHS.getOperand(0), ShiftAmt);
4318 return DAG.getNode(CompareType, dl, MVT::Glue, LHS, RHS);
4327 Cmp = DAG.getNode(ARMISD::CMPFP, dl, MVT::Glue, LHS, RHS);
4340 return DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0),Cmp.getOperand(1));
4346 Cmp = DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0),Cmp.getOperand(1));
4378 Value = DAG.getNode(ISD::ADD, dl, Op.getValueType(), LHS, RHS);
4379 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, Value, LHS);
4388 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, Value, LHS);
4392 Value = DAG.getNode(ISD::SUB, dl, Op.getValueType(), LHS, RHS);
4393 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, LHS, RHS);
4397 Value = DAG.getNode(ISD::SUB, dl, Op.getValueType(), LHS, RHS);
4398 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, LHS, RHS);
4406 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, Value.getValue(1),
4417 OverflowCmp = DAG.getNode(ARMISD::CMP, dl, MVT::Glue, Value.getValue(1),
4418 DAG.getNode(ISD::SRA, dl, Op.getValueType(),
4503 Overflow = DAG.getNode(ISD::SUB, dl, MVT::i32,
4535 DAG.getNode(NewOpcode, dl, MVT::i32,
4602 Cond = DAG.getNode(ISD::AND, dl, Cond.getValueType(), Cond,
4679 return DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Low, High);
4890 return DAG.getNode(ARMISD::USAT, dl, VT, SatValue,
4893 return DAG.getNode(ARMISD::SSAT, dl, VT, SatValue,
4906 SDValue ShiftV = DAG.getNode(ISD::SRA, dl, VT, SatValue,
4909 SDValue NotShiftV = DAG.getNode(ISD::XOR, dl, VT, ShiftV,
4911 return DAG.getNode(ISD::AND, dl, VT, SatValue, NotShiftV);
4913 return DAG.getNode(ISD::OR, dl, VT, SatValue, ShiftV);
5108 SDValue NewPtr = DAG.getNode(ISD::ADD, dl,
5146 LHS = DAG.getNode(ISD::AND, dl, MVT::i32,
5148 RHS = DAG.getNode(ISD::AND, dl, MVT::i32,
5160 LHS2 = DAG.getNode(ISD::AND, dl, MVT::i32, LHS2, Mask);
5161 RHS2 = DAG.getNode(ISD::AND, dl, MVT::i32, RHS2, Mask);
5302 Index = DAG.getNode(ISD::MUL, dl, PTy, Index, DAG.getConstant(4, dl, PTy));
5303 SDValue Addr = DAG.getNode(ISD::ADD, dl, PTy, Table, Index);
5317 Addr = DAG.getNode(ISD::ADD, dl, PTy, Table, Addr);
5462 Mask = DAG.getNode(ARMISD::VSHLIMM, dl, OpVT,
5470 Tmp1 = DAG.getNode(ARMISD::VSHLIMM, dl, OpVT,
5474 Tmp1 = DAG.getNode(ARMISD::VSHRuIMM, dl, MVT::v1i64,
5483 SDValue MaskNot = DAG.getNode(ISD::XOR, dl, OpVT, Mask,
5486 SDValue Res = DAG.getNode(ISD::OR, dl, OpVT,
5487 DAG.getNode(ISD::AND, dl, OpVT, Tmp1, Mask),
5488 DAG.getNode(ISD::AND, dl, OpVT, Tmp0, MaskNot));
5491 Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f32, Res,
5509 Tmp1 = DAG.getNode(ISD::AND, dl, MVT::i32, Tmp1, Mask1);
5511 Tmp0 = DAG.getNode(ISD::AND, dl, MVT::i32,
5514 DAG.getNode(ISD::OR, dl, MVT::i32, Tmp0, Tmp1));
5521 SDValue Hi = DAG.getNode(ISD::AND, dl, MVT::i32, Tmp0.getValue(1), Mask2);
5522 Hi = DAG.getNode(ISD::OR, dl, MVT::i32, Hi, Tmp1);
5523 return DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi);
5541 DAG.getNode(ISD::ADD, dl, VT, FrameAddr, Offset),
5596 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Read.getValue(0),
5647 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DstVT, BitCast,
5746 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, Op,
5748 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, Op,
5751 DAG.getNode(ARMISD::VMOVDRR, dl, MVT::f64, Lo, Hi));
5766 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Cvt, Cvt.getValue(1));
5804 SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
5806 SDValue Tmp1 = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, ShAmt);
5807 SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32, ShAmt,
5809 SDValue Tmp2 = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, RevShAmt);
5810 SDValue LoSmallShift = DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
5811 SDValue LoBigShift = DAG.getNode(Opc, dl, VT, ShOpHi, ExtraShAmt);
5817 SDValue HiSmallShift = DAG.getNode(Opc, dl, VT, ShOpHi, ShAmt);
5819 ? DAG.getNode(Opc, dl, VT, ShOpHi,
5846 SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
5848 SDValue Tmp1 = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, RevShAmt);
5849 SDValue Tmp2 = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, ShAmt);
5850 SDValue HiSmallShift = DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
5852 SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32, ShAmt,
5854 SDValue HiBigShift = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ExtraShAmt);
5862 SDValue LoSmallShift = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ShAmt);
5881 SDValue FltRounds = DAG.getNode(ISD::ADD, dl, MVT::i32, FPSCR,
5883 SDValue RMODE = DAG.getNode(ISD::SRL, dl, MVT::i32, FltRounds,
5885 return DAG.getNode(ISD::AND, dl, MVT::i32, RMODE,
5897 SDValue NX = DAG.getNode(ISD::SUB, dl, VT, getZeroVector(VT, DAG, dl), X);
5898 SDValue LSB = DAG.getNode(ISD::AND, dl, VT, X, NX);
5906 SDValue Bits = DAG.getNode(ISD::SUB, dl, VT, LSB, One);
5918 return DAG.getNode(ISD::SUB, dl, VT, WidthMinus1, CTLZ);
5929 Bits = DAG.getNode(ISD::ADD, dl, VT, LSB, FF);
5933 Bits = DAG.getNode(ISD::SUB, dl, VT, LSB, One);
6048 return DAG.getNode(ARMISD::VSHLIMM, dl, VT, N->getOperand(0),
6050 return DAG.getNode(ARMISD::VSHLu, dl, VT, N->getOperand(0),
6060 return DAG.getNode(VShiftOpc, dl, VT, N->getOperand(0),
6067 SDValue NegatedCount = DAG.getNode(
6071 return DAG.getNode(VShiftOpc, dl, VT, N->getOperand(0), NegatedCount);
6107 ShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
6116 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, N->getOperand(0),
6119 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, N->getOperand(0),
6127 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
6139 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, N->getOperand(0),
6141 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, N->getOperand(0),
6150 Lo = DAG.getNode(ARMISD::RRX, dl, MVT::i32, Lo, Hi.getValue(1));
6153 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
6198 SDValue Merged = DAG.getNode(ISD::AND, dl, SplitVT, Cmp, Reversed);
6241 SDValue Result = DAG.getNode(ISD::OR, dl, CmpVT, TmpOp0, TmpOp1);
6253 SDValue Result = DAG.getNode(ISD::OR, dl, CmpVT, TmpOp0, TmpOp1);
6295 SDValue Result = DAG.getNode(ARMISD::VTST, dl, CmpVT, Op0, Op1);
6321 Result = DAG.getNode(ARMISD::VCMPZ, dl, CmpVT, SingleOp,
6347 Carry = DAG.getNode(ISD::SUB, DL, MVT::i32,
6534 return DAG.getNode(ARMISD::VMOVDRR, DL, MVT::f64, Lo, Hi);
6566 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, VecConstant,
6597 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, VecFConstant,
6614 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32, VecFConstant,
7061 SDValue Ext = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::i32, FirstOp,
7216 N = DAG.getNode(ARMISD::VDUPLANE, dl, VT,
7221 N = DAG.getNode(ARMISD::VDUPLANE, dl, VT,
7290 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Lower, Upper);
7426 DAG.getNode(ISD::CONCAT_VECTORS, dl, DestVT, Src.ShuffleVec,
7442 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
7448 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
7453 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
7456 DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, DestVT, Src.ShuffleVec,
7649 return DAG.getNode(ARMISD::VDUPLANE, dl, VT,
7686 return DAG.getNode(ARMISD::VTBL1, DL, MVT::v8i8, V1,
7772 SDValue srl = DAG.getNode(ISD::SRL, dl, MVT::i32, rbit,
7794 return DAG.getNode(ARMISD::VCMPZ, dl, VT, Shuffled,
7842 return DAG.getNode(ARMISD::VDUPLANE, dl, VT, V1,
7925 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Res.getValue(0),
7976 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
8009 SDValue Ext = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::i32,
8071 SDValue Shift = DAG.getNode(ISD::SRL, dl, MVT::i32, Conv,
8091 return DAG.getNode(ARMISD::VGETLANEu, dl, MVT::i32, Vec, Lane);
8132 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32, NewV,
8145 return DAG.getNode(ARMISD::VCMPZ, dl, VT, ConVec,
8199 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32, NewV1,
8207 return DAG.getNode(ARMISD::VCMPZ, dl, VT, SubVec,
8477 return DAG.getNode(NewOpc, DL, VT, Op0, Op1);
8491 return DAG.getNode(N0->getOpcode(), DL, VT,
8492 DAG.getNode(NewOpc, DL, VT,
8494 DAG.getNode(NewOpc, DL, VT,
8511 Y = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f32,
8518 X = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, X, Y);
8521 X = DAG.getNode(ISD::ADD, dl, MVT::v4i32, X, Y);
8545 N2 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f32,
8551 N2 = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, N1, N2);
8556 N0 = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, N0, N2);
8559 N0 = DAG.getNode(ISD::ADD, dl, MVT::v4i32, N0, N1);
8583 N2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N0,
8585 N3 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N1,
8587 N0 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N0,
8589 N1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N1,
8595 N0 = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v8i16, N0, N2);
8620 N2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N0,
8622 N3 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N1,
8624 N0 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N0,
8626 N1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v4i16, N1,
8632 N0 = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v8i16, N0, N2);
8635 N0 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v8i8,
8654 N2 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f32,
8660 N2 = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, N1, N2);
8664 N2 = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, N1, N2);
8669 N0 = DAG.getNode(ISD::FMUL, dl, MVT::v4f32, N0, N2);
8672 N0 = DAG.getNode(ISD::ADD, dl, MVT::v4i32, N0, N1);
8704 Carry = DAG.getNode(ISD::SUB, DL, MVT::i32,
8717 Carry = DAG.getNode(ISD::SUB, DL, MVT::i32,
8790 SDValue Add = DAG.getNode(ISD::ADD, dl, PtrVT, SRet,
8886 SDValue DBZCHK = DAG.getNode(ARMISD::WIN__DBZCHK, dl, MVT::Other,
8896 return DAG.getNode(ARMISD::WIN__DBZCHK, DL, MVT::Other, InChain, Op);
8897 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, Op,
8899 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, Op,
8901 return DAG.getNode(ARMISD::WIN__DBZCHK, DL, MVT::Other, InChain,
8902 DAG.getNode(ISD::OR, DL, MVT::i32, Lo, Hi));
8920 SDValue Upper = DAG.getNode(ISD::SRL, dl, MVT::i64, Result,
8953 Pred = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MemVT, Pred,
8974 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32, Build,
9046 Results.push_back(DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Cycles32,
9055 DAG.getNode(ISD::SRL, dl, MVT::i64, V, DAG.getConstant(32, dl, MVT::i32)),
9258 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
9261 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
10922 SDValue FalseVal = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
11029 SDValue Concat = DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), ConcatVT,
11729 SDValue BinOp = DAG.getNode(N->getOpcode(), dl, MVT::i32, X,
11732 SDValue Res = DAG.getNode(ISD::SHL, dl, MVT::i32, BinOp, SHL.getOperand(1));
11817 return DAG.getNode(Opcode, DL, VT,
11818 DAG.getNode(ISD::MUL, DL, VT, N00, N1),
11819 DAG.getNode(ISD::MUL, DL, VT, N01, N1));
11856 Res = DAG.getNode(ISD::ADD, DL, VT,
11858 DAG.getNode(ISD::SHL, DL, VT,
11864 Res = DAG.getNode(ISD::SUB, DL, VT,
11865 DAG.getNode(ISD::SHL, DL, VT,
11876 Res = DAG.getNode(ISD::SUB, DL, VT,
11878 DAG.getNode(ISD::SHL, DL, VT,
11884 Res = DAG.getNode(ISD::ADD, DL, VT,
11886 DAG.getNode(ISD::SHL, DL, VT,
11890 Res = DAG.getNode(ISD::SUB, DL, VT,
11897 Res = DAG.getNode(ISD::SHL, DL, VT,
11959 SDValue SHL = DAG.getNode(ISD::SHL, DL, MVT::i32, N0->getOperand(0),
11961 return DAG.getNode(ISD::SRL, DL, MVT::i32, SHL,
11970 SDValue SHL = DAG.getNode(ISD::SRL, DL, MVT::i32, N0->getOperand(0),
11972 return DAG.getNode(ISD::SHL, DL, MVT::i32, SHL,
11983 SDValue SHL = DAG.getNode(ISD::SHL, DL, MVT::i32, N0->getOperand(0),
11985 return DAG.getNode(ISD::SRL, DL, MVT::i32, SHL,
11996 SDValue SHL = DAG.getNode(ISD::SRL, DL, MVT::i32, N0->getOperand(0),
11998 return DAG.getNode(ISD::SHL, DL, MVT::i32, SHL,
12035 SDValue Vbic = DAG.getNode(ARMISD::VBICIMM, dl, VbicVT, Input, Val);
12113 SDValue Res = DAG.getNode(Opcode, dl, MVT::i32, OpS32, OpS16);
12193 Res = DAG.getNode(ISD::SRL, DL, VT, N1.getOperand(0),
12210 Res = DAG.getNode(ISD::SRL, DL, VT, N00,
12310 SDValue And = DCI.DAG.getNode(ISD::AND, SDLoc(N), VT, NewN0, NewN1);
12311 return DCI.DAG.getNode(ISD::XOR, SDLoc(N), VT, And,
12342 SDValue Vorr = DAG.getNode(ARMISD::VORRIMM, dl, VorrVT, Input, Val);
12561 From1 = DCI.DAG.getNode(
12596 SDValue OffsetPtr = DAG.getNode(ISD::ADD, DL, MVT::i32, BasePtr,
12847 SDValue NewConcat = DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
13323 SDValue SubVec = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, StoreType,
13329 DAG.getNode(ISD::ADD, DL, BasePtr.getValueType(), BasePtr, Increment);
13379 DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NewFromVT, Trunc.getOperand(0),
13424 SDValue OffsetPtr = DAG.getNode(ISD::ADD, DL, MVT::i32, BasePtr,
13444 SDValue ExtElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
13704 return DAG.getNode(VShiftOpc, dl, N->getValueType(0),
13755 return DAG.getNode(ISD::ROTR, SDLoc(N), VT, N0, N1);
13784 SDValue SHL = DAG.getNode(ISD::SHL, DL, MVT::i32, N0->getOperand(0),
13786 return DAG.getNode(
13808 return DAG.getNode(ARMISD::VSHLIMM, dl, VT, N->getOperand(0),
13819 return DAG.getNode(VShiftOpc, dl, VT, N->getOperand(0),
13884 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
13888 return DAG.getNode(ISD::CONCAT_VECTORS, DL, ToVT, NewLoad1, NewLoad2);
13924 return DAG.getNode(Opc, SDLoc(N), VT, Vec, Lane);
14015 X = DAG.getNode(ISD::SRL, dl, VT, X,
14189 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
14316 SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, LHS, RHS);
14317 Res = DAG.getNode(ISD::SRL, dl, VT, DAG.getNode(ISD::CTLZ, dl, VT, Sub),
14329 SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, LHS, RHS);
14335 DAG.getNode(ISD::SUB, dl, MVT::i32,
14395 Res = DAG.getNode(ISD::SHL, dl, VT, Res,
14403 Res = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Res,
14406 Res = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Res,
14409 Res = DAG.getNode(ISD::AssertZext, dl, MVT::i32, Res,
15522 SDValue NewOp = TLO.DAG.getNode(ISD::AND, DL, VT, Op.getOperand(0), NewC);
15982 SDValue Div = DAG.getNode(DivOpcode, dl, VT, Dividend, Divisor);
15983 SDValue Mul = DAG.getNode(ISD::MUL, dl, VT, Div, Divisor);
15984 SDValue Rem = DAG.getNode(ISD::SUB, dl, VT, Dividend, Mul);
16074 SP = DAG.getNode(ISD::SUB, DL, MVT::i32, SP, Size);
16076 SP = DAG.getNode(ISD::AND, DL, MVT::i32, SP.getValue(0),
16083 SDValue Words = DAG.getNode(ISD::SRL, DL, MVT::i32, Size,
16188 Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(0),
16190 Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(0),
16193 Tmp = DAG.getNode(ISD::SRA, dl, HalfT, Hi,
16199 Hi = DAG.getNode(ISD::XOR, dl, HalfT, Tmp, Hi);
16200 Lo = DAG.getNode(ISD::XOR, dl, HalfT, Tmp, Lo);
lib/Target/ARM/ARMSelectionDAGInfo.cpp 213 DAG.getNode(ISD::ADD, dl, MVT::i32, Src,
230 DAG.getNode(ISD::ADD, dl, MVT::i32, Dst,
lib/Target/AVR/AVRISelLowering.cpp 292 return DAG.getNode(AVRISD::LSLLOOP, dl, VT, N->getOperand(0),
295 return DAG.getNode(AVRISD::LSRLOOP, dl, VT, N->getOperand(0),
298 return DAG.getNode(AVRISD::ROLLOOP, dl, VT, N->getOperand(0),
301 return DAG.getNode(AVRISD::RORLOOP, dl, VT, N->getOperand(0),
304 return DAG.getNode(AVRISD::ASRLOOP, dl, VT, N->getOperand(0),
538 SDValue LHSlo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS,
540 SDValue LHShi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS,
542 SDValue RHSlo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS,
544 SDValue RHShi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS,
549 SDValue Top = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i8, LHShi,
553 Cmp = DAG.getNode(AVRISD::CMP, DL, MVT::Glue, LHSlo, RHSlo);
557 SDValue LHS_0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, LHS,
559 SDValue LHS_1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, LHS,
562 SDValue LHS0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS_0,
564 SDValue LHS1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS_0,
566 SDValue LHS2 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS_1,
568 SDValue LHS3 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, LHS_1,
571 SDValue RHS_0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, RHS,
573 SDValue RHS_1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, RHS,
576 SDValue RHS0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS_0,
578 SDValue RHS1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS_0,
580 SDValue RHS2 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS_1,
582 SDValue RHS3 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i16, RHS_1,
587 SDValue Top = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i8, LHS3,
591 Cmp = DAG.getNode(AVRISD::CMP, DL, MVT::Glue, LHS0, RHS0);
602 : DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i8,
605 Cmp = DAG.getNode(AVRISD::CMP, DL, MVT::Glue, LHS, RHS);
724 SDValue Sub = DAG.getNode(
1098 ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
1103 ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
1247 SDValue PtrOff = DAG.getNode(
lib/Target/BPF/BPFISelLowering.cpp 247 ArgValue = DAG.getNode(ISD::AssertSext, DL, RegVT, ArgValue,
250 ArgValue = DAG.getNode(ISD::AssertZext, DL, RegVT, ArgValue,
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp 686 SDValue R = CurDAG->getNode(N->getOpcode(), SDLoc(N), N->getValueType(0),
1007 SDValue NewOr = DAG.getNode(ISD::OR, DLS, VT, SX, VOp);
1011 SDValue NewOr = DAG.getNode(ISD::OR, DLS, VT, SY, VOp);
1069 SDValue NewAdd = DAG.getNode(ISD::ADD, DL, VT, T1.getOperand(0), D);
1071 SDValue NewShl = DAG.getNode(ISD::SHL, DL, VT, NewAdd, C);
1146 SDValue NewSrl = DAG.getNode(ISD::SRL, dl, VT, Y, D);
1147 SDValue NewShl = DAG.getNode(ISD::SHL, dl, VT, NewSrl, DC);
2053 SDValue Sum = CurDAG->getNode(ISD::ADD, SDLoc(N), Mul1.Value.getValueType(),
2057 SDValue New = CurDAG->getNode(ISD::SHL, SDLoc(N), Mul1.Value.getValueType(),
2114 GA.Value = CurDAG->getNode(ISD::ADD, SDLoc(GA.Value),
2176 NewNode = CurDAG->getNode(
2182 NewNode = CurDAG->getNode(NOpcode, SDLoc(N), VT, V0, V1);
2206 NewRoot = CurDAG->getNode(
lib/Target/Hexagon/HexagonISelLowering.cpp 413 MemAddr = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, MemAddr);
747 SDValue T = DAG.getNode(ISD::AND, dl, RegVT,
982 DAG.getNode(ISD::ADD, dl, VT, FrameAddr, Offset),
1136 Sym = DAG.getNode(ISD::ADD, dl, PtrVT, GOT, Sym);
1146 return DAG.getNode(ISD::ADD, dl, PtrVT, TP, LoadOffset);
1168 return DAG.getNode(ISD::ADD, dl, PtrVT, TP, Sym);
1190 SDValue Chain = DAG.getNode(ISD::ADD, dl, PtrVT, GOT, Sym);
2055 return DAG.getNode(NewOpc, SDLoc(Op), ty(Op), Op.getOperand(0), S);
2297 SDValue I0 = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, M0);
2298 return DAG.getNode(HexagonISD::TSTBIT, dl, MVT::i1, A0, I0);
2311 SDValue S0 = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV,
2314 SDValue T1 = DAG.getNode(ISD::SRL, dl, MVT::i64, T0, S0);
2353 SDValue OffV = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV,
2380 ValR = DAG.getNode(HexagonISD::COMBINE, dl, MVT::i64,
2389 SDValue Idx = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV,
2423 SDValue OffV = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, WidthV);
2512 Rs[i] = DAG.getNode(ISD::OR, dl, MVT::i32, Rs[2*i], Rs[2*i+1]);
2528 return DAG.getNode(HexagonISD::COMBINE, dl, VecTy, Op.getOperand(1),
2552 W = DAG.getNode(HexagonISD::COMBINE, dl, MVT::i64,
2578 SDValue WW = DAG.getNode(HexagonISD::COMBINE, dl, MVT::i64,
2709 BO.first = DAG.getNode(ISD::ADD, dl, MVT::i32, BO.first,
2714 ? DAG.getNode(HexagonISD::VALIGNADDR, dl, MVT::i32, BO.first,
2734 SDValue NewChain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
2811 DAG.getNode(ISD::ADD, dl, PtrVT, DAG.getRegister(Hexagon::R30, PtrVT),
lib/Target/Hexagon/HexagonISelLoweringHVX.cpp 254 return DAG.getNode(ISD::CONCAT_VECTORS, dl, typeJoin(ty(Ops)),
529 return DAG.getNode(ISD::AND, dl, ByteTy, S, M);
576 Vec = DAG.getNode(HexagonISD::VROR, dl, ByteTy, Vec, S4);
577 Vec = DAG.getNode(HexagonISD::VINSERTW0, dl, ByteTy, Vec, W);
692 IdxV = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, ScV);
753 IdxV = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV, ScV);
909 SDValue S = DAG.getNode(ISD::SUB, dl, MVT::i32, IdxV, HalfV);
920 IdxV = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV,
922 SingleV = DAG.getNode(HexagonISD::VROR, dl, SingleTy, SingleV, IdxV);
935 SingleV = DAG.getNode(HexagonISD::VINSERTW0, dl, SingleTy, SingleV, R0);
936 SingleV = DAG.getNode(HexagonISD::VROR, dl, SingleTy, SingleV,
938 SingleV = DAG.getNode(HexagonISD::VINSERTW0, dl, SingleTy, SingleV, R1);
943 SDValue RolV = DAG.getNode(ISD::SUB, dl, MVT::i32,
945 SingleV = DAG.getNode(HexagonISD::VROR, dl, SingleTy, SingleV, RolV);
980 ByteIdx = DAG.getNode(ISD::MUL, dl, MVT::i32, IdxV,
982 ByteVec = DAG.getNode(HexagonISD::VROR, dl, ByteTy, ByteVec, ByteIdx);
995 SDValue ByteXdi = DAG.getNode(ISD::SUB, dl, MVT::i32, HwLenV, ByteIdx);
996 ByteVec = DAG.getNode(HexagonISD::VROR, dl, ByteTy, ByteVec, ByteXdi);
1037 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VecTy, V0, V1);
1070 Elems[i] = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NTy,
1071 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NTy,
1098 return DAG.getNode(HexagonISD::QCAT, dl, VecTy, Op0, Op.getOperand(1));
1109 return DAG.getNode(HexagonISD::QCAT, dl, VecTy, V0, V1);
1127 Res = DAG.getNode(HexagonISD::VROR, dl, ByteTy, Res, S);
1128 Res = DAG.getNode(ISD::OR, dl, ByteTy, Res, Prefixes[e-i-1]);
1470 SDValue S = DAG.getNode(ISD::CONCAT_VECTORS, dl, ResTy, L, H);
1503 { DAG.getNode(ISD::CONCAT_VECTORS, dl, MemTy, Load0, Load1),
1504 DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
1511 NewOp = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store0, Store1);
lib/Target/Lanai/LanaiISelLowering.cpp 471 ArgValue = DAG.getNode(ISD::AssertSext, DL, RegVT, ArgValue,
474 ArgValue = DAG.getNode(ISD::AssertZext, DL, RegVT, ArgValue,
520 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Copy, Chain);
695 DAG.getNode(ISD::ADD, DL, getPointerTy(DAG.getDataLayout()), StackPtr,
946 Res = DAG.getNode(ISD::SHL, DL, VT, V,
960 DAG.getNode(ISD::SHL, DL, VT, V, DAG.getConstant(I, DL, MVT::i32));
962 Res = DAG.getNode(ISD::ADD, DL, VT, Res, Op);
964 Res = DAG.getNode(ISD::SUB, DL, VT, Res, Op);
980 return DAG.getNode(LanaiISD::SETCC, DL, Op.getValueType(), TargetCC, Flag);
1030 SDValue Sub = DAG.getNode(ISD::SUB, DL, MVT::i32, StackPointer, Size);
1064 SDValue Ptr = DAG.getNode(ISD::ADD, DL, VT, FrameAddr,
1086 SDValue Ptr = DAG.getNode(ISD::ADD, DL, VT, FrameAddr,
1140 return DAG.getNode(ISD::OR, DL, MVT::i32,
1153 SDValue Result = DAG.getNode(ISD::OR, DL, MVT::i32, Hi, Lo);
1174 return DAG.getNode(ISD::OR, DL, MVT::i32,
1188 return DAG.getNode(ISD::OR, DL, MVT::i32, Hi, Lo);
1204 SDValue Result = DAG.getNode(ISD::OR, DL, MVT::i32, Hi, Lo);
1217 return DAG.getNode(ISD::OR, DL, MVT::i32,
1230 SDValue Result = DAG.getNode(ISD::OR, DL, MVT::i32, Hi, Lo);
1252 SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
1254 SDValue LoBitsForHi = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, RevShAmt);
1262 SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32, ShAmt,
1264 SDValue HiBitsForHi = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, ShAmt);
1266 DAG.getNode(ISD::OR, dl, VT, LoBitsForHi, HiBitsForHi);
1268 SDValue HiForBigShift = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ExtraShAmt);
1276 SDValue LoForNormalShift = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ShAmt);
1305 SDValue NegatedPlus32 = DAG.getNode(
1309 SDValue Hi = DAG.getNode(ISD::SRL, dl, MVT::i32, ShOpHi, ShAmt);
1312 SDValue Lo = DAG.getNode(ISD::SRL, dl, MVT::i32, ShOpLo, ShAmt);
1315 DAG.getNode(ISD::SHL, dl, MVT::i32, ShOpHi, NegatedPlus32);
1318 DAG.getNode(ISD::OR, dl, MVT::i32, Lo, CarryBits));
1433 DAG.getNode(N->getOpcode(), SDLoc(N), VT, OtherOp, NonConstantVal);
lib/Target/MSP430/MSP430ISelLowering.cpp 646 ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
649 ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
700 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
842 DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr,
974 ? DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, VT, Victim,
1109 return DAG.getNode(MSP430ISD::CMP, dl, MVT::Glue, LHS, RHS);
1191 SR = DAG.getNode(ISD::SRA, dl, MVT::i16, SR, One);
1192 SR = DAG.getNode(ISD::AND, dl, MVT::i16, SR, One);
1194 SR = DAG.getNode(ISD::XOR, dl, MVT::i16, SR, One);
1230 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, VT,
1270 DAG.getNode(ISD::ADD, dl, PtrVT, FrameAddr, Offset),
lib/Target/Mips/MipsISelDAGToDAG.cpp 258 SDValue NewNode = CurDAG->getNode(ISD::SUB, DL, VT, X, NegC);
lib/Target/Mips/MipsISelLowering.cpp 580 SDValue DivRem = DAG.getNode(Opc, DL, MVT::Glue,
738 return DAG.getNode(ISD::ADD, DL, SetCC.getValueType(), SetCC, False);
748 return DAG.getNode(ISD::ADD, DL, SetCC.getValueType(), SetCC, True);
944 SrlX = DAG.getNode(ISD::SRL, DL, And1->getValueType(0), And1, Const1);
1029 BottomHalf = CurDAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, AddOperand,
1032 TopHalf = CurDAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, AddOperand,
1034 SDValue ACCIn = CurDAG.getNode(MipsISD::MTLOHI, DL, MVT::Untyped,
1051 CurDAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, ResLo, ResHi);
1097 SDValue Add1 = DAG.getNode(ISD::ADD, DL, ValTy, N->getOperand(0),
1099 return DAG.getNode(ISD::ADD, DL, ValTy, Add1, Lo);
2035 SDValue Argument = DAG.getNode(MipsISD::Wrapper, DL, PtrVT,
2065 SDValue Add = DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Ret);
2066 return DAG.getNode(ISD::ADD, DL, PtrVT, Add, Lo);
2074 TGA = DAG.getNode(MipsISD::Wrapper, DL, PtrVT, getGlobalReg(DAG, PtrVT),
2087 Offset = DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Lo);
2091 return DAG.getNode(ISD::ADD, DL, PtrVT, ThreadPointer, Offset);
2168 VAList = DAG.getNode(
2172 VAList = DAG.getNode(
2182 DAG.getNode(ISD::ADD, DL, VAList.getValueType(), VAList,
2196 VAList = DAG.getNode(ISD::ADD, DL, VAListPtr.getValueType(), VAList,
2216 DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32, Op.getOperand(0),
2220 DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32, Op.getOperand(1),
2234 SDValue SllX = DAG.getNode(ISD::SHL, DL, MVT::i32, X, Const1);
2235 SDValue SrlX = DAG.getNode(ISD::SRL, DL, MVT::i32, SllX, Const1);
2236 SDValue SrlY = DAG.getNode(ISD::SRL, DL, MVT::i32, Y, Const31);
2237 SDValue SllY = DAG.getNode(ISD::SHL, DL, MVT::i32, SrlY, Const31);
2238 Res = DAG.getNode(ISD::OR, DL, MVT::i32, SrlX, SllY);
2244 SDValue LowX = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
2247 return DAG.getNode(MipsISD::BuildPairF64, DL, MVT::f64, LowX, Res);
2284 SDValue SllX = DAG.getNode(ISD::SHL, DL, TyX, X, Const1);
2285 SDValue SrlX = DAG.getNode(ISD::SRL, DL, TyX, SllX, Const1);
2286 SDValue SrlY = DAG.getNode(ISD::SRL, DL, TyY, Y,
2294 SDValue SllY = DAG.getNode(ISD::SHL, DL, TyX, SrlY,
2296 SDValue Or = DAG.getNode(ISD::OR, DL, TyX, SrlX, SllY);
2317 : DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
2328 SDValue SllX = DAG.getNode(ISD::SHL, DL, MVT::i32, X, Const1);
2329 Res = DAG.getNode(ISD::SRL, DL, MVT::i32, SllX, Const1);
2340 DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32, Op.getOperand(0),
2342 return DAG.getNode(MipsISD::BuildPairF64, DL, MVT::f64, LowX, Res);
2359 SDValue SllX = DAG.getNode(ISD::SHL, DL, MVT::i64, X, Const1);
2360 Res = DAG.getNode(ISD::SRL, DL, MVT::i64, SllX, Const1);
2448 return DAG.getNode(MipsISD::Sync, DL, MVT::Other, Op.getOperand(0),
2465 SDValue Not = DAG.getNode(ISD::XOR, DL, MVT::i32, Shamt,
2467 SDValue ShiftRight1Lo = DAG.getNode(ISD::SRL, DL, VT, Lo,
2469 SDValue ShiftRightLo = DAG.getNode(ISD::SRL, DL, VT, ShiftRight1Lo, Not);
2470 SDValue ShiftLeftHi = DAG.getNode(ISD::SHL, DL, VT, Hi, Shamt);
2471 SDValue Or = DAG.getNode(ISD::OR, DL, VT, ShiftLeftHi, ShiftRightLo);
2472 SDValue ShiftLeftLo = DAG.getNode(ISD::SHL, DL, VT, Lo, Shamt);
2473 SDValue Cond = DAG.getNode(ISD::AND, DL, MVT::i32, Shamt,
2503 SDValue Not = DAG.getNode(ISD::XOR, DL, MVT::i32, Shamt,
2505 SDValue ShiftLeft1Hi = DAG.getNode(ISD::SHL, DL, VT, Hi,
2507 SDValue ShiftLeftHi = DAG.getNode(ISD::SHL, DL, VT, ShiftLeft1Hi, Not);
2508 SDValue ShiftRightLo = DAG.getNode(ISD::SRL, DL, VT, Lo, Shamt);
2509 SDValue Or = DAG.getNode(ISD::OR, DL, VT, ShiftLeftHi, ShiftRightLo);
2510 SDValue ShiftRightHi = DAG.getNode(IsSRA ? ISD::SRA : ISD::SRL,
2512 SDValue Cond = DAG.getNode(ISD::AND, DL, MVT::i32, Shamt,
2514 SDValue Ext = DAG.getNode(ISD::SRA, DL, VT, Hi,
2543 Ptr = DAG.getNode(ISD::ADD, DL, BasePtrVT, Ptr,
2610 SDValue SLL = DAG.getNode(ISD::SHL, DL, MVT::i64, LWR, Const32);
2611 SDValue SRL = DAG.getNode(ISD::SRL, DL, MVT::i64, SLL, Const32);
2624 Ptr = DAG.getNode(ISD::ADD, DL, BasePtrVT, Ptr,
2893 DAG.getNode(ISD::ADD, DL, getPointerTy(DAG.getDataLayout()), StackPtr,
3162 SDValue Lo = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
3164 SDValue Hi = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
3202 Arg = DAG.getNode(
3367 Val = DAG.getNode(
3386 Val = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), Val,
3392 Val = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), Val,
3421 Val = DAG.getNode(
3443 Val = DAG.getNode(ISD::AssertSext, DL, LocVT, Val, DAG.getValueType(ValVT));
3448 Val = DAG.getNode(ISD::AssertZext, DL, LocVT, Val, DAG.getValueType(ValVT));
3547 ArgValue = DAG.getNode(MipsISD::BuildPairF64, DL, MVT::f64,
3596 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Copy, Chain);
3706 Val = DAG.getNode(
4217 SDValue StorePtr = DAG.getNode(ISD::ADD, DL, PtrTy, FIN,
4248 SDValue LoadPtr = DAG.getNode(ISD::ADD, DL, PtrTy, Arg,
4273 SDValue LoadPtr = DAG.getNode(ISD::ADD, DL, PtrTy, Arg,
4289 SDValue Shift = DAG.getNode(ISD::SHL, DL, RegTy, LoadVal,
4293 Val = DAG.getNode(ISD::OR, DL, RegTy, Val, Shift);
4310 SDValue Src = DAG.getNode(ISD::ADD, DL, PtrTy, Arg,
4312 SDValue Dst = DAG.getNode(ISD::ADD, DL, PtrTy, StackPtr,
lib/Target/Mips/MipsISelLowering.h 395 SDValue GOT = DAG.getNode(MipsISD::Wrapper, DL, Ty, getGlobalReg(DAG, Ty),
403 return DAG.getNode(ISD::ADD, DL, Ty, Load, Lo);
414 SDValue Tgt = DAG.getNode(MipsISD::Wrapper, DL, Ty, getGlobalReg(DAG, Ty),
430 Hi = DAG.getNode(ISD::ADD, DL, Ty, Hi, getGlobalReg(DAG, Ty));
431 SDValue Wrapper = DAG.getNode(MipsISD::Wrapper, DL, Ty, Hi,
447 return DAG.getNode(ISD::ADD, DL, Ty,
470 DAG.getNode(ISD::ADD, DL, Ty, Highest,
473 SDValue Shift = DAG.getNode(ISD::SHL, DL, Ty, HigherPart, Cst);
474 SDValue Add = DAG.getNode(ISD::ADD, DL, Ty, Shift,
476 SDValue Shift2 = DAG.getNode(ISD::SHL, DL, Ty, Add, Cst);
478 return DAG.getNode(ISD::ADD, DL, Ty, Shift2,
490 return DAG.getNode(
lib/Target/Mips/MipsSEISelLowering.cpp 804 return DAG.getNode(ISD::SHL, DL, VT, X,
818 return DAG.getNode(ISD::ADD, DL, VT, Op0, Op1);
825 return DAG.getNode(ISD::SUB, DL, VT, Op0, Op1);
865 return DAG.getNode(Opc, DL, Ty, N->getOperand(0),
1017 return DAG.getNode(MipsISD::VNOR, SDLoc(N), Ty, NotOp->getOperand(0),
1189 Ptr = DAG.getNode(ISD::ADD, DL, PtrVT, Ptr, DAG.getConstant(4, DL, PtrVT));
1197 SDValue BP = DAG.getNode(MipsISD::BuildPairF64, DL, MVT::f64, Lo, Hi);
1212 SDValue Lo = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
1214 SDValue Hi = DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32,
1226 Ptr = DAG.getNode(ISD::ADD, DL, PtrVT, Ptr, DAG.getConstant(4, DL, PtrVT));
1240 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32,
1242 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32,
1244 return DAG.getNode(MipsISD::BuildPairF64, DL, MVT::f64, Lo, Hi);
1250 DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32, Op.getOperand(0),
1253 DAG.getNode(MipsISD::ExtractElementF64, DL, MVT::i32, Op.getOperand(0),
1255 return DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Lo, Hi);
1270 SDValue Mult = DAG.getNode(NewOpc, DL, MVT::Untyped,
1287 SDValue InLo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, In,
1289 SDValue InHi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i32, In,
1291 return DAG.getNode(MipsISD::MTLOHI, DL, MVT::Untyped, InLo, InHi);
1297 return DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i64, Lo, Hi);
1412 DAG.getNode(ISD::AND, DL, ViaVecTy, Result, One));
1439 SplatValueB = DAG.getNode(ISD::SRL, DL, MVT::i64, SplatValue,
1500 Exp2Imm = DAG.getNode(ISD::SHL, DL, VecTy, DAG.getConstant(1, DL, VecTy),
1504 return DAG.getNode(Opc, DL, VecTy, Op->getOperand(1), Exp2Imm);
1517 return DAG.getNode(ISD::AND, DL, ResTy, Vec, SplatVec);
1524 SDValue Bit = DAG.getNode(ISD::SHL, DL, ResTy, One, truncateVecElts(Op, DAG));
1526 return DAG.getNode(ISD::AND, DL, ResTy, Op->getOperand(1),
1537 return DAG.getNode(ISD::AND, DL, ResTy, Op->getOperand(1), BitMask);
1583 return DAG.getNode(ISD::ADD, DL, Op->getValueType(0), Op->getOperand(1),
1589 return DAG.getNode(ISD::ADD, DL, Op->getValueType(0), Op->getOperand(1),
1592 return DAG.getNode(ISD::AND, DL, Op->getValueType(0), Op->getOperand(1),
1595 return DAG.getNode(ISD::AND, DL, Op->getValueType(0), Op->getOperand(1),
1658 return DAG.getNode(ISD::XOR, DL, VecTy, Op->getOperand(1),
1659 DAG.getNode(ISD::SHL, DL, VecTy, One,
1694 return DAG.getNode(ISD::OR, DL, VecTy, Op->getOperand(1),
1695 DAG.getNode(ISD::SHL, DL, VecTy, One,
1784 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(Op),
1802 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(Op),
1810 return DAG.getNode(ISD::SDIV, DL, Op->getValueType(0), Op->getOperand(1),
1816 return DAG.getNode(ISD::UDIV, DL, Op->getValueType(0), Op->getOperand(1),
1821 return DAG.getNode(ISD::FADD, DL, Op->getValueType(0), Op->getOperand(1),
1867 return DAG.getNode(ISD::FDIV, DL, Op->getValueType(0), Op->getOperand(1),
1893 return DAG.getNode(
1907 return DAG.getNode(ISD::FMUL, DL, Op->getValueType(0), Op->getOperand(1),
1924 return DAG.getNode(ISD::FSUB, DL, Op->getValueType(0), Op->getOperand(1),
1938 return DAG.getNode(MipsISD::ILVEV, DL, Op->getValueType(0),
1944 return DAG.getNode(MipsISD::ILVL, DL, Op->getValueType(0),
1950 return DAG.getNode(MipsISD::ILVOD, DL, Op->getValueType(0),
1956 return DAG.getNode(MipsISD::ILVR, DL, Op->getValueType(0),
1992 return DAG.getNode(ISD::ADD, SDLoc(Op), ResTy, Op->getOperand(1),
1993 DAG.getNode(ISD::SHL, SDLoc(Op), ResTy,
2001 return DAG.getNode(ISD::ADD, SDLoc(Op), ResTy, Op->getOperand(1),
2002 DAG.getNode(ISD::MUL, SDLoc(Op), ResTy,
2009 return DAG.getNode(ISD::SMAX, DL, Op->getValueType(0),
2015 return DAG.getNode(ISD::UMAX, DL, Op->getValueType(0),
2021 return DAG.getNode(ISD::SMAX, DL, Op->getValueType(0),
2027 return DAG.getNode(ISD::UMAX, DL, Op->getValueType(0),
2033 return DAG.getNode(ISD::SMIN, DL, Op->getValueType(0),
2039 return DAG.getNode(ISD::UMIN, DL, Op->getValueType(0),
2045 return DAG.getNode(ISD::SMIN, DL, Op->getValueType(0),
2051 return DAG.getNode(ISD::UMIN, DL, Op->getValueType(0),
2057 return DAG.getNode(ISD::SREM, DL, Op->getValueType(0), Op->getOperand(1),
2063 return DAG.getNode(ISD::UREM, DL, Op->getValueType(0), Op->getOperand(1),
2069 return DAG.getNode(ISD::MUL, DL, Op->getValueType(0), Op->getOperand(1),
2076 return DAG.getNode(ISD::SUB, SDLoc(Op), ResTy, Op->getOperand(1),
2077 DAG.getNode(ISD::MUL, SDLoc(Op), ResTy,
2086 SDValue Res = DAG.getNode(ISD::OR, DL, Op->getValueType(0),
2091 SDValue Res = DAG.getNode(ISD::OR, DL, Op->getValueType(0),
2097 return DAG.getNode(ISD::OR, DL, Op->getValueType(0), Op->getOperand(1),
2100 return DAG.getNode(ISD::OR, DL, Op->getValueType(0),
2106 return DAG.getNode(MipsISD::PCKEV, DL, Op->getValueType(0),
2112 return DAG.getNode(MipsISD::PCKOD, DL, Op->getValueType(0),
2151 return DAG.getNode(MipsISD::SHF, DL, Op->getValueType(0),
2176 return DAG.getNode(ISD::SHL, DL, Op->getValueType(0), Op->getOperand(1),
2182 return DAG.getNode(ISD::SHL, DL, Op->getValueType(0),
2206 return DAG.getNode(ISD::SRA, DL, Op->getValueType(0), Op->getOperand(1),
2212 return DAG.getNode(ISD::SRA, DL, Op->getValueType(0),
2236 return DAG.getNode(ISD::SRL, DL, Op->getValueType(0), Op->getOperand(1),
2242 return DAG.getNode(ISD::SRL, DL, Op->getValueType(0),
2266 return DAG.getNode(ISD::SUB, DL, Op->getValueType(0), Op->getOperand(1),
2272 return DAG.getNode(ISD::SUB, DL, Op->getValueType(0),
2281 return DAG.getNode(ISD::XOR, DL, Op->getValueType(0), Op->getOperand(1),
2284 return DAG.getNode(ISD::XOR, DL, Op->getValueType(0),
2308 Address = DAG.getNode(ISD::ADD, DL, PtrTy, Address, Offset);
2382 Address = DAG.getNode(ISD::ADD, DL, PtrTy, Address, Offset);
2598 return DAG.getNode(MipsISD::SHF, DL, ResTy,
2694 return DAG.getNode(MipsISD::ILVEV, SDLoc(Op), ResTy, Ws, Wt);
2740 return DAG.getNode(MipsISD::ILVOD, SDLoc(Op), ResTy, Wt, Ws);
2787 return DAG.getNode(MipsISD::ILVR, SDLoc(Op), ResTy, Ws, Wt);
2836 return DAG.getNode(MipsISD::ILVL, SDLoc(Op), ResTy, Ws, Wt);
2879 return DAG.getNode(MipsISD::PCKEV, SDLoc(Op), ResTy, Ws, Wt);
2922 return DAG.getNode(MipsISD::PCKOD, SDLoc(Op), ResTy, Ws, Wt);
lib/Target/NVPTX/NVPTXISelLowering.cpp 1216 return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, DL, VT,
1241 return DAG.getNode(
1608 SDValue srcAddr = DAG.getNode(ISD::ADD, dl, PtrVT, OutVals[OIdx],
1900 Ops.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, SubOp,
1948 SDValue E0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Vector,
1950 SDValue E1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, Vector,
1980 SDValue Hi = DAG.getNode(Opc, dl, VT, ShOpHi, ShAmt);
1996 SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
1999 SDValue Tmp1 = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, ShAmt);
2000 SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32, ShAmt,
2002 SDValue Tmp2 = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, RevShAmt);
2003 SDValue FalseVal = DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
2004 SDValue TrueVal = DAG.getNode(Opc, dl, VT, ShOpHi, ExtraShAmt);
2009 SDValue Hi = DAG.getNode(Opc, dl, VT, ShOpHi, ShAmt);
2042 SDValue Lo = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ShAmt);
2056 SDValue RevShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32,
2059 SDValue Tmp1 = DAG.getNode(ISD::SHL, dl, VT, ShOpHi, ShAmt);
2060 SDValue ExtraShAmt = DAG.getNode(ISD::SUB, dl, MVT::i32, ShAmt,
2062 SDValue Tmp2 = DAG.getNode(ISD::SRL, dl, VT, ShOpLo, RevShAmt);
2063 SDValue FalseVal = DAG.getNode(ISD::OR, dl, VT, Tmp1, Tmp2);
2064 SDValue TrueVal = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ExtraShAmt);
2069 SDValue Lo = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, ShAmt);
2107 SDValue Sign = DAG.getNode(ISD::AND, SL, MVT::i32, Bitcast,
2111 DAG.getNode(ISD::OR, SL, MVT::i32, Sign,
2115 SDValue AdjustedA = DAG.getNode(ISD::FADD, SL, VT, A, PointFiveWithSign);
2146 SDValue AdjustedA = DAG.getNode(ISD::FADD, SL, VT, AbsA,
2159 RoundedA = DAG.getNode(ISD::FCOPYSIGN, SL, VT, RoundedA, A);
2374 SDValue E0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f16, Val,
2376 SDValue E1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f16, Val,
2378 SDValue V2 = DAG.getNode(ISD::BUILD_VECTOR, DL, MVT::v2f16, E0, E1);
2384 SDValue ExtVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, Val,
2587 DAG.getNode(ISD::ADD, dl, PtrVT, Arg,
2599 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, LoadVT, P,
4561 return DAG.getNode(ISD::SUB, DL, VT, Num,
4562 DAG.getNode(ISD::MUL, DL, VT,
4563 DAG.getNode(DivOpc, DL, VT, Num, Den),
4705 return DCI.DAG.getNode(Opc, DL, MulType, TruncLHS, TruncRHS);
4751 return DCI.DAG.getNode(ISD::BUILD_VECTOR, DL, CCType, CCNode.getValue(0),
4885 SDValue E0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, SubVector,
4887 SDValue E1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, SubVector,
lib/Target/PowerPC/PPCISelDAGToDAG.cpp 5432 Res = CurDAG->getNode(PPCISD::CMPB, dl, VT, LHS, RHS);
5437 Res = CurDAG->getNode(ISD::AND, dl, VT, Res,
5446 Res = CurDAG->getNode(ISD::AND, dl, VT, Res,
5448 Res = CurDAG->getNode(ISD::XOR, dl, VT, Res,
lib/Target/PowerPC/PPCISelLowering.cpp 2668 SDValue Hi = DAG.getNode(PPCISD::Hi, DL, PtrVT, HiPart, Zero);
2669 SDValue Lo = DAG.getNode(PPCISD::Lo, DL, PtrVT, LoPart, Zero);
2673 Hi = DAG.getNode(ISD::ADD, DL, PtrVT,
2678 return DAG.getNode(ISD::ADD, DL, PtrVT, Hi, Lo);
2866 SDValue Hi = DAG.getNode(PPCISD::Hi, dl, PtrVT, TGAHi, TLSReg);
2867 return DAG.getNode(PPCISD::Lo, dl, PtrVT, TGALo, Hi);
2878 GOTPtr = DAG.getNode(PPCISD::ADDIS_GOT_TPREL_HA, dl,
2888 SDValue TPOffset = DAG.getNode(PPCISD::LD_GOT_TPREL_L, dl,
2890 return DAG.getNode(PPCISD::ADD_TLS, dl, PtrVT, TPOffset, TGATLS);
2899 GOTPtr = DAG.getNode(PPCISD::ADDIS_TLSGD_HA, dl, PtrVT,
2917 GOTPtr = DAG.getNode(PPCISD::ADDIS_TLSLD_HA, dl, PtrVT,
2927 SDValue DtvOffsetHi = DAG.getNode(PPCISD::ADDIS_DTPREL_HA, dl,
2929 return DAG.getNode(PPCISD::ADDI_DTPREL_L, dl, PtrVT, DtvOffsetHi, TGA);
3022 SDValue Sub = DAG.getNode(ISD::XOR, dl, LHSVT, Op.getOperand(0),
3047 SDValue GprAnd = DAG.getNode(ISD::AND, dl, MVT::i32, GprIndex,
3051 SDValue GprIndexPlusOne = DAG.getNode(ISD::ADD, dl, MVT::i32, GprIndex,
3059 SDValue FprPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
3067 SDValue RegSaveAreaPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
3070 SDValue OverflowAreaPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAListPtr,
3087 SDValue RegConstant = DAG.getNode(ISD::MUL, dl, MVT::i32,
3093 SDValue OurReg = DAG.getNode(ISD::ADD, dl, PtrVT, RegSaveArea,
3098 OurReg = DAG.getNode(ISD::ADD, dl, PtrVT, OurReg,
3102 SDValue IndexPlus1 = DAG.getNode(ISD::ADD, dl, MVT::i32,
3115 SDValue OverflowAreaPlusN = DAG.getNode(ISD::ADD, dl, PtrVT, OverflowArea,
3243 SDValue nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, Op.getOperand(1),
3251 nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, nextPtr, ConstStackOffset);
3257 nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, nextPtr, ConstFrameOffset);
3540 ArgValue = DAG.getNode(PPCISD::BUILD_SPE64, dl, MVT::f64, ArgValueLo,
3644 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
3664 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
3681 ArgVal = DAG.getNode(ISD::AssertSext, dl, MVT::i64, ArgVal,
3684 ArgVal = DAG.getNode(ISD::AssertZext, dl, MVT::i64, ArgVal,
3835 Arg = DAG.getNode(ISD::ADD, dl, ArgOff.getValueType(), Arg, ArgOff);
3881 Addr = DAG.getNode(ISD::ADD, dl, Off.getValueType(), Addr, Off);
3964 ArgVal = DAG.getNode(ISD::SRL, dl, MVT::i64, ArgVal,
4092 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
4452 FIN = DAG.getNode(ISD::ADD, dl, PtrOff.getValueType(), FIN, PtrOff);
4898 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr,
5071 SDValue AddPtr = DAG.getNode(ISD::ADD, dl, MVT::i64, Callee, PtrOff);
5077 SDValue AddTOC = DAG.getNode(ISD::ADD, dl, MVT::i64, Callee, TOCOff);
5185 Val = DAG.getNode(PPCISD::BUILD_SPE64, dl, MVT::f64, Lo, Hi);
5200 Val = DAG.getNode(ISD::AssertZext, dl, VA.getLocVT(), Val,
5205 Val = DAG.getNode(ISD::AssertSext, dl, VA.getLocVT(), Val,
5297 SDValue AddTOC = DAG.getNode(ISD::ADD, dl, MVT::i64, StackPtr, TOCOff);
5548 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(MF.getDataLayout()),
5584 SDValue SVal = DAG.getNode(PPCISD::EXTRACT_SPE, dl, MVT::i32, Arg,
5587 SVal = DAG.getNode(PPCISD::EXTRACT_SPE, dl, MVT::i32, Arg,
5600 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(MF.getDataLayout()),
5895 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
5951 AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const);
5990 AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const);
6011 SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
6105 ArgVal = DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
6112 ArgVal = DAG.getNode(ISD::SHL, dl, MVT::i64, ArgVal,
6131 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, ConstFour);
6188 SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
6244 SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
6296 SDValue AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
6467 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr, PtrOff);
6495 SDValue AddPtr = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, Const);
6515 SDValue AddArg = DAG.getNode(ISD::ADD, dl, PtrVT, Arg, Const);
6566 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff, ConstFour);
6608 PtrOff = DAG.getNode(ISD::ADD, dl, PtrVT, StackPtr,
6623 SDValue Ix = DAG.getNode(ISD::ADD, dl, PtrVT, PtrOff,
6927 DAG.getNode(PPCISD::EXTRACT_SPE, dl, MVT::i32, Arg,
6931 SVal = DAG.getNode(PPCISD::EXTRACT_SPE, dl, MVT::i32, Arg,
7070 SDValue NegSize = DAG.getNode(ISD::SUB, dl, PtrVT,
7102 return DAG.getNode(PPCISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
7252 return DAG.getNode(PPCISD::XSMAXCDP, dl, Op.getValueType(), LHS, RHS);
7255 return DAG.getNode(PPCISD::XSMINCDP, dl, Op.getValueType(), LHS, RHS);
7309 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS, Flags);
7319 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS, Flags);
7325 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, LHS, RHS, Flags);
7331 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, RHS, LHS, Flags);
7337 Cmp = DAG.getNode(ISD::FSUB, dl, CmpVT, RHS, LHS, Flags);
7395 FIPtr = DAG.getNode(ISD::ADD, dl, FIPtr.getValueType(), FIPtr,
7452 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl,
7455 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl,
7460 SDValue Res = DAG.getNode(PPCISD::FADDRTZ, dl, MVT::f64, Lo, Hi);
7472 SDValue True = DAG.getNode(ISD::FSUB, dl, MVT::ppcf128,
7475 True = DAG.getNode(ISD::ADD, dl, MVT::i32, True,
7531 RLI.Ptr = DAG.getNode(ISD::ADD, dl, RLI.Ptr.getValueType(), RLI.Ptr,
7559 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
7689 Extend = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, IntermediateVT, Arrange,
7726 Value = DAG.getNode(ISD::FP_ROUND, dl,
7783 SDValue Round = DAG.getNode(ISD::AND, dl, MVT::i64,
7785 Round = DAG.getNode(ISD::ADD, dl, MVT::i64,
7787 Round = DAG.getNode(ISD::OR, dl, MVT::i64, Round, SINT);
7788 Round = DAG.getNode(ISD::AND, dl, MVT::i64,
7799 SDValue Cond = DAG.getNode(ISD::SRA, dl, MVT::i64,
7801 Cond = DAG.getNode(ISD::ADD, dl, MVT::i64,
7876 FP = DAG.getNode(ISD::FP_ROUND, dl,
7949 FP = DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, FP,
7995 SDValue Addr = DAG.getNode(ISD::ADD, dl, PtrVT, StackSlot, Four);
8000 DAG.getNode(ISD::AND, dl, MVT::i32,
8003 DAG.getNode(ISD::SRL, dl, MVT::i32,
8004 DAG.getNode(ISD::AND, dl, MVT::i32,
8005 DAG.getNode(ISD::XOR, dl, MVT::i32,
8011 DAG.getNode(ISD::XOR, dl, MVT::i32, CWD1, CWD2);
8032 SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
8034 SDValue Tmp2 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Amt);
8035 SDValue Tmp3 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Tmp1);
8036 SDValue Tmp4 = DAG.getNode(ISD::OR , dl, VT, Tmp2, Tmp3);
8037 SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
8039 SDValue Tmp6 = DAG.getNode(PPCISD::SHL, dl, VT, Lo, Tmp5);
8040 SDValue OutHi = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp6);
8041 SDValue OutLo = DAG.getNode(PPCISD::SHL, dl, VT, Lo, Amt);
8061 SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
8063 SDValue Tmp2 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Amt);
8064 SDValue Tmp3 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Tmp1);
8065 SDValue Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
8066 SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
8068 SDValue Tmp6 = DAG.getNode(PPCISD::SRL, dl, VT, Hi, Tmp5);
8069 SDValue OutLo = DAG.getNode(ISD::OR, dl, VT, Tmp4, Tmp6);
8070 SDValue OutHi = DAG.getNode(PPCISD::SRL, dl, VT, Hi, Amt);
8089 SDValue Tmp1 = DAG.getNode(ISD::SUB, dl, AmtVT,
8091 SDValue Tmp2 = DAG.getNode(PPCISD::SRL, dl, VT, Lo, Amt);
8092 SDValue Tmp3 = DAG.getNode(PPCISD::SHL, dl, VT, Hi, Tmp1);
8093 SDValue Tmp4 = DAG.getNode(ISD::OR, dl, VT, Tmp2, Tmp3);
8094 SDValue Tmp5 = DAG.getNode(ISD::ADD, dl, AmtVT, Amt,
8096 SDValue Tmp6 = DAG.getNode(PPCISD::SRA, dl, VT, Hi, Tmp5);
8097 SDValue OutHi = DAG.getNode(PPCISD::SRA, dl, VT, Hi, Amt);
8135 return DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, DestVT,
8240 return DAG.getNode(PPCISD::BUILD_FP128, dl, MVT::f128, Op0.getOperand(0),
8323 Idx = DAG.getNode(ISD::ADD, dl, FIdx.getValueType(), FIdx, Idx);
8358 LoadedVect = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f64,
8480 SDValue RetVal = DAG.getNode(PPCISD::VADD_SPLAT, dl, VT, Elt, EltSize);
8499 Res = DAG.getNode(ISD::XOR, dl, MVT::v4i32, Res, OnesV);
8913 BasePtr = DAG.getNode(ISD::ADD, dl, getPointerTy(DAG.getDataLayout()),
9009 SDValue Splat = DAG.getNode(PPCISD::XXSPLT, dl, MVT::v4i32, Conv,
9039 return DAG.getNode(PPCISD::QVESPLATI, dl, VT, V1,
9482 SDValue Flags = DAG.getNode(PPCISD::MFOCRF, dl, MVT::i32,
9506 Flags = DAG.getNode(ISD::SRL, dl, MVT::i32, Flags,
9509 Flags = DAG.getNode(ISD::AND, dl, MVT::i32, Flags,
9514 Flags = DAG.getNode(ISD::XOR, dl, MVT::i32, Flags,
9557 Op = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2i64, Op.getOperand(0),
9565 Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Op,
9591 DAG.getNode(ISD::AND, dl, MVT::i32, CmpOp,
9676 Value = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f64,
9699 Idx = DAG.getNode(ISD::ADD, dl, FIdx.getValueType(), FIdx, Idx);
9756 BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
9782 Idx = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr, Idx);
9822 SDValue Ex = DAG.getNode(
9845 BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
9876 Value = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::v4f64,
9900 Idx = DAG.getNode(ISD::ADD, dl, FIdx.getValueType(), FIdx, Idx);
9912 Idx = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr, Idx);
9951 return DAG.getNode(ISD::ADD, dl, MVT::v4i32, LoProd, HiProd);
10018 SDValue Y = DAG.getNode(ISD::SUB, dl, VT, Zero, X);
10072 return DAG.getNode(PPCISD::FP_EXTEND_HALF, dl, MVT::v2f64,
10092 DAG.getNode(Op0.getOpcode(), SDLoc(Op0), MVT::v4f32, NewLoad[0],
10094 return DAG.getNode(PPCISD::FP_EXTEND_HALF, dl, MVT::v2f64, NewOp,
10103 return DAG.getNode(PPCISD::FP_EXTEND_HALF, dl, MVT::v2f64, NewLd,
11947 auto Op0 = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, N->getOperand(0),
11949 auto Op1 = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, N->getOperand(1),
11957 auto SubNode = DAG.getNode(ISD::SUB, DL, MVT::i64, Op0, Op1);
11961 auto Shifted = DAG.getNode(ISD::SRL, DL, MVT::i64, SubNode,
11967 Final = DAG.getNode(ISD::XOR, DL, MVT::i64, Shifted,
12563 return DAG.getNode(ISD::AND, dl, N->getValueType(0), N->getOperand(0),
12573 return DAG.getNode(
12575 DAG.getNode(ISD::SHL, dl, N->getValueType(0), N->getOperand(0), ShiftCst),
12602 SDValue Add = DAG.getNode(ISD::ADD, DL, OpVT, LHS, RHS.getOperand(1));
12683 SDValue Trunc = DAG.getNode(ISD::FP_ROUND, dl,
13009 return DAG.getNode(NodeType, dl, MVT::v2f64,
13106 FP = DAG.getNode(ISD::FP_ROUND, dl,
13455 BSwapOp = DAG.getNode(ISD::SRL, dl, Op1VT, BSwapOp,
13586 DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
13596 DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(),
13724 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr, Increment);
13735 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
13754 DAG.getNode(ISD::FP_ROUND, dl, VT, Perm, // QPX
13983 return DAG.getNode(PPCISD::BDNZ, dl, MVT::Other,
14023 return DAG.getNode(isBDNZ ? PPCISD::BDNZ : PPCISD::BDZ, dl, MVT::Other,
14042 return DAG.getNode(ISD::BR, dl, MVT::Other,
14112 SDValue Op = DAG.getNode(PPCISD::SRA_ADDZE, DL, VT, N0, ShiftAmt);
14116 Op = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Op);
14530 DAG.getNode(ISD::ADD, dl, PtrVT, FrameAddr, Offset),
15127 return DAG.getNode(TargetOpcode, SDLoc(N), VT, N0, N1->getOperand(0));
15158 return DCI.DAG.getNode(PPCISD::EXTSWSLI, DL, MVT::i64, N0->getOperand(0),
15235 SDValue Add = DAG.getNode(ISD::ADD, DL, MVT::i64, Z,
15250 SDValue Add = DAG.getNode(ISD::ADD, DL, MVT::i64, Z,
15315 return DCI.DAG.getNode(
15375 DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
15377 SDValue Res = DAG.getNode(ISD::ADD, DL, VT, Op0, Op1);
15382 return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Res);
15392 DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
15396 return DAG.getNode(ISD::SUB, DL, VT, Op1, Op0);
15398 return DAG.getNode(ISD::SUB, DL, VT, Op0, Op1);
lib/Target/RISCV/RISCVISelLowering.cpp 484 return DAG.getNode(ISD::ADD, DL, Ty, Addr,
522 return DAG.getNode(ISD::ADD, DL, Ty, Load, TPReg);
608 return DAG.getNode(ISD::ADD, DL, Ty, Addr,
683 SDValue Ptr = DAG.getNode(ISD::ADD, DL, VT, FrameAddr,
711 DAG.getNode(ISD::ADD, DL, VT, FrameAddr, Offset),
740 SDValue ShamtMinusXLen = DAG.getNode(ISD::ADD, DL, VT, Shamt, MinusXLen);
741 SDValue XLenMinus1Shamt = DAG.getNode(ISD::SUB, DL, VT, XLenMinus1, Shamt);
743 SDValue LoTrue = DAG.getNode(ISD::SHL, DL, VT, Lo, Shamt);
744 SDValue ShiftRight1Lo = DAG.getNode(ISD::SRL, DL, VT, Lo, One);
746 DAG.getNode(ISD::SRL, DL, VT, ShiftRight1Lo, XLenMinus1Shamt);
747 SDValue ShiftLeftHi = DAG.getNode(ISD::SHL, DL, VT, Hi, Shamt);
748 SDValue HiTrue = DAG.getNode(ISD::OR, DL, VT, ShiftLeftHi, ShiftRightLo);
749 SDValue HiFalse = DAG.getNode(ISD::SHL, DL, VT, Lo, ShamtMinusXLen);
790 SDValue ShamtMinusXLen = DAG.getNode(ISD::ADD, DL, VT, Shamt, MinusXLen);
791 SDValue XLenMinus1Shamt = DAG.getNode(ISD::SUB, DL, VT, XLenMinus1, Shamt);
793 SDValue ShiftRightLo = DAG.getNode(ISD::SRL, DL, VT, Lo, Shamt);
794 SDValue ShiftLeftHi1 = DAG.getNode(ISD::SHL, DL, VT, Hi, One);
796 DAG.getNode(ISD::SHL, DL, VT, ShiftLeftHi1, XLenMinus1Shamt);
797 SDValue LoTrue = DAG.getNode(ISD::OR, DL, VT, ShiftRightLo, ShiftLeftHi);
798 SDValue HiTrue = DAG.getNode(ShiftRightOp, DL, VT, Hi, Shamt);
799 SDValue LoFalse = DAG.getNode(ShiftRightOp, DL, VT, Hi, ShamtMinusXLen);
801 IsSRA ? DAG.getNode(ISD::SRA, DL, VT, Hi, XLenMinus1) : Zero;
843 SDValue NewRes = DAG.getNode(WOpcode, DL, MVT::i64, NewOp0, NewOp1);
854 SDValue NewWOp = DAG.getNode(N->getOpcode(), DL, MVT::i64, NewOp0, NewOp1);
855 SDValue NewRes = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, MVT::i64, NewWOp,
963 SDValue NewHi = DAG.getNode(ISD::XOR, DL, MVT::i32, Hi,
968 SDValue NewHi = DAG.getNode(ISD::AND, DL, MVT::i32, Hi,
1009 DAG.getNode(ISD::XOR, DL, MVT::i64, NewFMV,
1014 DAG.getNode(ISD::AND, DL, MVT::i64, NewFMV,
1804 return DAG.getNode(RISCVISD::BuildPairF64, DL, MVT::f64, Lo, Hi);
1932 SDValue Address = DAG.getNode(ISD::ADD, DL, PtrVT, ArgValue,
2209 SDValue Address = DAG.getNode(ISD::ADD, DL, PtrVT, SpillSlot,
2237 DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr,
2349 RetValue = DAG.getNode(RISCVISD::BuildPairF64, DL, MVT::f64, RetValue,
lib/Target/Sparc/SparcISelLowering.cpp 244 SDValue Part0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32,
247 SDValue Part1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::i32,
340 OutVal = DAG.getNode(ISD::SHL, DL, MVT::i64, OutVal,
347 OutVal = DAG.getNode(ISD::OR, DL, MVT::i64, OutVal, NV);
443 DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, LoVal, HiVal);
454 Arg = DAG.getNode(ISD::AssertSext, dl, MVT::i32, Arg,
499 DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, LoVal, HiVal);
531 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
606 Arg = DAG.getNode(ISD::SRL, DL, VA.getLocVT(), Arg,
613 Arg = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), Arg,
617 Arg = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), Arg,
824 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
845 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
861 SDValue Part0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
864 SDValue Part1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
879 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
888 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
893 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
918 PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
1173 HiPtrOff = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr, HiPtrOff);
1175 LoPtrOff = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr, LoPtrOff);
1195 Arg = DAG.getNode(ISD::SHL, DL, MVT::i64, Arg,
1204 Arg = DAG.getNode(ISD::OR, DL, MVT::i64, Arg, NV);
1222 PtrOff = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr, PtrOff);
1322 RV = DAG.getNode(ISD::SRL, DL, VA.getLocVT(), RV,
1329 RV = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), RV,
1333 RV = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), RV,
1936 return DAG.getNode(ISD::ADD, DL, VT, Hi, Lo);
1962 SDValue AbsAddr = DAG.getNode(ISD::ADD, DL, VT, GlobalBase, Idx);
1983 H44 = DAG.getNode(ISD::SHL, DL, VT, H44, DAG.getConstant(12, DL, MVT::i32));
1986 return DAG.getNode(ISD::ADD, DL, VT, H44, L44);
1992 Hi = DAG.getNode(ISD::SHL, DL, VT, Hi, DAG.getConstant(32, DL, MVT::i32));
1995 return DAG.getNode(ISD::ADD, DL, VT, Hi, Lo);
2080 HiLo = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo);
2099 SDValue Ptr = DAG.getNode(ISD::ADD, DL, PtrVT, Base, TGA);
2100 SDValue Offset = DAG.getNode(SPISD::TLS_LD,
2114 SDValue Offset = DAG.getNode(ISD::XOR, DL, PtrVT, Hi, Lo);
2116 return DAG.getNode(ISD::ADD, DL, PtrVT,
2244 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2248 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2251 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2256 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2261 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2266 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2272 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2277 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2281 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2284 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2288 Result = DAG.getNode(ISD::AND, DL, Result.getValueType(), Result, Mask);
2291 return DAG.getNode(SPISD::CMPICC, DL, MVT::Glue, Result, RHS);
2445 CompareFlag = DAG.getNode(SPISD::CMPICC, dl, MVT::Glue, LHS, RHS);
2455 CompareFlag = DAG.getNode(SPISD::CMPFCC, dl, MVT::Glue, LHS, RHS);
2481 CompareFlag = DAG.getNode(SPISD::CMPICC, dl, MVT::Glue, LHS, RHS);
2491 CompareFlag = DAG.getNode(SPISD::CMPFCC, dl, MVT::Glue, LHS, RHS);
2513 DAG.getNode(ISD::ADD, DL, PtrVT, DAG.getRegister(SP::I6, PtrVT),
2531 SDValue NextPtr = DAG.getNode(ISD::ADD, DL, PtrVT, VAList,
2588 Size = DAG.getNode(ISD::ADD, dl, VT, Size,
2595 SDValue NewSP = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
2600 SDValue NewVal = DAG.getNode(ISD::ADD, dl, VT, NewSP,
2636 SDValue Ptr = DAG.getNode(ISD::ADD, dl, VT, FrameAddr,
2641 FrameAddr = DAG.getNode(ISD::ADD, dl, VT, FrameAddr,
2682 SDValue Ptr = DAG.getNode(ISD::ADD,
2740 SDValue LoPtr = DAG.getNode(ISD::ADD, dl, addrVT,
2808 SDValue LoPtr = DAG.getNode(ISD::ADD, dl, addrVT,
2889 SDValue Src1Hi = DAG.getNode(ISD::SRL, dl, MVT::i64, Src1,
2895 SDValue Src2Hi = DAG.getNode(ISD::SRL, dl, MVT::i64, Src2,
2922 Hi = DAG.getNode(ISD::SHL, dl, MVT::i64, Hi,
2925 SDValue Dst = DAG.getNode(ISD::OR, dl, MVT::i64, Hi, Lo);
2950 SDValue HiLHS = DAG.getNode(ISD::SRA, dl, VT, LHS, ShiftAmt);
2951 SDValue HiRHS = DAG.getNode(ISD::SRA, dl, MVT::i64, RHS, ShiftAmt);
2959 SDValue BottomHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT,
2961 SDValue TopHalf = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, VT,
2964 SDValue Tmp1 = DAG.getNode(ISD::SRA, dl, VT, BottomHalf, ShiftAmt);
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp 1005 SDValue New = CurDAG->getNode(ISD::AND, DL, VT, In, Mask);
1115 Upper = CurDAG->getNode(Opcode, DL, VT, Op0, Upper);
1136 SDValue Or = CurDAG->getNode(Opcode, DL, VT, Upper, Lower);
1846 Result = CurDAG->getNode(ISD::XOR, DL, MVT::i32, Result,
1850 Result = CurDAG->getNode(ISD::ADD, DL, MVT::i32, Result,
1856 Result = CurDAG->getNode(ShiftOp, DL, MVT::i32, Result,
1864 Result = CurDAG->getNode(ISD::SRL, DL, VT, Result,
1866 Result = CurDAG->getNode(ISD::AND, DL, VT, Result,
1872 Result = CurDAG->getNode(ISD::SHL, DL, VT, Result,
1874 Result = CurDAG->getNode(ISD::SRA, DL, VT, Result,
lib/Target/SystemZ/SystemZISelLowering.cpp 1246 Value = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), Value,
1249 Value = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), Value,
1284 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VA.getLocVT(), Value,
1369 FIN = DAG.getNode(ISD::ADD, DL, PtrVT, FIN,
1387 SDValue Address = DAG.getNode(ISD::ADD, DL, PtrVT, ArgValue,
1519 SDValue Address = DAG.getNode(ISD::ADD, DL, PtrVT, SpillSlot,
1543 SDValue Address = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr,
2559 return DAG.getNode(C.Opcode, DL, MVT::i32, C.Op0, C.Op1);
2570 SDValue Mul = DAG.getNode(ISD::MUL, DL, MVT::i64, Op0, Op1);
2571 Hi = DAG.getNode(ISD::SRL, DL, MVT::i64, Mul,
2584 SDValue Result = DAG.getNode(Opcode, DL, MVT::Untyped, Op0, Op1);
2671 SDValue HRes = DAG.getNode(Opcode, DL, MVT::v2i64, H0, H1);
2672 SDValue LRes = DAG.getNode(Opcode, DL, MVT::v2i64, L0, L1);
2673 return DAG.getNode(SystemZISD::PACK, DL, VT, HRes, LRes);
2675 return DAG.getNode(Opcode, DL, VT, CmpOp0, CmpOp1);
2697 Cmp = DAG.getNode(ISD::OR, DL, VT, LT, GE);
2709 Cmp = DAG.getNode(ISD::OR, DL, VT, LT, GT);
2731 Cmp = DAG.getNode(ISD::XOR, DL, VT, Cmp, Mask);
2783 Op = DAG.getNode(ISD::SUB, DL, Op.getValueType(),
2840 Result = DAG.getNode(SystemZISD::PCREL_OFFSET, DL, PtrVT, Full, Result);
2853 Result = DAG.getNode(ISD::ADD, DL, PtrVT, Result,
2920 SDValue TPHiShifted = DAG.getNode(ISD::SHL, DL, PtrVT, TPHi,
2922 return DAG.getNode(ISD::OR, DL, PtrVT, TPHiShifted, TPLo);
2982 Offset = DAG.getNode(ISD::ADD, DL, PtrVT, Offset, DTPOffset);
3011 return DAG.getNode(ISD::ADD, DL, PtrVT, TP, Offset);
3132 In64 = DAG.getNode(ISD::SHL, DL, MVT::i64, In64,
3147 SDValue Shift = DAG.getNode(ISD::SRL, DL, MVT::i64, Out64,
3181 FieldAddr = DAG.getNode(ISD::ADD, DL, PtrVT, FieldAddr,
3239 NeededSpace = DAG.getNode(ISD::ADD, DL, MVT::i64, NeededSpace,
3243 SDValue NewSP = DAG.getNode(ISD::SUB, DL, MVT::i64, OldSP, NeededSpace);
3252 SDValue Result = DAG.getNode(ISD::ADD, DL, MVT::i64, NewSP, ArgAdjust);
3257 DAG.getNode(ISD::ADD, DL, MVT::i64, Result,
3260 DAG.getNode(ISD::AND, DL, MVT::i64, Result,
3311 SDValue LH = DAG.getNode(ISD::SRA, DL, VT, LL, C63);
3312 SDValue RH = DAG.getNode(ISD::SRA, DL, VT, RL, C63);
3318 SDValue NegLLTimesRH = DAG.getNode(ISD::AND, DL, VT, LL, RH);
3319 SDValue NegLHTimesRL = DAG.getNode(ISD::AND, DL, VT, LH, RL);
3320 SDValue NegSum = DAG.getNode(ISD::ADD, DL, VT, NegLLTimesRH, NegLHTimesRL);
3321 Ops[1] = DAG.getNode(ISD::SUB, DL, VT, Ops[1], NegSum);
3562 SDValue Tmp = DAG.getNode(SystemZISD::VSHL_BY_SCALAR, DL, VT, Op, Shift);
3563 Op = DAG.getNode(ISD::ADD, DL, VT, Op, Tmp);
3564 Op = DAG.getNode(SystemZISD::VSRL_BY_SCALAR, DL, VT, Op, Shift);
3570 Op = DAG.getNode(SystemZISD::VSUM, DL, VT, Op, Tmp);
3576 Op = DAG.getNode(SystemZISD::VSUM, DL, MVT::v4i32, Op, Tmp);
3577 Op = DAG.getNode(SystemZISD::VSUM, DL, VT, Op, Tmp);
3605 SDValue Tmp = DAG.getNode(ISD::SHL, DL, VT, Op, DAG.getConstant(I, DL, VT));
3607 Tmp = DAG.getNode(ISD::AND, DL, VT, Tmp,
3609 Op = DAG.getNode(ISD::ADD, DL, VT, Op, Tmp);
3614 Op = DAG.getNode(ISD::SRL, DL, VT, Op,
3694 SDValue AlignedAddr = DAG.getNode(ISD::AND, DL, PtrVT, Addr,
3699 SDValue BitShift = DAG.getNode(ISD::SHL, DL, PtrVT, Addr,
3705 SDValue NegBitShift = DAG.getNode(ISD::SUB, DL, WideVT,
3714 Src2 = DAG.getNode(ISD::SHL, DL, WideVT, Src2,
3718 Src2 = DAG.getNode(ISD::OR, DL, WideVT, Src2,
3730 SDValue ResultShift = DAG.getNode(ISD::ADD, DL, WideVT, BitShift,
3732 SDValue Result = DAG.getNode(ISD::ROTL, DL, WideVT, AtomicOp, ResultShift);
3760 NegSrc2 = DAG.getNode(ISD::SUB, DL, MemVT, DAG.getConstant(0, DL, MemVT),
3810 SDValue AlignedAddr = DAG.getNode(ISD::AND, DL, PtrVT, Addr,
3815 SDValue BitShift = DAG.getNode(ISD::SHL, DL, PtrVT, Addr,
3821 SDValue NegBitShift = DAG.getNode(ISD::SUB, DL, WideVT,
3914 return DAG.getNode(ISD::SRL, DL, MVT::i32, IPM,
3989 return DAG.getNode(SystemZISD::VSUM, SDLoc(Op), Op.getValueType(),
4251 Op = DAG.getNode(SystemZISD::PACK, DL, OutVT, Op0, Op1);
4253 Op = DAG.getNode(P.Opcode, DL, InVT, Op0, Op1);
4492 return DAG.getNode(SystemZISD::MERGE_HIGH, DL, VT,
4513 return DAG.getNode(SystemZISD::JOIN_DWORDS, DL, MVT::v2i64, Op0, Op1);
4648 SDValue Op = DAG.getNode(SystemZISD::MERGE_HIGH,
4769 return DAG.getNode(SystemZISD::SPLAT, DL, VT, Op.getOperand(0),
4846 SDValue Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, IntVT,
4889 return DAG.getNode(ByScalar, DL, VT, Op0, Shift);
4898 return DAG.getNode(ByScalar, DL, VT, Op0, Shift);
4916 return DAG.getNode(ByScalar, DL, VT, Op0, Shift);
5048 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i64, In,
5050 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i64, In,
5063 return DAG.getNode(ISD::BUILD_PAIR, DL, MVT::i128, Lo, Hi);
5364 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ResVT, Op,
5474 SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(Inner), VT, Ext,
5477 return DAG.getNode(ISD::SRA, SDLoc(N0), VT, Shl,
5547 SDValue Extract0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, LdVT,
5704 Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N), EltVT,
5771 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(U), MVT::f32,
5776 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(Op0), MVT::f32,
5822 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(U), MVT::f64,
5827 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(Op0), MVT::f64,
lib/Target/SystemZ/SystemZSelectionDAGInfo.cpp 103 Dst = DAG.getNode(ISD::ADD, DL, PtrVT, Dst,
108 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2);
116 SDValue Dst2 = DAG.getNode(ISD::ADD, DL, PtrVT, Dst,
121 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chain1, Chain2);
135 SDValue DstPlus1 = DAG.getNode(ISD::ADD, DL, PtrVT, Dst,
172 SDValue SHL = DAG.getNode(ISD::SHL, DL, MVT::i32, IPM,
174 SDValue SRA = DAG.getNode(ISD::SRA, DL, MVT::i32, SHL,
202 Char = DAG.getNode(ISD::AND, DL, MVT::i32, Char,
204 SDValue Limit = DAG.getNode(ISD::ADD, DL, PtrVT, Src, Length);
257 SDValue Len = DAG.getNode(ISD::SUB, DL, PtrVT, End, Src);
273 SDValue Limit = DAG.getNode(ISD::ADD, DL, PtrVT, Src, MaxLength);
lib/Target/WebAssembly/WebAssemblyISelLowering.cpp 777 SDValue Add = DAG.getNode(ISD::ADD, DL, PtrVT, FINode,
1123 return DAG.getNode(ISD::ADD, DL, VT, BaseAddr, SymAddr);
1280 SDValue NewExtract = DAG.getNode(
1283 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, Op.getValueType(),
1399 Result = DAG.getNode(WebAssemblyISD::SWIZZLE, DL, VecT, SwizzleSrc,
1496 SDValue MaskedShiftVal = DAG.getNode(
1504 DAG.getNode(Op.getOpcode(), // original shift opcode
1547 return DAG.getNode(Opcode, DL, Op.getValueType(), Op.getOperand(0),
lib/Target/X86/X86ISelDAGToDAG.cpp 797 SDValue Res = CurDAG->getNode(ISD::AND, SDLoc(N), N->getValueType(0),
843 SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
888 SDValue Res = CurDAG->getNode(
927 Res = CurDAG->getNode(Opc, dl, IntVT, Op0, Op1);
930 Res = CurDAG->getNode(N->getOpcode(), dl, VecVT, Op0, Op1);
932 Res = CurDAG->getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Res,
1584 SDValue Srl = DAG.getNode(ISD::SRL, DL, VT, X, Eight);
1585 SDValue And = DAG.getNode(ISD::AND, DL, VT, Srl, NewMask);
1587 SDValue Shl = DAG.getNode(ISD::SHL, DL, VT, And, ShlCount);
1656 SDValue NewAnd = DAG.getNode(ISD::AND, DL, VT, X, NewMask);
1657 SDValue NewShift = DAG.getNode(ISD::SHL, DL, VT, NewAnd, Shift.getOperand(1));
1765 SDValue NewSRL = DAG.getNode(ISD::SRL, DL, VT, X, NewSRLAmt);
1767 SDValue NewSHL = DAG.getNode(ISD::SHL, DL, VT, NewSRL, NewSHLAmt);
1820 SDValue NewSRL = DAG.getNode(ISD::SRL, DL, VT, X, NewSRLAmt);
1822 SDValue NewAnd = DAG.getNode(ISD::AND, DL, VT, NewSRL, NewMask);
1824 SDValue NewSHL = DAG.getNode(ISD::SHL, DL, VT, NewAnd, NewSHLAmt);
2158 SDValue NewShl = CurDAG->getNode(ISD::SHL, DL, VT, Zext, Shl.getOperand(1));
3378 SDValue Extract = CurDAG->getNode(X86ISD::BZHI, DL, NVT, X, NBits);
3406 SDValue Control = CurDAG->getNode(ISD::SHL, DL, MVT::i32, NBits, C8);
3425 Control = CurDAG->getNode(ISD::OR, DL, MVT::i32, Control, ShiftAmt);
3436 SDValue Extract = CurDAG->getNode(X86ISD::BEXTR, DL, XVT, X, Control);
3676 SDValue Neg = CurDAG->getNode(ISD::SUB, DL, SubVT, Zero, Add1);
3697 NewShiftAmt = CurDAG->getNode(ISD::AND, DL, MVT::i8, NewShiftAmt,
3826 SDValue NewBinOp = CurDAG->getNode(Opcode, dl, NVT, X, NewCst);
3828 SDValue NewSHL = CurDAG->getNode(ISD::SHL, dl, NVT, NewBinOp,
3874 SDValue NewNode = CurDAG->getNode(NewOpcode, DL, VT, X, AllOnesVec);
3945 SDValue NewAnd = CurDAG->getNode(ISD::AND, SDLoc(And), VT, And0, NewMask);
4430 SDValue Brind = CurDAG->getNode(ISD::BRIND, dl, MVT::Other,
5214 SDValue Res = CurDAG->getNode(X86ISD::VRNDSCALE, dl, Node->getValueType(0),
lib/Target/X86/X86ISelLowering.cpp 2413 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, Dl, ValLoc, ValArg,
2454 Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, Dl, MVT::i32, Arg,
2456 Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, Dl, MVT::i32, Arg,
2778 return DAG.getNode(ISD::CONCAT_VECTORS, Dl, MVT::v64i1, Lo, Hi);
2884 Val = DAG.getNode(ISD::FP_ROUND, dl, VA.getValVT(), Val,
3085 DAG.getNode(ISD::ADD, dl, PtrVT, DAG.getFrameIndex(FI, PtrVT),
3279 ArgValue = DAG.getNode(ISD::AssertSext, dl, RegVT, ArgValue,
3282 ArgValue = DAG.getNode(ISD::AssertZext, dl, RegVT, ArgValue,
3332 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Copy, Chain);
3412 SDValue FIN = DAG.getNode(ISD::ADD, dl, getPointerTy(DAG.getDataLayout()),
3544 PtrOff = DAG.getNode(ISD::ADD, dl, getPointerTy(DAG.getDataLayout()),
3961 Source = DAG.getNode(ISD::ADD, dl, getPointerTy(DAG.getDataLayout()),
5480 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResultVT, Vec, VecIdx);
5686 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OpVT, Op, ZeroIdx);
5703 Vec = DAG.getNode(X86ISD::KSHIFTR, dl, WideOpVT, Vec, ShiftBits);
5704 Vec = DAG.getNode(X86ISD::KSHIFTL, dl, WideOpVT, Vec, ShiftBits);
5709 Op = DAG.getNode(ISD::OR, dl, WideOpVT, Vec, SubVec);
5710 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OpVT, Op, ZeroIdx);
5718 SubVec = DAG.getNode(X86ISD::KSHIFTL, dl, WideOpVT, SubVec,
5720 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OpVT, SubVec, ZeroIdx);
5728 SubVec = DAG.getNode(X86ISD::KSHIFTL, dl, WideOpVT, SubVec,
5731 SubVec = DAG.getNode(X86ISD::KSHIFTR, dl, WideOpVT, SubVec,
5733 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OpVT, SubVec, ZeroIdx);
5738 SubVec = DAG.getNode(X86ISD::KSHIFTL, dl, WideOpVT, SubVec,
5743 Vec = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVecVT, Vec, ZeroIdx);
5753 Vec = DAG.getNode(X86ISD::KSHIFTL, dl, WideOpVT, Vec, ShiftBits);
5754 Vec = DAG.getNode(X86ISD::KSHIFTR, dl, WideOpVT, Vec, ShiftBits);
5756 Op = DAG.getNode(ISD::OR, dl, WideOpVT, Vec, SubVec);
5757 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OpVT, Op, ZeroIdx);
5769 SubVec = DAG.getNode(X86ISD::KSHIFTL, dl, WideOpVT, SubVec,
5772 SubVec = DAG.getNode(X86ISD::KSHIFTR, dl, WideOpVT, SubVec,
5777 SDValue Low = DAG.getNode(X86ISD::KSHIFTL, dl, WideOpVT, Vec,
5779 Low = DAG.getNode(X86ISD::KSHIFTR, dl, WideOpVT, Low,
5784 SDValue High = DAG.getNode(X86ISD::KSHIFTR, dl, WideOpVT, Vec,
5786 High = DAG.getNode(X86ISD::KSHIFTL, dl, WideOpVT, High,
5790 Vec = DAG.getNode(ISD::OR, dl, WideOpVT, Low, High);
5791 SubVec = DAG.getNode(ISD::OR, dl, WideOpVT, SubVec, Vec);
5794 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OpVT, SubVec, ZeroIdx);
5875 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(Not), V.getValueType(),
7489 NextElt = DAG.getNode(ISD::SHL, dl, MVT::i32, NextElt,
7492 Elt = DAG.getNode(ISD::OR, dl, MVT::i32, NextElt, Elt);
7666 return DAG.getBitcast(VT, DAG.getNode(Opc, dl, ShVT, SrcOp, ShiftVal));
7723 Ptr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
8538 Cond = DAG.getNode(ISD::AND, dl, MVT::i8, Cond,
8553 DstVec = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v64i1, ImmL, ImmH);
8559 DstVec = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, DstVec,
8729 LO = DAG.getNode(X86Opcode, DL, NewVT, V0_LO, V0_HI);
8731 HI = DAG.getNode(X86Opcode, DL, NewVT, V1_LO, V1_HI);
8735 LO = DAG.getNode(X86Opcode, DL, NewVT, V0_LO, V1_LO);
8738 HI = DAG.getNode(X86Opcode, DL, NewVT, V0_HI, V1_HI);
8741 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, LO, HI);
8937 return DAG.getNode(X86ISD::ADDSUB, DL, VT, Opnd0, Opnd1);
9057 SDValue Half = DAG.getNode(HOpcode, SDLoc(BV), HalfVT, V0, V1);
9061 return DAG.getNode(HOpcode, SDLoc(BV), VT, V0, V1);
9250 return DAG.getNode(Opcode, DL, VT, LHS, RHS);
9333 Idx = DAG.getNode(ISD::MUL, SDLoc(Idx), SrcVT, Idx,
9335 Idx = DAG.getNode(ISD::ADD, SDLoc(Idx), SrcVT, Idx,
9370 IndicesVec = DAG.getNode(ISD::ADD, DL, IndicesVT, IndicesVec, IndicesVec);
9391 return DAG.getNode(
9398 SDValue LoLo = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Lo);
9399 SDValue HiHi = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Hi, Hi);
9408 DAG.getNode(X86ISD::PSHUFB, DL, VT, Ops[1], Idx),
9409 DAG.getNode(X86ISD::PSHUFB, DL, VT, Ops[0], Idx),
9447 DAG.getNode(X86ISD::VPERMILPV, DL, MVT::v8f32, HiHi, IndicesVec),
9448 DAG.getNode(X86ISD::VPERMILPV, DL, MVT::v8f32, LoLo, IndicesVec),
9474 IndicesVec = DAG.getNode(ISD::ADD, DL, IndicesVT, IndicesVec, IndicesVec);
9483 DAG.getNode(X86ISD::VPERMILPV, DL, MVT::v4f64, HiHi, IndicesVec),
9484 DAG.getNode(X86ISD::VPERMILPV, DL, MVT::v4f64, LoLo, IndicesVec),
9521 ? DAG.getNode(Opcode, DL, ShuffleVT, IndicesVec, SrcVec)
9522 : DAG.getNode(Opcode, DL, ShuffleVT, SrcVec, IndicesVec);
9984 return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResVT, Lo, Hi);
10048 Op = DAG.getNode(X86ISD::KSHIFTL, dl, ShiftVT, SubVec,
10050 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResVT, Op,
10073 return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResVT, Lo, Hi);
10587 VT, DAG.getNode(X86ISD::PSHUFB, DL, I8VT, DAG.getBitcast(I8VT, V),
10712 return DAG.getNode(X86ISD::UNPCKL, DL, VT, V1, V2);
10717 return DAG.getNode(X86ISD::UNPCKH, DL, VT, V1, V2);
10722 return DAG.getNode(X86ISD::UNPCKL, DL, VT, V2, V1);
10726 return DAG.getNode(X86ISD::UNPCKH, DL, VT, V2, V1);
10885 return DAG.getNode(PackOpcode, DL, VT, DAG.getBitcast(PackVT, V1),
10941 SDValue And = DAG.getNode(ISD::AND, DL, LogicVT, V, VMask);
10965 V1 = DAG.getNode(ISD::AND, DL, VT, V1, V1Mask);
10966 V2 = DAG.getNode(X86ISD::ANDNP, DL, VT, V1Mask, V2);
10967 return DAG.getNode(ISD::OR, DL, VT, V1, V2);
11572 DAG.getNode(X86ISD::VSHLDQ, DL, MVT::v16i8, Lo,
11575 DAG.getNode(X86ISD::VSRLDQ, DL, MVT::v16i8, Hi,
11578 DAG.getNode(ISD::OR, DL, MVT::v16i8, LoShift, HiShift));
11646 Res = DAG.getNode(X86ISD::VSHLDQ, DL, MVT::v16i8, Res,
11648 Res = DAG.getNode(X86ISD::VSRLDQ, DL, MVT::v16i8, Res,
11652 Res = DAG.getNode(X86ISD::VSRLDQ, DL, MVT::v16i8, Res,
11654 Res = DAG.getNode(X86ISD::VSHLDQ, DL, MVT::v16i8, Res,
11661 Res = DAG.getNode(X86ISD::VSHLDQ, DL, MVT::v16i8, Res,
11664 Res = DAG.getNode(X86ISD::VSRLDQ, DL, MVT::v16i8, Res,
11666 Res = DAG.getNode(X86ISD::VSHLDQ, DL, MVT::v16i8, Res,
11788 V = DAG.getNode(Opcode, DL, ShiftVT, V,
12000 VT, DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
12007 InputV = DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32,
12013 VT, DAG.getNode(OddEvenOp, DL, MVT::v8i16,
12039 DAG.getNode(X86ISD::UNPCKL, DL, MVT::v2i64, Lo, Hi));
12059 VT, DAG.getNode(X86ISD::PSHUFB, DL, MVT::v16i8, InputV,
12086 InputV = DAG.getNode(UnpackLoHi, DL, InputVT, InputV, Ext);
12324 return DAG.getNode(EltVT == MVT::f32 ? X86ISD::MOVSS : X86ISD::MOVSD, DL,
12347 V2 = DAG.getNode(X86ISD::VSHLDQ, DL, MVT::v16i8, V2,
12402 Scalar = DAG.getNode(ISD::SRL, DL, Scalar.getValueType(), Scalar,
12480 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Shuf,
12853 VT, DAG.getNode(UnpackLo ? X86ISD::UNPCKL : X86ISD::UNPCKH, DL,
12893 VT, DL, DAG.getNode(NumLoInputs == 0 ? X86ISD::UNPCKH : X86ISD::UNPCKL,
12929 return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v2f64, V1,
12968 return DAG.getNode(
13015 DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32, V1,
13204 return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v4f32, V1,
13212 return DAG.getNode(X86ISD::MOVLHPS, DL, MVT::v4f32, V1, V1);
13214 return DAG.getNode(X86ISD::MOVHLPS, DL, MVT::v4f32, V1, V1);
13256 return DAG.getNode(X86ISD::MOVLHPS, DL, MVT::v4f32, V1, V2);
13258 return DAG.getNode(X86ISD::MOVHLPS, DL, MVT::v4f32, V2, V1);
13310 return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v4i32, V1,
13414 return DAG.getNode(X86ISD::PSHUFLW, DL, VT, V,
13421 return DAG.getNode(X86ISD::PSHUFHW, DL, VT, V,
13447 V = DAG.getNode(ShufWOp, DL, VT, V,
13450 V = DAG.getNode(X86ISD::PSHUFD, DL, PSHUFDVT, V,
13599 V = DAG.getNode(
13627 DAG.getNode(X86ISD::PSHUFD, DL, PSHUFDVT, DAG.getBitcast(PSHUFDVT, V),
13861 V = DAG.getNode(X86ISD::PSHUFLW, DL, VT, V,
13864 V = DAG.getNode(X86ISD::PSHUFHW, DL, VT, V,
13869 DAG.getNode(X86ISD::PSHUFD, DL, PSHUFDVT, DAG.getBitcast(PSHUFDVT, V),
13881 V = DAG.getNode(X86ISD::PSHUFLW, DL, VT, V,
13889 V = DAG.getNode(X86ISD::PSHUFHW, DL, VT, V,
13931 V1 = DAG.getNode(X86ISD::PSHUFB, DL, ShufVT, DAG.getBitcast(ShufVT, V1),
13934 V2 = DAG.getNode(X86ISD::PSHUFB, DL, ShufVT, DAG.getBitcast(ShufVT, V2),
13940 V = DAG.getNode(ISD::OR, DL, ShufVT, V1, V2);
14156 return DAG.getNode(X86ISD::VPERMV, DL, VT, MaskNode, V1);
14288 V1 = DAG.getNode(TargetLo ? X86ISD::UNPCKL : X86ISD::UNPCKH, DL,
14409 V1 = DAG.getNode(ISD::AND, DL, MVT::v16i8, V1, ByteClearMask);
14411 V2 = DAG.getNode(ISD::AND, DL, MVT::v16i8, V2, ByteClearMask);
14416 SDValue Result = DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, V1, V2);
14419 Result = DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, Result, Result);
14449 VLoHalf = DAG.getNode(ISD::AND, DL, MVT::v8i16, VLoHalf,
14468 MVT::v8i16, DAG.getNode(X86ISD::UNPCKL, DL, MVT::v16i8, V, Zero));
14470 MVT::v8i16, DAG.getNode(X86ISD::UNPCKH, DL, MVT::v16i8, V, Zero));
14476 return DAG.getNode(X86ISD::PACKUS, DL, MVT::v16i8, LoV, HiV);
14543 LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigSplitVT, V,
14545 HiV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, OrigSplitVT, V,
14627 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
14830 SDValue LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V1,
14858 SDValue SubVec = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT,
15150 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, HalfVT, V,
15163 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Op0, Op1);
15194 SDValue Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, HalfVT, V1,
15204 SDValue Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, HalfVT, V1,
15602 return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v4f64, V1,
15608 return DAG.getNode(X86ISD::VPERMI, DL, MVT::v4f64, V1,
15714 DAG.getNode(X86ISD::PSHUFD, DL, MVT::v8i32,
15721 return DAG.getNode(X86ISD::VPERMI, DL, MVT::v4i64, V1,
15812 return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v8f32, V1,
15835 return DAG.getNode(X86ISD::VPERMILPV, DL, MVT::v8f32, V1, VPermMask);
15838 return DAG.getNode(X86ISD::VPERMV, DL, MVT::v8f32, VPermMask, V1);
15923 return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v8i32, V1,
15962 return DAG.getNode(X86ISD::VPERMV, DL, MVT::v8i32, VPermMask, V1);
16275 SDValue LoV = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V1,
16289 SDValue SubVec = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT,
16323 SDValue Subvec = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SubVT, V2,
16374 return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v8f64, V1,
16380 return DAG.getNode(X86ISD::VPERMI, DL, MVT::v8f64, V1,
16429 return DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v16f32, V1,
16449 return DAG.getNode(X86ISD::VPERMILPV, DL, MVT::v16f32, V1, VPermMask);
16479 DAG.getNode(X86ISD::PSHUFD, DL, MVT::v16i32,
16486 return DAG.getNode(X86ISD::VPERMI, DL, MVT::v8i64, V1,
16548 return DAG.getNode(X86ISD::PSHUFD, DL, MVT::v16i32, V1,
16803 Res = DAG.getNode(X86ISD::KSHIFTR, DL, WideVT, Res,
16805 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Res,
16881 SDValue Extract = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ExtractVT,
16910 Res = DAG.getNode(X86ISD::KSHIFTL, DL, WideVT, Res,
16916 Res = DAG.getNode(Opcode, DL, WideVT, Res,
16918 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Res,
17289 SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32,
17308 SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
17345 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ExtEltVT, Ext, Idx);
17364 Vec = DAG.getNode(X86ISD::KSHIFTR, dl, WideVecVT, Vec,
17367 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
17431 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, Op.getValueType(), Vec,
17445 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
17449 SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32,
17465 SDValue Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
17470 Res = DAG.getNode(ISD::SRL, dl, MVT::i32, Res,
17476 SDValue Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i16,
17481 Res = DAG.getNode(ISD::SRL, dl, MVT::i16, Res,
17493 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
17509 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Vec,
17754 Vec = DAG.getNode(X86ISD::KSHIFTR, dl, WideVecVT, Vec,
17757 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, Op.getValueType(), Vec,
17802 DAG.getNode(ISD::ADD, DL, PtrVT,
17824 DAG.getNode(ISD::ADD, DL, PtrVT,
17849 Result = DAG.getNode(ISD::ADD, dl, PtrVT,
17910 Result = DAG.getNode(ISD::ADD, dl, PtrVT,
17923 Result = DAG.getNode(ISD::ADD, dl, PtrVT, Result,
18023 return DAG.getNode(ISD::ADD, dl, PtrVT, Offset, Base);
18067 Offset = DAG.getNode(ISD::ADD, dl, PtrVT,
18078 return DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, Offset);
18132 Offset = DAG.getNode(ISD::ADD, DL, PtrVT,
18205 IDX = DAG.getNode(ISD::SHL, dl, PtrVT, IDX, Scale);
18207 res = DAG.getNode(ISD::ADD, dl, PtrVT, ThreadPointer, IDX);
18220 return DAG.getNode(ISD::ADD, dl, PtrVT, res, Offset);
18241 SDValue SafeShAmt = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
18243 SDValue Tmp1 = isSRA ? DAG.getNode(ISD::SRA, dl, VT, ShOpHi,
18250 Tmp3 = DAG.getNode(ISD::SHL, dl, VT, ShOpLo, SafeShAmt);
18253 Tmp3 = DAG.getNode(isSRA ? ISD::SRA : ISD::SRL, dl, VT, ShOpHi, SafeShAmt);
18259 SDValue AndNode = DAG.getNode(ISD::AND, dl, MVT::i8, ShAmt,
18319 Amt = DAG.getNode(ISD::AND, DL, Amt.getValueType(), Amt,
18350 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, CvtVec,
18414 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, DestVT, VCast,
18434 DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4i32, Src,
18591 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, XR2F, CLod1);
18595 Result = DAG.getNode(X86ISD::FHADD, dl, MVT::v2f64, Sub, Sub);
18598 Result = DAG.getNode(ISD::FADD, dl, MVT::v2f64, Shuffle, Sub);
18601 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64, Result,
18620 Load = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
18625 SDValue Or = DAG.getNode(
18632 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
18637 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::f64, Or, Bias);
18653 N0 = DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4i32, N0,
18668 SDValue HI = DAG.getNode(ISD::SRL, DL, MVT::v4i32, N0, HalfWord);
18669 SDValue LO = DAG.getNode(ISD::AND, DL, MVT::v4i32, N0, HalfWordMask);
18672 fHI = DAG.getNode(ISD::FMUL, DL, MVT::v2f64, fHI, TWOHW);
18676 return DAG.getNode(ISD::FADD, DL, MVT::v2f64, fHI, fLO);
18729 SDValue HighShift = DAG.getNode(ISD::SRL, DL, VecIntVT, V, VecCstShift);
18752 SDValue LowAnd = DAG.getNode(ISD::AND, DL, VecIntVT, V, VecCstMask);
18753 Low = DAG.getNode(ISD::OR, DL, VecIntVT, LowAnd, VecCstLow);
18756 High = DAG.getNode(ISD::OR, DL, VecIntVT, HighShift, VecCstHigh);
18767 DAG.getNode(ISD::FADD, DL, VecFloatVT, HighBitcast, VecCstFAdd);
18770 return DAG.getNode(ISD::FADD, DL, VecFloatVT, LowBitcast, FHigh);
18882 FudgePtr = DAG.getNode(ISD::ADD, dl, PtrVT, FudgePtr, Offset);
18892 SDValue Add = DAG.getNode(ISD::FADD, dl, MVT::f80, Fild, Fudge);
18893 return DAG.getNode(ISD::FP_ROUND, dl, DstVT, Add,
18986 SDValue Sub = DAG.getNode(ISD::FSUB, DL, TheVT, Value, ThreshVal);
19023 Res = DAG.getNode(ISD::XOR, DL, MVT::i64, Res, Adjust);
19057 In = DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(Op),
19084 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpLo);
19092 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
19099 SDValue Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v8i1, In,
19101 SDValue Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v8i1, In,
19105 SDValue Res = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v16i16, Lo, Hi);
19123 return DAG.getNode(ISD::SRL, DL, VT, Extend,
19161 SelectedVal = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, SelectedVal,
19232 SDValue Res = DAG.getNode(Opcode, DL, OutVT, In, In);
19250 SDValue Res = DAG.getNode(Opcode, DL, OutVT, Lo, Hi);
19259 SDValue Res = DAG.getNode(Opcode, DL, OutVT, Lo, Hi);
19285 SDValue Res = DAG.getNode(ISD::CONCAT_VECTORS, DL, PackedVT, Lo, Hi);
19308 In = DAG.getNode(ISD::SHL, DL, ExtVT,
19342 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
19356 In = DAG.getNode(ISD::SHL, DL, InVT, In,
19392 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
19441 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, In,
19445 SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
19447 SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
19470 In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v2i64, In,
19475 SDValue OpLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
19478 SDValue OpHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v4i32, In,
19502 In = DAG.getNode(ISD::AND, DL, InVT, In, DAG.getConstant(255, DL, InVT));
19504 SDValue InLo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v8i16, In,
19506 SDValue InHi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, MVT::v8i16, In,
19508 return DAG.getNode(X86ISD::PACKUS, DL, VT, InLo, InHi);
19548 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v2i1, Res,
19555 DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32, Src,
19621 DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4f32,
19719 SDValue HOp = DAG.getNode(HOpcode, DL, X.getValueType(), X, X);
19720 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, Op.getSimpleValueType(), HOp,
19790 return DAG.getNode(LogicOp, dl, LogicVT, Operand, Mask);
19795 SDValue LogicNode = DAG.getNode(LogicOp, dl, LogicVT, Operand, Mask);
19796 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, LogicNode,
19812 Sign = DAG.getNode(ISD::FP_ROUND, dl, VT, Sign, DAG.getIntPtrConstant(1, dl));
19844 SDValue SignBit = DAG.getNode(X86ISD::FAND, dl, LogicVT, Sign, SignMask);
19858 MagBits = DAG.getNode(X86ISD::FAND, dl, LogicVT, Mag, MagMask);
19862 SDValue Or = DAG.getNode(X86ISD::FOR, dl, LogicVT, MagBits, SignBit);
19863 return !IsFakeVector ? Or : DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Or,
19881 Res = DAG.getNode(ISD::AND, dl, VT, Res, DAG.getConstant(1, dl, VT));
19888 return DAG.getNode(X86ISD::SETCC, dl, MVT::i8,
19989 VecIns.push_back(DAG.getNode(ISD::OR, DL, TestVT, LHS, RHS));
19994 return DAG.getNode(X86ISD::PTEST, DL, MVT::i32, VecIns.back(), VecIns.back());
20056 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
20121 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
20142 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op0, Op1);
20205 SDValue Srl = DAG.getNode(ISD::SRL, dl, MVT::i16, FNStSW,
20341 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0, Pow2MinusOne);
20350 DAG.getNode(ISD::SRA, DL, VT, CMov, DAG.getConstant(Lg2, DL, MVT::i64));
20358 return DAG.getNode(ISD::SUB, DL, VT, Zero, SRA);
20439 return DAG.getNode(X86ISD::BT, dl, MVT::i32, Src, BitNo);
20512 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
20621 SDValue Result = DAG.getNode(ISD::USUBSAT, dl, VT, Op0, Op1);
20622 return DAG.getNode(X86ISD::PCMPEQ, dl, VT, Result,
20677 Cmp = DAG.getNode(CombineOpc, dl, VT, Cmp0, Cmp1);
20767 Result = DAG.getNode(ISD::SHL, dl, VT, Result,
20769 Result = DAG.getNode(ISD::SRA, dl, VT, Result,
20830 SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
20831 Result = DAG.getNode(X86ISD::PCMPEQ, dl, VT, Op0, Result);
20872 Op0 = DAG.getNode(ISD::XOR, dl, MVT::v2i64, Op0, SB);
20873 Op1 = DAG.getNode(ISD::XOR, dl, MVT::v2i64, Op1, SB);
20880 SDValue GT = DAG.getNode(X86ISD::PCMPGT, dl, MVT::v4i32, Op0, Op1);
20881 SDValue EQ = DAG.getNode(X86ISD::PCMPEQ, dl, MVT::v4i32, Op0, Op1);
20890 SDValue Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, EQHi, GTLo);
20891 Result = DAG.getNode(ISD::OR, dl, MVT::v4i32, Result, GTHi);
20909 SDValue Result = DAG.getNode(Opc, dl, MVT::v4i32, Op0, Op1);
20914 Result = DAG.getNode(ISD::AND, dl, MVT::v4i32, Result, Shuf);
20929 Op0 = DAG.getNode(ISD::XOR, dl, VT, Op0, SM);
20930 Op1 = DAG.getNode(ISD::XOR, dl, VT, Op1, SM);
20933 SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
20983 return DAG.getNode(X86ISD::KTEST, dl, MVT::i32, LHS, RHS);
20995 return DAG.getNode(X86ISD::KORTEST, dl, MVT::i32, LHS, RHS);
21087 return DAG.getNode(X86ISD::SETCC, dl, MVT::i8, X86CC, EFLAGS);
21259 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT,
21262 SDValue AndN = DAG.getNode(X86ISD::FANDN, DL, VT, Cmp, Op2);
21263 SDValue And = DAG.getNode(X86ISD::FAND, DL, VT, Cmp, Op1);
21264 return DAG.getNode(X86ISD::FOR, DL, VT, AndN, And);
21283 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
21303 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, ExtVec,
21342 SDValue CmpZero = DAG.getNode(X86ISD::CMP, DL, MVT::i32, Zero, CmpOp0);
21348 Cmp = DAG.getNode(X86ISD::CMP, DL, MVT::i32,
21361 Res = DAG.getNode(ISD::OR, DL, Res.getValueType(), Res, Y);
21390 Neg = DAG.getNode(ISD::AND, DL, VT,
21395 SDValue Mask = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
21397 SDValue And = DAG.getNode(ISD::AND, DL, VT, Mask, Src1); // Mask & z
21398 return DAG.getNode(Op2.getOpcode(), DL, VT, And, Src2); // And Op y
21473 DAG.getNode(X86ISD::SETCC_CARRY, DL, Op.getValueType(),
21569 V = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, V,
21656 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Lo, Hi);
21688 SignExt = DAG.getNode(X86ISD::VSRAI, dl, DestVT, Curr,
21730 In = DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(Op),
21757 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, OpLo, OpHi);
21791 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Ch0, Ch1);
21819 SDValue Scl = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, StoreSVT, StoredVal,
21878 StoredVal = DAG.getNode(ISD::CONCAT_VECTORS, dl, WideVT, StoredVal,
21887 StoredVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, StVT, StoredVal,
21933 Val = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, RegVT,
22129 SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
22145 SDValue Cmp = DAG.getNode(X86ISD::CMP, dl, MVT::i32,
22225 Result = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
22227 Result = DAG.getNode(ISD::AND, dl, VT, Result,
22247 Result = DAG.getNode(X86ISD::SEG_ALLOCA, dl, SPTy, Chain,
22260 SP = DAG.getNode(ISD::AND, dl, VT, SP.getValue(0),
22315 FIN = DAG.getNode(ISD::ADD, DL, PtrVT, FIN, DAG.getIntPtrConstant(4, DL));
22322 FIN = DAG.getNode(ISD::ADD, DL, PtrVT, FIN, DAG.getIntPtrConstant(
22509 return DAG.getNode(Opc, dl, VT, SrcOp,
22558 ShAmt = DAG.getNode(X86ISD::VSHLDQ, SDLoc(ShAmt), MVT::v16i8, ShAmt,
22560 ShAmt = DAG.getNode(X86ISD::VSRLDQ, SDLoc(ShAmt), MVT::v16i8, ShAmt,
22580 return DAG.getNode(Opc, dl, VT, SrcOp, ShAmt);
22601 Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, Mask,
22603 Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, Mask,
22609 return DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v64i1, Lo, Hi);
22615 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MaskVT,
22663 SDValue IMask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, MVT::v1i1,
22669 return DAG.getNode(ISD::AND, dl, VT, Op, IMask);
22727 return DAG.getNode(ISD::ADD, dl, PtrVT, EntryEBP, ParentFrameOffset);
22732 SDValue RegNodeBase = DAG.getNode(ISD::SUB, dl, PtrVT, EntryEBP,
22734 return DAG.getNode(ISD::SUB, dl, PtrVT, RegNodeBase, ParentFrameOffset);
22791 return DAG.getNode(IntrWithRoundingModeOpcode, dl, Op.getValueType(),
22830 return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(),
22844 return DAG.getNode(Opc, dl, Op.getValueType(), Op.getOperand(1),
22887 DAG.getNode(IntrWithRoundingModeOpcode, dl, Op.getValueType(),
22935 return getScalarMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src1,
22965 NewOp = DAG.getNode(IntrData->Opc0, dl, VT, Src1, Src2);
22988 return getScalarMaskingNode(DAG.getNode(Opc, dl, VT, Src1, Src2),
23007 NewOp = DAG.getNode(IntrData->Opc0, dl, VT, Src1, Src2);
23025 return getVectorMaskingNode(DAG.getNode(Opc, dl, VT, Src1, Src2),
23080 return DAG.getNode(IntrData->Opc0, dl, VT,Src2, Src1);
23091 SDValue FPclass = DAG.getNode(IntrData->Opc0, dl, MVT::v1i1, Src1, Imm);
23151 SDValue Comi = DAG.getNode(IntrData->Opc0, dl, MVT::i32, LHS, RHS);
23152 SDValue InvComi = DAG.getNode(IntrData->Opc0, dl, MVT::i32, RHS, LHS);
23158 SetCC = DAG.getNode(ISD::AND, dl, MVT::i8, SetCC, SetNP);
23164 SetCC = DAG.getNode(ISD::OR, dl, MVT::i8, SetCC, SetP);
23260 return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(),
23280 return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(),
23328 return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Src, Rnd);
23445 SDValue Test = DAG.getNode(TestOpc, dl, MVT::i32, LHS, RHS);
23833 SDValue Tmp = DAG.getNode(ISD::SHL, DL, MVT::i64, HI,
23835 Results.push_back(DAG.getNode(ISD::OR, DL, MVT::i64, LO, Tmp));
24196 DAG.getNode(ISD::ADD, dl, PtrVT, FrameAddr, Offset),
24323 SDValue StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, Frame,
24326 StoreAddr = DAG.getNode(ISD::ADD, dl, PtrVT, StoreAddr, Offset);
24330 return DAG.getNode(X86ISD::EH_RETURN, dl, MVT::Other, Chain,
24355 return DAG.getNode(X86ISD::EH_SJLJ_LONGJMP, DL, MVT::Other,
24399 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
24408 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
24413 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
24421 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
24427 Addr = DAG.getNode(ISD::ADD, dl, MVT::i64, Trmp,
24484 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
24486 Disp = DAG.getNode(ISD::SUB, dl, MVT::i32, FPtr, Addr);
24495 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
24502 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
24508 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
24565 DAG.getNode(ISD::SRL, DL, MVT::i16,
24566 DAG.getNode(ISD::AND, DL, MVT::i16,
24570 DAG.getNode(ISD::SRL, DL, MVT::i16,
24571 DAG.getNode(ISD::AND, DL, MVT::i16,
24576 DAG.getNode(ISD::AND, DL, MVT::i16,
24577 DAG.getNode(ISD::ADD, DL, MVT::i16,
24578 DAG.getNode(ISD::OR, DL, MVT::i16, CWD1, CWD2),
24602 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
24655 return DAG.getNode(ISD::SUB, dl, VT, TruncNode, Delta);
24688 SDValue Hi = DAG.getNode(ISD::SRL, DL, CurrVT, Op0, NibbleShift);
24698 Lo = DAG.getNode(X86ISD::PSHUFB, DL, CurrVT, InRegLUT, Lo);
24699 Hi = DAG.getNode(X86ISD::PSHUFB, DL, CurrVT, InRegLUT, Hi);
24700 Lo = DAG.getNode(ISD::AND, DL, CurrVT, Lo, HiZ);
24701 SDValue Res = DAG.getNode(ISD::ADD, DL, CurrVT, Lo, Hi);
24731 SDValue R0 = DAG.getNode(ISD::SRL, DL, NextVT, ResNext, Shift);
24732 SDValue R1 = DAG.getNode(ISD::SRL, DL, NextVT, HiZ, Shift);
24733 R1 = DAG.getNode(ISD::AND, DL, NextVT, ResNext, R1);
24734 Res = DAG.getNode(ISD::ADD, DL, NextVT, R0, R1);
24794 Op = DAG.getNode(ISD::XOR, dl, OpVT, Op,
24847 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
24848 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
24849 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
24876 return DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
24877 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS1, RHS1),
24878 DAG.getNode(Op.getOpcode(), dl, NewVT, LHS2, RHS2));
24888 return DAG.getNode(ISD::XOR, SDLoc(Op), VT,
24909 return DAG.getNode(ISD::OR, dl, VT, X, Y);
24913 return DAG.getNode(ISD::AND, dl, VT, X, DAG.getNOT(dl, Y, VT));
24925 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, X, Y);
24931 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, X, Y);
24965 DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Src);
24997 N0 = DAG.getNode(ISD::XOR, DL, VT, N0, Sign);
24998 N1 = DAG.getNode(ISD::XOR, DL, VT, N1, Sign);
25000 SDValue Result = DAG.getNode(Opcode, DL, VT, N0, N1);
25001 return DAG.getNode(ISD::XOR, DL, VT, Result, Sign);
25024 return DAG.getNode(ISD::AND, dl, VT, Op.getOperand(0), Op.getOperand(1));
25043 DAG.getNode(ISD::MUL, dl, ExVT,
25079 SDValue RLo = DAG.getNode(ISD::MUL, dl, ExVT, ALo, BLo);
25080 SDValue RHi = DAG.getNode(ISD::MUL, dl, ExVT, AHi, BHi);
25081 RLo = DAG.getNode(ISD::AND, dl, ExVT, RLo, DAG.getConstant(255, dl, ExVT));
25082 RHi = DAG.getNode(ISD::AND, dl, ExVT, RHi, DAG.getConstant(255, dl, ExVT));
25083 return DAG.getNode(X86ISD::PACKUS, dl, VT, RLo, RHi);
25097 SDValue Evens = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64,
25101 SDValue Odds = DAG.getNode(X86ISD::PMULUDQ, dl, MVT::v2i64,
25143 AloBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, B);
25148 AloBhi = DAG.getNode(X86ISD::PMULUDQ, dl, VT, A, Bhi);
25154 AhiBlo = DAG.getNode(X86ISD::PMULUDQ, dl, VT, Ahi, B);
25157 SDValue Hi = DAG.getNode(ISD::ADD, dl, VT, AloBhi, AhiBlo);
25160 return DAG.getNode(ISD::ADD, dl, VT, AloBlo, Hi);
25209 SDValue Mul1 = DAG.getBitcast(VT, DAG.getNode(Opcode, dl, MulVT,
25214 SDValue Mul2 = DAG.getBitcast(VT, DAG.getNode(Opcode, dl, MulVT,
25229 SDValue T1 = DAG.getNode(ISD::AND, dl, VT,
25231 SDValue T2 = DAG.getNode(ISD::AND, dl, VT,
25234 SDValue Fixup = DAG.getNode(ISD::ADD, dl, VT, T1, T2);
25235 Res = DAG.getNode(ISD::SUB, dl, VT, Res, Fixup);
25258 SDValue Mul = DAG.getNode(ISD::MUL, dl, ExVT, ExA, ExB);
25279 SDValue Lo = DAG.getNode(ISD::MUL, dl, ExVT, ALo, BLo);
25280 SDValue Hi = DAG.getNode(ISD::MUL, dl, ExVT, AHi, BHi);
25374 SDValue RLo = DAG.getNode(ISD::MUL, dl, ExVT, ALo, BLo);
25375 SDValue RHi = DAG.getNode(ISD::MUL, dl, ExVT, AHi, BHi);
25380 return DAG.getNode(X86ISD::PACKUS, dl, VT, RLo, RHi);
25503 return DAG.getNode(X86ISD::PCMPGT, dl, VT, DAG.getConstant(0, dl, VT), R);
25560 return DAG.getNode(ISD::ADD, dl, VT, R, R);
25570 return DAG.getNode(X86ISD::PCMPGT, dl, VT, Zeros, R);
25584 return DAG.getNode(ISD::AND, dl, VT, SHL, DAG.getConstant(Mask, dl, VT));
25592 return DAG.getNode(ISD::AND, dl, VT, SRL,
25597 SDValue Res = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
25600 Res = DAG.getNode(ISD::XOR, dl, VT, Res, Mask);
25601 Res = DAG.getNode(ISD::SUB, dl, VT, Res, Mask);
25660 Res = DAG.getNode(ISD::AND, dl, VT, Res, BitMask);
25669 Res = DAG.getNode(ISD::XOR, dl, VT, Res, SignMask);
25670 Res = DAG.getNode(ISD::SUB, dl, VT, Res, SignMask);
25692 return DAG.getNode(X86OpcV, dl, VT, R, Op.getOperand(1));
25736 Amt = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(23, dl, VT));
25737 Amt = DAG.getNode(ISD::ADD, dl, VT, Amt,
25751 return DAG.getNode(X86ISD::PACKUS, dl, VT, Lo, Hi);
25792 Amt = DAG.getNode(ISD::SUB, dl, VT, Zero, Amt);
25795 return DAG.getNode(X86ISD::VPSHL, dl, VT, R, Amt);
25797 return DAG.getNode(X86ISD::VPSHA, dl, VT, R, Amt);
25806 SDValue R0 = DAG.getNode(Opc, dl, VT, R, Amt0);
25807 SDValue R1 = DAG.getNode(Opc, dl, VT, R, Amt1);
25817 SDValue M = DAG.getNode(ISD::SRL, dl, VT, S, Amt);
25818 R = DAG.getNode(ISD::SRL, dl, VT, R, Amt);
25819 R = DAG.getNode(ISD::XOR, dl, VT, R, M);
25820 R = DAG.getNode(ISD::SUB, dl, VT, R, M);
25881 return DAG.getNode(ISD::MUL, dl, VT, R, Scale);
25888 SDValue RAmt = DAG.getNode(ISD::SUB, dl, VT, EltBits, Amt);
25892 SDValue Res = DAG.getNode(ISD::MULHU, dl, VT, R, Scale);
25907 SDValue RAmt = DAG.getNode(ISD::SUB, dl, VT, EltBits, Amt);
25915 SDValue Res = DAG.getNode(ISD::MULHS, dl, VT, R, Scale);
25960 SDValue R0 = DAG.getNode(ShOpc, dl, VT, R, DAG.getBitcast(VT, Amt0));
25961 SDValue R1 = DAG.getNode(ShOpc, dl, VT, R, DAG.getBitcast(VT, Amt1));
25962 SDValue R2 = DAG.getNode(ShOpc, dl, VT, R, DAG.getBitcast(VT, Amt2));
25963 SDValue R3 = DAG.getNode(ShOpc, dl, VT, R, DAG.getBitcast(VT, Amt3));
25994 DAG.getNode(Opc, dl, ExtVT, R, Amt));
26010 Amt = DAG.getNode(ISD::SUB, dl, ExVT, DAG.getConstant(8, dl, ExVT), Amt);
26011 Amt = DAG.getNode(ISD::SHL, dl, ExVT, DAG.getConstant(1, dl, ExVT), Amt);
26018 R = DAG.getNode(ISD::MUL, dl, ExVT, R, Amt);
26019 R = DAG.getNode(X86ISD::VSRLI, dl, ExVT, R, Cst8);
26037 LoR = DAG.getNode(X86OpcI, dl, VT16, LoR, Cst8);
26038 HiR = DAG.getNode(X86OpcI, dl, VT16, HiR, Cst8);
26039 LoR = DAG.getNode(ISD::MUL, dl, VT16, LoR, LoA);
26040 HiR = DAG.getNode(ISD::MUL, dl, VT16, HiR, HiA);
26041 LoR = DAG.getNode(X86ISD::VSRLI, dl, VT16, LoR, Cst8);
26042 HiR = DAG.getNode(X86ISD::VSRLI, dl, VT16, HiR, Cst8);
26043 return DAG.getNode(X86ISD::PACKUS, dl, VT, LoR, HiR);
26075 SDValue C = DAG.getNode(X86ISD::PCMPGT, dl, SelVT, Z, Sel);
26088 SDValue M = DAG.getNode(Opc, dl, VT, R, DAG.getConstant(4, dl, VT));
26092 Amt = DAG.getNode(ISD::ADD, dl, VT, Amt, Amt);
26095 M = DAG.getNode(Opc, dl, VT, R, DAG.getConstant(2, dl, VT));
26099 Amt = DAG.getNode(ISD::ADD, dl, VT, Amt, Amt);
26102 M = DAG.getNode(Opc, dl, VT, R, DAG.getConstant(1, dl, VT));
26127 ALo = DAG.getNode(ISD::ADD, dl, ExtVT, ALo, ALo);
26128 AHi = DAG.getNode(ISD::ADD, dl, ExtVT, AHi, AHi);
26137 ALo = DAG.getNode(ISD::ADD, dl, ExtVT, ALo, ALo);
26138 AHi = DAG.getNode(ISD::ADD, dl, ExtVT, AHi, AHi);
26150 return DAG.getNode(X86ISD::PACKUS, dl, VT, RLo, RHi);
26165 SDValue Lo = DAG.getNode(Opc, dl, ExtVT, RLo, ALo);
26166 SDValue Hi = DAG.getNode(Opc, dl, ExtVT, RHi, AHi);
26169 return DAG.getNode(X86ISD::PACKUS, dl, VT, Lo, Hi);
26200 Amt = DAG.getNode(
26213 Amt = DAG.getNode(ISD::ADD, dl, VT, Amt, Amt);
26220 Amt = DAG.getNode(ISD::ADD, dl, VT, Amt, Amt);
26227 Amt = DAG.getNode(ISD::ADD, dl, VT, Amt, Amt);
26275 return DAG.getNode(Op, DL, VT, R,
26296 return DAG.getNode(X86ISD::VROTLI, DL, VT, R,
26341 SDValue C = DAG.getNode(X86ISD::PCMPGT, DL, SelVT, Z, Sel);
26349 Amt = DAG.getNode(ISD::SHL, DL, ExtVT, Amt, DAG.getConstant(5, DL, ExtVT));
26354 M = DAG.getNode(
26356 DAG.getNode(ISD::SHL, DL, VT, R, DAG.getConstant(4, DL, VT)),
26357 DAG.getNode(ISD::SRL, DL, VT, R, DAG.getConstant(4, DL, VT)));
26361 Amt = DAG.getNode(ISD::ADD, DL, VT, Amt, Amt);
26364 M = DAG.getNode(
26366 DAG.getNode(ISD::SHL, DL, VT, R, DAG.getConstant(2, DL, VT)),
26367 DAG.getNode(ISD::SRL, DL, VT, R, DAG.getConstant(6, DL, VT)));
26371 Amt = DAG.getNode(ISD::ADD, DL, VT, Amt, Amt);
26374 M = DAG.getNode(
26376 DAG.getNode(ISD::SHL, DL, VT, R, DAG.getConstant(1, DL, VT)),
26377 DAG.getNode(ISD::SRL, DL, VT, R, DAG.getConstant(7, DL, VT)));
26382 Amt = DAG.getNode(ISD::AND, DL, VT, Amt,
26393 AmtR = DAG.getNode(ISD::SUB, DL, VT, AmtR, Amt);
26394 SDValue SHL = DAG.getNode(ISD::SHL, DL, VT, R, Amt);
26395 SDValue SRL = DAG.getNode(ISD::SRL, DL, VT, R, AmtR);
26396 return DAG.getNode(ISD::OR, DL, VT, SHL, SRL);
26405 SDValue Lo = DAG.getNode(ISD::MUL, DL, VT, R, Scale);
26406 SDValue Hi = DAG.getNode(ISD::MULHU, DL, VT, R, Scale);
26407 return DAG.getNode(ISD::OR, DL, VT, Lo, Hi);
26418 SDValue Res02 = DAG.getNode(X86ISD::PMULUDQ, DL, MVT::v2i64,
26421 SDValue Res13 = DAG.getNode(X86ISD::PMULUDQ, DL, MVT::v2i64,
26427 return DAG.getNode(ISD::OR, DL, VT,
26739 Hi = DAG.getNode(ISD::SHL, DL, MVT::i64, Hi,
26741 return DAG.getNode(ISD::OR, DL, MVT::i64, Lo, Hi);
26748 Hi = DAG.getNode(ISD::SHL, DL, MVT::i32, Hi,
26750 return DAG.getNode(ISD::OR, DL, MVT::i32, Lo, Hi);
26768 SDValue Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, Src,
26771 SDValue Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32, Src,
26774 return DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v64i1, Lo, Hi);
26786 return DAG.getNode(ISD::CONCAT_VECTORS, dl, DstVT, Lo, Hi);
26814 Src = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewVT, Src,
26828 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, DstVT, Src,
26856 V = DAG.getNode(X86ISD::PSADBW, DL, SadVecVT, V, Zeros);
26874 Low = DAG.getNode(X86ISD::PSADBW, DL, SadVecVT,
26876 High = DAG.getNode(X86ISD::PSADBW, DL, SadVecVT,
26881 V = DAG.getNode(X86ISD::PACKUS, DL, ByteVecVT,
26896 SDValue Shl = DAG.getNode(ISD::SHL, DL, VT, DAG.getBitcast(VT, V), ShifterV);
26897 V = DAG.getNode(ISD::ADD, DL, ByteVecVT, DAG.getBitcast(ByteVecVT, Shl),
26899 return DAG.getNode(ISD::SRL, DL, VT, DAG.getBitcast(VT, V), ShifterV);
26934 SDValue HiNibbles = DAG.getNode(ISD::SRL, DL, VT, Op, FourV);
26937 SDValue LoNibbles = DAG.getNode(ISD::AND, DL, VT, Op, M0F);
26942 SDValue HiPopCnt = DAG.getNode(X86ISD::PSHUFB, DL, VT, InRegLUT, HiNibbles);
26943 SDValue LoPopCnt = DAG.getNode(X86ISD::PSHUFB, DL, VT, InRegLUT, LoNibbles);
26944 return DAG.getNode(ISD::ADD, DL, VT, HiPopCnt, LoPopCnt);
27011 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Res,
27076 SDValue Lo = DAG.getNode(ISD::AND, DL, VT, In, NibbleMask);
27077 SDValue Hi = DAG.getNode(ISD::SRL, DL, VT, In, DAG.getConstant(4, DL, VT));
27098 Lo = DAG.getNode(X86ISD::PSHUFB, DL, VT, LoMask, Lo);
27099 Hi = DAG.getNode(X86ISD::PSHUFB, DL, VT, HiMask, Hi);
27100 return DAG.getNode(ISD::OR, DL, VT, Lo, Hi);
27152 RHS = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), RHS);
27325 SDValue SinVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
27327 SDValue CosVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ArgVT,
27407 Src = DAG.getNode(ISD::CONCAT_VECTORS, dl, WideVT, Src, DAG.getUNDEF(VT));
27512 SDValue Exract = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT,
27605 SDValue Extract = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OrigVT,
27841 Wide = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32, Wide,
27857 SDValue Res = DAG.getNode(ISD::MUL, dl, MulVT, Op0, Op1);
27893 SDValue Res = DAG.getNode(N->getOpcode(), dl, WideVT, InVec0, InVec1);
27905 Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(0),
27907 Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(0),
27909 Tmp = DAG.getNode(
27916 Hi = DAG.getNode(ISD::XOR, dl, HalfT, Tmp, Hi);
27917 Lo = DAG.getNode(ISD::XOR, dl, HalfT, Tmp, Lo);
27930 SDValue LHS = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32,
27932 SDValue RHS = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4f32,
27934 Results.push_back(DAG.getNode(N->getOpcode(), dl, MVT::v4f32, LHS, RHS));
27956 SDValue Res = DAG.getNode(N->getOpcode(), dl, ResVT, N0, N1);
27995 SDValue Val = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, InEltVT, In,
28013 In = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v8i64, In,
28073 SDValue Res = DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Lo, Hi);
28111 SDValue Res = DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, Lo, Hi);
28136 Res = DAG.getNode(N->getOpcode() == ISD::FP_TO_UINT ? ISD::AssertZext
28198 Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, Res, ZeroIdx);
28231 SDValue Or = DAG.getNode(ISD::OR, dl, MVT::v2i64, ZExtIn,
28235 SDValue Sub = DAG.getNode(ISD::FSUB, dl, MVT::v2f64, Or, VBias);
28285 cpInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
28287 cpInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(2),
28296 swapInL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
28298 swapInH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, HalfT, N->getOperand(3),
28375 SDValue Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Ld,
28449 SDValue Res = DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
28462 SDValue Res = DAG.getNode(ISD::CONCAT_VECTORS, dl, DstVT, Lo, Hi);
28491 SDValue PassThru = DAG.getNode(ISD::CONCAT_VECTORS, dl, WideVT,
28497 Mask = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v4i1, Mask,
31477 SDValue NewOp = TLO.DAG.getNode(ISD::AND, DL, VT, Op.getOperand(0), NewC);
32479 Res = DAG.getNode(Shuffle, DL, ShuffleVT, Res,
32495 Res = DAG.getNode(Shuffle, DL, ShuffleVT, NewV1, NewV2);
32570 Res = DAG.getNode(X86ISD::VPERMV, DL, MaskVT, VPermMask, Res);
32650 Res = DAG.getNode(AndOpcode, DL, MaskVT, Res, BitMask);
32668 Res = DAG.getNode(X86ISD::VPERMILPV, DL, MaskVT, Res, VPermMask);
32736 Res = DAG.getNode(X86ISD::PSHUFB, DL, ByteVT, Res, PSHUFBMaskOp);
33393 V = DAG.getNode(V.getOpcode(), DL, V.getValueType(), V.getOperand(0),
33409 V = DAG.getNode(W.getOpcode(), DL, W.getValueType(), V, V);
33415 V = DAG.getNode(W.getOpcode(), DL, W.getValueType(), V, W.getOperand(1));
33458 SDValue Horiz = DAG.getNode(Opcode0, DL, VT0, Lo, Hi);
33529 SDValue Scl = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, SrcVT, BcastLd,
33571 SDValue Res = DAG.getNode(X86ISD::VPERMI, DL, SrcVT, Src, N1);
33601 N10 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, SVT, N10, ZeroIdx);
33602 N11 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, SVT, N11, ZeroIdx);
33603 SDValue Scl = DAG.getNode(Opcode1, DL, SVT, N10, N11);
33605 return DAG.getNode(Opcode, DL, VT, N0, SclVec);
33744 V = DAG.getNode(X86ISD::PSHUFD, DL, DVT, V,
33776 return DAG.getNode(MappedMask[0] == 0 ? X86ISD::UNPCKL
33968 return DAG.getNode(X86ISD::ADDSUB, DL, VT, Opnd0, Opnd1);
34011 SDValue Concat = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, N0.getOperand(0),
34063 return DAG.getNode(HorizOp.getOpcode(), SDLoc(HorizOp),
34340 Op, TLO.DAG.getNode(NewOpc, dl, VT, Src.getOperand(0), NewSA));
34379 Op, TLO.DAG.getNode(NewOpc, dl, VT, Src.getOperand(0), NewSA));
34433 TLO.DAG.getNode(Opc, SDLoc(Op), VT, NewN0, NewN1));
34593 TLO.DAG.getNode(Opc, DL, Ext0.getValueType(), Ext0, Op.getOperand(1));
34635 SDValue ExtOp = TLO.DAG.getNode(Opc, DL, ExtVT, Ext0, Ext1);
34739 Op, TLO.DAG.getNode(Opc, SDLoc(Op), VT, DemandedLHS, DemandedRHS));
34766 SDValue NewShift = TLO.DAG.getNode(
34850 Op, TLO.DAG.getNode(X86ISD::VSRLI, SDLoc(Op), VT, Op0, Op1));
34889 Op, TLO.DAG.getNode(Opc, SDLoc(Op), VT, V, Op.getOperand(1)));
35172 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, N->getValueType(0), Shuffle,
35200 return DAG.getNode(
35302 V = DAG.getNode(X86ISD::PACKSS, DL, MVT::v16i8, V,
35368 return DAG.getNode(Op.getOpcode(), SDLoc(N), DstVT, LHS.getOperand(0),
35373 return DAG.getNode(Op.getOpcode(), SDLoc(N), DstVT,
35380 return DAG.getNode(Op.getOpcode(), SDLoc(N), DstVT,
35500 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, N0,
35623 SDValue Res = DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v4i32, N0,
35679 return DAG.getNode(FPOpcode, DL0, VT, LogicOp0.getOperand(0), CastedOp1);
35686 return DAG.getNode(FPOpcode, DL0, VT, LogicOp1.getOperand(0), CastedOp0);
35778 MinPos = DAG.getNode(BinOp, DL, SrcVT, Lo, Hi);
35796 MinPos = DAG.getNode(ISD::XOR, DL, SrcVT, Mask, MinPos);
35806 MinPos = DAG.getNode(ISD::UMIN, DL, SrcVT, MinPos, Upper);
35815 MinPos = DAG.getNode(ISD::XOR, DL, SrcVT, Mask, MinPos);
35817 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ExtractVT, MinPos,
35868 Match = DAG.getNode(BinOp, DL, Lo.getValueType(), Lo, Hi);
35901 Match = DAG.getNode(BinOp, DL, Lo.getValueType(), Lo, Hi);
35925 Result = DAG.getNode(ISD::AND, DL, CmpVT, Result, Mask);
35949 return DAG.getNode(ISD::SUB, DL, ExtractVT, Zero, Zext);
36020 SAD = DAG.getNode(ISD::ADD, DL, SadVT, SAD, Shuffle);
36029 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, Type, SAD,
36087 return DAG.getNode(N->getOpcode(), dl, VT, Src, Idx);
36147 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SrcSVT, SrcOp,
36157 SDValue ExtOp = DAG.getNode(OpCode, dl, MVT::i32, SrcOp,
36188 SDValue Ext0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, OpVT,
36190 SDValue Ext1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, OpVT,
36210 SDValue Ext0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL,
36213 SDValue Ext1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT,
36215 SDValue Ext2 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT,
36254 ExtOps.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Op, Index));
36301 Rdx = DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v8i8, Rdx,
36307 Rdx = DAG.getNode(ISD::CONCAT_VECTORS, DL, MVT::v16i8, Rdx,
36310 Rdx = DAG.getNode(X86ISD::PSADBW, DL, MVT::v2i64, Rdx,
36313 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Rdx, Index);
36328 Rdx = DAG.getNode(ISD::ADD, DL, Lo.getValueType(), Lo, Hi);
36336 Rdx = DAG.getNode(ISD::ADD, DL, MVT::v16i8, Rdx, Hi);
36337 Rdx = DAG.getNode(X86ISD::PSADBW, DL, MVT::v2i64, Rdx,
36340 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Rdx, Index);
36359 Rdx = DAG.getNode(HorizOpcode, DL, Lo.getValueType(), Hi, Lo);
36369 Rdx = DAG.getNode(HorizOpcode, DL, VecVT, Rdx, Rdx);
36371 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Rdx, Index);
36501 SDValue Res = DAG.getNode(ISD::AND, dl, BCVT, BC, Mask);
36603 SDValue Or = DAG.getNode(ISD::OR, DL, CondVT, Cond, CastRHS);
36610 SDValue And = DAG.getNode(ISD::AND, DL, CondVT, Cond, CastLHS);
36619 SDValue AndN = DAG.getNode(X86ISD::ANDNP, DL, AndNVT, CastCond, CastRHS);
36710 R = DAG.getNode(ISD::MUL, DL, VT, R, DAG.getConstant(AbsDiff, DL, VT));
36714 R = DAG.getNode(ISD::ADD, DL, VT, R, SDValue(FalseC, 0));
36981 return DAG.getNode(Opcode, DL, N->getValueType(0), LHS, RHS);
37118 return DAG.getNode(ISD::USUBSAT, DL, VT, OpLHS, OpRHS);
37133 OpRHS = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
37135 return DAG.getNode(ISD::USUBSAT, DL, VT, OpLHS, OpRHS);
37150 return DAG.getNode(ISD::USUBSAT, DL, VT, OpLHS, OpRHS);
37194 return DAG.getNode(ISD::UADDSAT, DL, VT, OpLHS, OpRHS);
37206 return DAG.getNode(ISD::UADDSAT, DL, VT, OpLHS, OpRHS);
37624 Cond = DAG.getNode(ISD::SHL, DL, Cond.getValueType(), Cond,
37637 Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
37672 Cond = DAG.getNode(ISD::MUL, DL, Cond.getValueType(), Cond,
37677 Cond = DAG.getNode(ISD::ADD, DL, Cond.getValueType(), Cond,
37786 SDValue Diff = DAG.getNode(ISD::SUB, DL, VT, Const, Add.getOperand(1));
37790 return DAG.getNode(ISD::ADD, DL, VT, CMov, Add.getOperand(1));
37897 SDValue MulLo = DAG.getNode(ISD::MUL, DL, ReducedVT, NewN0, NewN1);
37905 SDValue MulHi = DAG.getNode(Mode == MULS16 ? ISD::MULHS : ISD::MULHU, DL,
37927 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, ResLo, ResHi);
37934 SDValue Result = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
37936 Result = DAG.getNode(ISD::SHL, DL, VT, Result,
37938 Result = DAG.getNode(isAdd ? ISD::ADD : ISD::SUB, DL, VT, Result,
37944 SDValue Result = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
37946 Result = DAG.getNode(X86ISD::MUL_IMM, DL, VT, Result,
37948 Result = DAG.getNode(isAdd ? ISD::ADD : ISD::SUB, DL, VT, Result,
37967 return DAG.getNode(ISD::ADD, DL, VT, N->getOperand(0),
37992 return DAG.getNode(ISD::ADD, DL, VT, N->getOperand(0),
38005 SDValue Shift1 = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
38007 SDValue Shift2 = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
38009 return DAG.getNode(ISD::ADD, DL, VT, Shift1, Shift2);
38148 SDValue NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
38151 NewMul = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
38186 NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
38189 NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, N->getOperand(0),
38193 NewMul = DAG.getNode(ISD::SHL, DL, VT, NewMul,
38196 NewMul = DAG.getNode(X86ISD::MUL_IMM, DL, VT, NewMul,
38201 NewMul = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
38213 NewMul = DAG.getNode(
38215 DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
38220 NewMul = DAG.getNode(ISD::SUB, DL, VT,
38224 NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
38229 NewMul = DAG.getNode(ISD::SUB, DL, VT, N->getOperand(0), NewMul);
38231 NewMul = DAG.getNode(ISD::SUB, DL, VT, NewMul, N->getOperand(0));
38234 NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
38237 NewMul = DAG.getNode(ISD::ADD, DL, VT, NewMul, N->getOperand(0));
38238 NewMul = DAG.getNode(ISD::ADD, DL, VT, NewMul, N->getOperand(0));
38241 NewMul = DAG.getNode(ISD::SHL, DL, VT, N->getOperand(0),
38244 NewMul = DAG.getNode(ISD::SUB, DL, VT, NewMul, N->getOperand(0));
38245 NewMul = DAG.getNode(ISD::SUB, DL, VT, NewMul, N->getOperand(0));
38290 return DAG.getNode(ISD::AND, DL, VT, N00, DAG.getConstant(Mask, DL, VT));
38305 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N0);
38350 DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT, N00, DAG.getValueType(SVT));
38355 return DAG.getNode(ISD::SHL, DL, VT, NN,
38358 return DAG.getNode(ISD::SRA, DL, VT, NN,
38407 SDValue NewShift = DAG.getNode(ISD::SRL, DL, VT, N0.getOperand(0), N1);
38408 return DAG.getNode(ISD::AND, DL, VT, NewShift, NewMask);
38499 SDValue Concat = DAG.getNode(ISD::CONCAT_VECTORS, dl, MVT::v16i32,
38587 return DAG.getNode(X86ISD::VSRAI, SDLoc(N), VT, N0.getOperand(0),
38733 OnesOrZeroesF = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f32,
38739 SDValue ANDed = DAG.getNode(ISD::AND, DL, IntVT, OnesOrZeroesI,
38774 return DAG.getNode(X86ISD::ANDNP, SDLoc(N), VT, X, Y);
38832 SDValue Op = DAG.getNode(Narrow->getOpcode(), DL, VT, N0, N1);
38841 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT,
38878 SDValue FPLogic = DAG.getNode(FPOpcode, DL, N00Type, N00, N10);
38914 SDValue Shift = DAG.getNode(X86ISD::VSRLI, DL, VT0, Op0, ShAmt);
39023 SDValue Sub = DAG.getNode(ISD::SUB, dl, MVT::i32, SizeC, Index);
39027 SDValue LShr = DAG.getNode(ISD::SRL, dl, VT, AllOnes, Sub);
39029 return DAG.getNode(ISD::AND, dl, VT, Inp, LShr);
39070 DAG.getNode(ISD::SRL, DL, VT, X,
39073 X = DAG.getNode(ISD::XOR, DL, MVT::i32, Lo, Hi);
39076 SDValue Parity = DAG.getNode(ISD::AND, DL, MVT::i32,
39084 SDValue Hi16 = DAG.getNode(ISD::SRL, DL, VT, X,
39086 X = DAG.getNode(ISD::XOR, DL, VT, X, Hi16);
39092 DAG.getNode(ISD::SRL, DL, VT, X,
39177 MVT::v4i32, DAG.getNode(X86ISD::FAND, SDLoc(N), MVT::v4f32,
39192 DAG.getNode(ISD::AND, dl, MVT::i32, LHS, RHS));
39280 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N), VT, Shuffle,
39331 DAG.getNode(X86ISD::ANDNP, DL, VT, DAG.getBitcast(VT, N0.getOperand(1)),
39333 return DAG.getNode(ISD::OR, DL, VT, X, Y);
39410 SDValue SubOp1 = DAG.getNode(ISD::XOR, DL, MaskVT, V, Mask);
39426 SDValue Res = DAG.getNode(ISD::SUB, DL, MaskVT, SubOp1, SubOp2);
39499 SDValue Scc = DAG.getNode(ISD::SRL, dl, MVT::i32, Trunc,
39565 Ret = DAG.getNode(ISD::OR, SDLoc(OR), VT, NewLHS, NewRHS);
39581 Ret = DAG.getNode(ISD::OR, SDLoc(OR), VT, Ret, NewRHS);
39600 DAG.getNode(X86ISD::FOR, SDLoc(N), MVT::v4f32,
39861 return DAG.getNode(X86ISD::PCMPGT, SDLoc(N), VT, Shift.getOperand(0), Ones);
39912 return DAG.getNode(ISD::SMAX, DL, InVT, SMin, In.getOperand(1));
40055 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Res,
40144 Operands[1] = DAG.getNode(ISD::SUB, DL, InVT, Operands[1], VecOnes);
40239 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
40242 SDValue NewVec = DAG.getNode(ISD::CONCAT_VECTORS, dl, RegVT, Load1, Load2);
40442 SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT,
40557 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Ch0, Ch1);
40723 return DAG.getNode(ISD::TokenFactor, StDL, MVT::Other, LoSt, HiSt);
40739 SDValue NewExtract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::f64,
40926 return DAG.getNode(HorizOpcode, SDLoc(N), VT, LHS, RHS);
40969 return DAG.getNode(SrcOpcode, DL, VT, Trunc0, Trunc1);
41040 In = DAG.getNode(ISD::AND, DL, InVT, In, DAG.getConstant(Mask, DL, InVT));
41051 In = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, InVT, In,
41212 return DAG.getNode(Opc, DL, VT, LHS, RHS);
41348 return DAG.getNode(X86ISD::VPMADDUBSW, DL, ResVT, Ops[0], Ops[1]);
41709 SDValue IntOp = DAG.getNode(IntOpcode, dl, IntVT, Op0, Op1);
41737 MVT::v4i32, DAG.getNode(X86ISD::FXOR, SDLoc(N), MVT::v4f32,
41777 return DAG.getNode(X86ISD::BEXTR, SDLoc(N), VT, Op0,
41832 return DAG.getNode(X86ISD::FANDN, DL, VT, N0.getOperand(0), N1);
41836 return DAG.getNode(X86ISD::FANDN, DL, VT, N1.getOperand(0), N0);
41908 return DAG.getNode(NewOp, SDLoc(N), N->getValueType(0),
41933 return DAG.getNode(MinMaxOp, DL, VT, Op0, Op1, N->getFlags());
41938 return DAG.getNode(MinMaxOp, DL, VT, Op0, Op1, N->getFlags());
41940 return DAG.getNode(MinMaxOp, DL, VT, Op1, Op0, N->getFlags());
41969 SDValue MinOrMax = DAG.getNode(MinMaxOp, DL, VT, Op1, Op0);
42070 return DAG.getNode(ISD::AND, SDLoc(N), VT, DAG.getBitcast(VT, Not),
42092 return DAG.getNode(X86ISD::BT, SDLoc(N), MVT::i32, N0, DemandedN1);
42139 CMovOp0 = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, DstVT, CMovOp0, N1);
42140 CMovOp1 = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, DstVT, CMovOp1, N1);
42188 SDValue Tmp = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, MVT::v4i32,
42258 return DAG.getNode(ISD::ADD, SDLoc(Add), VT, NewExt, NewConstant, Flags);
42392 Vec = DAG.getNode(ISD::AND, DL, VT, Vec, BitMask);
42403 return DAG.getNode(ISD::SRL, DL, VT, Vec,
42474 return DAG.getNode(ISD::SUB, DL, VT, Zext, DAG.getConstant(1, DL, VT));
42524 V = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(V), V.getValueType(),
42592 return DAG.getNode(ISD::AND, dl, VT,
42593 DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
42604 return DAG.getNode(ISD::AND, dl, VT,
42605 DAG.getNode(X86ISD::SETCC_CARRY, dl, VT,
42765 Cmp = DAG.getNode(ISD::OR, DL, CmpVT, Cmp1, Cmp2);
42767 SDValue Cmp1 = DAG.getNode(ISD::XOR, DL, VecVT, A, B);
42768 SDValue Cmp2 = DAG.getNode(ISD::XOR, DL, VecVT, C, D);
42769 Cmp = DAG.getNode(ISD::OR, DL, VecVT, Cmp1, Cmp2);
42773 Cmp = DAG.getNode(ISD::AND, DL, CmpVT, Cmp1, Cmp2);
42781 Cmp = DAG.getNode(ISD::XOR, DL, VecVT, VecX, VecY);
42796 SDValue PT = DAG.getNode(X86ISD::PTEST, DL, MVT::i32, BCCmp, BCCmp);
42829 SDValue Add = DAG.getNode(ISD::ADD, DL, OpVT, RHS, LHS.getOperand(1));
42836 SDValue Add = DAG.getNode(ISD::ADD, DL, OpVT, LHS, RHS.getOperand(1));
42929 return DAG.getNode(ISD::XOR, DL, VT,
43137 SDValue NewAnd = DAG.getNode(ISD::AND, DL, IntVT,
43176 SDValue NewExtElt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, TruncVT,
43382 Op = DAG.getNode(ISD::AND, dl, VT, Op.getOperand(0),
43384 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
43436 return DAG.getNode(X86ISD::CMP, dl, MVT::i32, Op,
43456 SDValue Res = DAG.getNode(GenericOpc, DL, VT, LHS, RHS);
43467 Op = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Op);
43513 DAG.getNode(ISD::AND, DL, VT,
43514 DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
43576 return DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
43594 return DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
43654 return DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
43666 SDValue Cmp1 = DAG.getNode(X86ISD::CMP, DL, MVT::i32, Z, One);
43667 return DAG.getNode(X86ISD::SETCC_CARRY, DL, VT,
43674 SDValue Cmp1 = DAG.getNode(X86ISD::CMP, DL, MVT::i32, Z, One);
43745 SDValue Concat = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Madd, Zero);
43751 return DAG.getNode(ISD::ADD, DL, VT, Concat, OtherOp, Flags);
43818 Sad = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Sad,
43826 return DAG.getNode(ISD::ADD, DL, VT, Sad, OtherOp, Flags);
43929 return DAG.getNode(X86ISD::VPMADDWD, DL, ResVT,
44053 return DAG.getNode(X86ISD::VPMADDWD, DL, ResVT, Ops[0], Ops[1]);
44103 return DAG.getNode(ISD::SUB, DL, VT, Op1, SExt);
44111 return DAG.getNode(ISD::SUB, DL, VT, Op0, SExt);
44165 return DAG.getNode(ISD::USUBSAT, SDLoc(N), VT, SubusLHS, SubusRHS);
44192 SDValue UMin = DAG.getNode(ISD::UMIN, SDLoc(SubusLHS), ExtType, SubusRHS,
44197 SDValue Psubus = DAG.getNode(ISD::USUBSAT, SDLoc(N), ShrinkedType,
44221 SDValue NewXor = DAG.getNode(ISD::XOR, SDLoc(Op1), VT,
44224 return DAG.getNode(ISD::ADD, SDLoc(N), VT, NewXor,
44310 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, MVT::f64,
44340 return DAG.getNode(Op0.getOpcode(), DL, VT,
44353 Res = DAG.getNode(X86ISD::VPERMILPI, DL, MVT::v8f32, Res,
44368 return DAG.getNode(Op0.getOpcode(), DL, VT,
44615 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N), VT,
44659 SDValue NewExtract = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NewExtVT,
44770 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Src.getOperand(0),
44795 return DAG.getNode(N->getOpcode(), SDLoc(N), N->getValueType(0), RHS, LHS);
44822 return DAG.getNode(N->getOpcode(), dl, MVT::v2i64, LHS, RHS);
44832 return DAG.getNode(N->getOpcode(), dl, MVT::v2i64, LHS, RHS);
45095 return DAG.getNode(X86ISD::NT_BRIND, dl, MVT::Other, Value, Addr);
lib/Target/X86/X86SelectionDAGInfo.cpp 173 DAG.getNode(ISD::ADD, dl, AddrVT, Dst,
284 DAG.getNode(ISD::ADD, dl, DstVT, Dst, DAG.getConstant(Offset, dl, DstVT)),
285 DAG.getNode(ISD::ADD, dl, SrcVT, Src, DAG.getConstant(Offset, dl, SrcVT)),
lib/Target/XCore/XCoreISelLowering.cpp 292 GA = DAG.getNode(ISD::ADD, DL, MVT::i32, GA, Remaining);
360 SDValue ScaledIndex = DAG.getNode(ISD::SHL, dl, MVT::i32, Index,
384 LowAddr = DAG.getNode(ISD::ADD, DL, MVT::i32, Base,
386 HighAddr = DAG.getNode(ISD::ADD, DL, MVT::i32, Base,
394 SDValue LowShifted = DAG.getNode(ISD::SRL, DL, MVT::i32, Low, LowShift);
395 SDValue HighShifted = DAG.getNode(ISD::SHL, DL, MVT::i32, High, HighShift);
396 SDValue Result = DAG.getNode(ISD::OR, DL, MVT::i32, LowShifted, HighShifted);
397 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Low.getValue(1),
449 SDValue HighAddr = DAG.getNode(ISD::ADD, DL, MVT::i32, BasePtr,
455 SDValue HighShifted = DAG.getNode(ISD::SHL, DL, MVT::i32, High,
457 SDValue Result = DAG.getNode(ISD::OR, DL, MVT::i32, Low, HighShifted);
458 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Low.getValue(1),
502 SDValue High = DAG.getNode(ISD::SRL, dl, MVT::i32, Value,
507 SDValue HighAddr = DAG.getNode(ISD::ADD, dl, MVT::i32, BasePtr,
512 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, StoreLow, StoreHigh);
647 LL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
649 RL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
651 AddendL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
653 AddendH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
665 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
673 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
676 LH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
678 RH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
684 RH = DAG.getNode(ISD::MUL, dl, MVT::i32, LL, RH);
685 LH = DAG.getNode(ISD::MUL, dl, MVT::i32, LH, RL);
686 Hi = DAG.getNode(ISD::ADD, dl, MVT::i32, Hi, RH);
687 Hi = DAG.getNode(ISD::ADD, dl, MVT::i32, Hi, LH);
688 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
705 SDValue LHSL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
708 SDValue LHSH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
711 SDValue RHSL = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
714 SDValue RHSH = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
730 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
748 SDValue nextPtr = DAG.getNode(ISD::ADD, dl, PtrVT, VAList,
833 Stack = DAG.getNode(ISD::ADD, dl, MVT::i32, Stack, FrameToArgs);
834 Stack = DAG.getNode(ISD::ADD, dl, MVT::i32, Stack, Offset);
888 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
894 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
900 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
905 Addr = DAG.getNode(ISD::ADD, dl, MVT::i32, Trmp,
1648 SDValue Result = DAG.getNode(ISD::AND, dl, VT, N2,
1662 SDValue Result = DAG.getNode(ISD::ADD, dl, VT, N0, N2);
1684 SDValue Result = DAG.getNode(ISD::SUB, dl, VT,
1699 SDValue Result = DAG.getNode(ISD::SUB, dl, VT, N0, N2);
1725 SDValue Lo = DAG.getNode(ISD::ADD, dl, VT, N2, N3);
1763 SDValue Mul0L = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
1765 SDValue Mul1L = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
1767 SDValue Addend0L = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
1769 SDValue Addend1L = DAG.getNode(ISD::EXTRACT_ELEMENT, dl, MVT::i32,
1775 return DAG.getNode(ISD::BUILD_PAIR, dl, MVT::i64, Lo, Hi);
unittests/CodeGen/AArch64SelectionDAGTest.cpp 104 auto Op = DAG->getNode(ISD::EXTRACT_SUBVECTOR, Loc, VecVT, Vec, ZeroIdx);
133 auto Op = DAG->getNode(ISD::EXTRACT_SUBVECTOR, Loc, VecVT, Vec, ZeroIdx);
150 auto Op = DAG->getNode(ISD::EXTRACT_SUBVECTOR, Loc, VecVT, Vec, ZeroIdx);
168 auto N0 = DAG->getNode(ISD::AND, Loc, IntVT, Mask, UnknownOp);
170 auto Op = DAG->getNode(ISD::ADD, Loc, IntVT, N0, N1);
190 auto N1 = DAG->getNode(ISD::AND, Loc, IntVT, Mask, UnknownOp);
191 auto Op = DAG->getNode(ISD::SUB, Loc, IntVT, N0, N1);