|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/CodeGen/SelectionDAG.h 914 SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue Operand,
References
include/llvm/CodeGen/SelectionDAG.h 793 return getNode(ISD::SPLAT_VECTOR, DL, VT, Op);
lib/CodeGen/SelectionDAG/DAGCombiner.cpp 1089 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, DL, VT, SDValue(ExtLoad, 0));
1128 return DAG.getNode(ExtOpc, DL, PVT, Op);
1134 return DAG.getNode(ISD::ANY_EXTEND, DL, PVT, Op);
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));
1308 return DAG.getNode(Op.getOpcode(), SDLoc(Op), VT, Op.getOperand(0));
1345 SDValue Result = DAG.getNode(ISD::TRUNCATE, DL, VT, NewLD);
2143 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Not);
2467 SDValue ZExt = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0));
3092 SDValue SExt = DAG.getNode(ISD::SIGN_EXTEND, DL, VT, N1.getOperand(0));
3105 return DAG.getNode(ISD::ABS, SDLoc(N), VT, S0);
3716 SDValue C1 = DAG.getNode(ISD::CTTZ, DL, VT, N1);
3984 N0 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N0);
3985 N1 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N1);
3990 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
4040 N0 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N0);
4041 N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N1);
4046 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
4116 SDValue Lo = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N->getOperand(0));
4117 SDValue Hi = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N->getOperand(1));
4123 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
4125 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
4159 SDValue Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N->getOperand(0));
4160 SDValue Hi = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N->getOperand(1));
4166 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
4168 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
4291 return DAG.getNode(HandOpcode, DL, VT, Logic);
4313 return DAG.getNode(HandOpcode, DL, VT, Logic);
4334 return DAG.getNode(HandOpcode, DL, VT, Logic);
4351 return DAG.getNode(HandOpcode, DL, VT, Logic);
4641 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SL, HalfVT,
4648 return DAG.getNode(ISD::ZERO_EXTEND, SL, VT, And);
5108 SDValue Zext = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N),
5274 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, SubRHS.getOperand(0));
5427 SDValue Res = DAG.getNode(ISD::BSWAP, SDLoc(N), VT, N00);
5587 SDValue BSwap = DAG.getNode(ISD::BSWAP, DL, VT,
6153 return DAG.getNode(ISD::TRUNCATE, SDLoc(LHS), LHS.getValueType(), Rot);
6602 CombinedValue = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT,
6607 CombinedValue = DAG.getNode(ISD::BSWAP, SDLoc(N), VT, CombinedValue);
6771 return NeedsBswap ? DAG.getNode(ISD::BSWAP, SDLoc(N), VT, NewLoad) : NewLoad;
6930 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, V);
7008 return DAG.getNode(ISD::ABS, DL, VT, S0);
7212 SDValue Trunc00 = DAG.getNode(ISD::TRUNCATE, DL, TruncVT, N00);
7213 SDValue Trunc01 = DAG.getNode(ISD::TRUNCATE, DL, TruncVT, N01);
7408 SDValue Ext = DAG.getNode(N0.getOpcode(), DL, VT, N0Op0.getOperand(0));
7437 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N0), VT, NewSHL);
7636 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, DL, TruncVT,
7638 return DAG.getNode(ISD::SIGN_EXTEND, DL,
7701 return DAG.getNode(ISD::TRUNCATE, DL, VT, SRA);
7794 return DAG.getNode(ISD::TRUNCATE, DL, VT,
7834 DAG.getNode(ISD::ANY_EXTEND, DL, VT, SmallShift),
8017 return DAG.getNode(ISD::ABS, SDLoc(N), VT, N0);
8033 return DAG.getNode(ISD::BSWAP, SDLoc(N), VT, N0);
8046 return DAG.getNode(ISD::BITREVERSE, SDLoc(N), VT, N0);
8059 return DAG.getNode(ISD::CTLZ, SDLoc(N), VT, N0);
8064 return DAG.getNode(ISD::CTLZ_ZERO_UNDEF, SDLoc(N), VT, N0);
8076 return DAG.getNode(ISD::CTLZ_ZERO_UNDEF, SDLoc(N), VT, N0);
8086 return DAG.getNode(ISD::CTTZ, SDLoc(N), VT, N0);
8091 return DAG.getNode(ISD::CTTZ_ZERO_UNDEF, SDLoc(N), VT, N0);
8103 return DAG.getNode(ISD::CTTZ_ZERO_UNDEF, SDLoc(N), VT, N0);
8113 return DAG.getNode(ISD::CTPOP, SDLoc(N), VT, N0);
8240 NotCond = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, NotCond);
8247 NotCond = DAG.getNode(ISD::SIGN_EXTEND, DL, VT, NotCond);
8253 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Cond);
8259 Cond = DAG.getNode(ISD::SIGN_EXTEND, DL, VT, Cond);
8273 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Cond);
8279 Cond = DAG.getNode(ISD::SIGN_EXTEND, DL, VT, Cond);
8286 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Cond);
8655 SDValue ExtendedCond = DAG.getNode(ExtendOpcode, DL, VT, Cond);
8713 return DAG.getNode(ISD::ABS, DL, VT, LHS);
8758 SDValue WideLHS = DAG.getNode(ExtOpcode, DL, WideVT, LHS);
8759 SDValue WideRHS = DAG.getNode(ExtOpcode, DL, WideVT, RHS);
8902 return DAG.getNode(Opcode, DL, VT, N0);
8925 DAG.getNode(FoldOpc, DL, VT, Op1),
8926 DAG.getNode(FoldOpc, DL, VT, Op2));
9046 Ops.push_back(DAG.getNode(ExtType, DL, ExtLoad->getValueType(0), SOp));
9148 DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(), NewValue);
9221 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(Load),
9271 CastA = DAG.getNode(CastOpcode, DL, VT, A);
9272 CastB = DAG.getNode(CastOpcode, DL, VT, B);
9344 DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(), ExtLoad);
9369 SDValue PassThru = DAG.getNode(ExtOpc, dl, VT, Ld->getPassThru());
9421 return DAG.getNode(ISD::SIGN_EXTEND, DL, VT, N0.getOperand(0));
9453 return DAG.getNode(ISD::SIGN_EXTEND, DL, VT, Op);
9458 return DAG.getNode(ISD::TRUNCATE, DL, VT, Op);
9465 Op = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N0), VT, Op);
9467 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N0), VT, Op);
9524 DAG.getNode(ISD::TRUNCATE, DL, N0.getValueType(), And);
9530 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(LN00),
9616 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0);
9696 return DAG.getNode(ISD::CTPOP, DL, VT, NewZext);
9709 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT,
9849 DAG.getNode(ISD::TRUNCATE, DL, N0.getValueType(), And);
9855 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(LN00),
9939 ShAmt = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, ShAmt);
9942 DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0)),
9968 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, N0.getOperand(0));
10030 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
10133 return DAG.getNode(ISD::TRUNCATE, DL, N->getValueType(0), NewAssert);
10152 return DAG.getNode(ISD::TRUNCATE, DL, N->getValueType(0), NewAssert);
10406 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N00);
10416 return DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, SDLoc(N), VT,
10549 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
10553 SDValue C = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0);
10564 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, N0.getOperand(0));
10567 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
10618 SDValue TruncOp0 = DAG.getNode(ISD::TRUNCATE, SL, VT, N0.getOperand(1));
10619 SDValue TruncOp1 = DAG.getNode(ISD::TRUNCATE, SL, VT, N0.getOperand(2));
10635 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SL, VT, N0.getOperand(0));
10651 SDValue TruncOp = DAG.getNode(ISD::TRUNCATE, DL, SVT, Op);
10696 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Shorter);
10755 SDValue NV = DAG.getNode(ISD::TRUNCATE, SDLoc(V), VTs[i], V);
10796 auto X = DAG.getNode(ISD::TRUNCATE, SL, VT, N0.getOperand(0));
10797 auto Y = DAG.getNode(ISD::TRUNCATE, SL, VT, N0.getOperand(1));
10840 SDValue NarrowL = DAG.getNode(ISD::TRUNCATE, DL, VT, N0.getOperand(0));
10841 SDValue NarrowR = DAG.getNode(ISD::TRUNCATE, DL, VT, N0.getOperand(1));
10940 SDValue FPOp = DAG.getNode(FPOpcode, SDLoc(N), VT, LogicOp0.getOperand(0));
10943 return DAG.getNode(ISD::FNEG, SDLoc(N), VT, FPOp);
11096 X = DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, X);
11107 X = DAG.getNode(ISD::TRUNCATE, SDLoc(X), VT, X);
11223 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(BV), SrcEltVT, Op);
11395 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11397 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11409 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11411 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11452 DAG.getNode(ISD::FP_EXTEND, SL, VT, U),
11453 DAG.getNode(ISD::FP_EXTEND, SL, VT, V),
11478 DAG.getNode(ISD::FP_EXTEND, SL, VT, X),
11479 DAG.getNode(ISD::FP_EXTEND, SL, VT, Y),
11481 DAG.getNode(ISD::FP_EXTEND, SL, VT, U),
11482 DAG.getNode(ISD::FP_EXTEND, SL, VT, V),
11584 DAG.getNode(ISD::FNEG, SL, VT, N1), Flags);
11591 DAG.getNode(ISD::FNEG, SL, VT,
11602 DAG.getNode(ISD::FNEG, SL, VT, N00), N01,
11603 DAG.getNode(ISD::FNEG, SL, VT, N1), Flags);
11615 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11617 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11619 DAG.getNode(ISD::FNEG, SL, VT, N1), Flags);
11631 DAG.getNode(ISD::FNEG, SL, VT,
11632 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11634 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11652 return DAG.getNode(ISD::FNEG, SL, VT,
11654 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11656 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11675 return DAG.getNode(ISD::FNEG, SL, VT,
11677 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11679 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11698 DAG.getNode(ISD::FNEG, SL, VT,
11709 DAG.getNode(ISD::FNEG, SL, VT,
11713 DAG.getNode(ISD::FNEG, SL, VT, N20),
11729 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11731 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11733 DAG.getNode(ISD::FNEG, SL, VT,
11752 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11754 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11757 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11759 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11761 DAG.getNode(ISD::FNEG, SL, VT,
11777 DAG.getNode(ISD::FNEG, SL, VT, N1.getOperand(0)),
11780 DAG.getNode(ISD::FNEG, SL, VT,
11781 DAG.getNode(ISD::FP_EXTEND, SL,
11783 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11806 DAG.getNode(ISD::FNEG, SL, VT,
11807 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11809 DAG.getNode(ISD::FP_EXTEND, SL, VT, N101),
11811 DAG.getNode(ISD::FNEG, SL, VT,
11812 DAG.getNode(ISD::FP_EXTEND, SL,
11814 DAG.getNode(ISD::FP_EXTEND, SL, VT,
11872 DAG.getNode(ISD::FNEG, SL, VT, Y), Flags);
11892 DAG.getNode(ISD::FNEG, SL, VT, X.getOperand(1)), Y,
11896 DAG.getNode(ISD::FNEG, SL, VT, X.getOperand(1)), Y,
11897 DAG.getNode(ISD::FNEG, SL, VT, Y), Flags);
11902 DAG.getNode(ISD::FNEG, SL, VT, Y), Flags);
12145 return DAG.getNode(ISD::FNEG, DL, VT, N1, Flags);
12154 return DAG.getNode(ISD::FNEG, DL, VT, N1->getOperand(1), Flags);
12157 return DAG.getNode(ISD::FNEG, DL, VT, N1->getOperand(0), Flags);
12258 return DAG.getNode(ISD::FNEG, DL, VT, N0);
12305 return DAG.getNode(ISD::FNEG, DL, VT,
12306 DAG.getNode(ISD::FABS, DL, VT, X));
12308 return DAG.getNode(ISD::FABS, DL, VT, X);
12402 SDValue RHSNeg = DAG.getNode(ISD::FNEG, DL, VT, N0);
12414 DAG.getNode(ISD::FNEG, DL, VT, N1, Flags), N2);
12567 RV = DAG.getNode(ISD::FP_EXTEND, SDLoc(N1), VT, RV);
12681 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
12684 return DAG.getNode(ISD::FNEG, SDLoc(N), VT,
12685 DAG.getNode(ISD::FABS, SDLoc(N0), VT, N0));
12698 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
12742 return DAG.getNode(ISD::FCBRT, SDLoc(N), VT, N->getOperand(0), Flags);
12777 SDValue Sqrt = DAG.getNode(ISD::FSQRT, DL, VT, N->getOperand(0), Flags);
12778 SDValue SqrtSqrt = DAG.getNode(ISD::FSQRT, DL, VT, Sqrt, Flags);
12814 return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0.getOperand(0));
12818 return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0.getOperand(0));
12837 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
12845 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
12898 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
12906 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
12963 return DAG.getNode(ExtOp, SDLoc(N), VT, Src);
12966 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Src);
12982 return DAG.getNode(ISD::FP_TO_SINT, SDLoc(N), VT, N0);
12997 return DAG.getNode(ISD::FP_TO_UINT, SDLoc(N), VT, N0);
13069 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, N0);
13074 return DAG.getNode(ISD::FP16_TO_FP, SDLoc(N), VT, N0.getOperand(0));
13085 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, In);
13117 return DAG.getNode(ISD::FCEIL, SDLoc(N), VT, N0);
13128 return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0);
13152 return DAG.getNode(ISD::FFLOOR, SDLoc(N), VT, N0);
13164 return DAG.getNode(ISD::FNEG, SDLoc(N), VT, N0);
13207 DAG.getNode(ISD::FNEG, SDLoc(N), VT, N0.getOperand(1)),
13259 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
13268 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0.getOperand(0));
13891 Val = DAG.getNode(ISD::FTRUNC, SDLoc(ST), STMemType, Val);
13896 Val = DAG.getNode(ISD::TRUNCATE, SDLoc(ST), STMemType, Val);
13919 Val = DAG.getNode(ISD::ANY_EXTEND, SDLoc(LD), LDType, Val);
13922 Val = DAG.getNode(ISD::SIGN_EXTEND, SDLoc(LD), LDType, Val);
13925 Val = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(LD), LDType, Val);
14014 Val = DAG.getNode(ISD::TRUNCATE, SDLoc(LD), LDMemType, Val);
14409 DAG->getNode(ISD::ZERO_EXTEND, SDLoc(LastInst), FinalType, LastInst);
14826 IVal = DAG.getNode(ISD::TRUNCATE, SDLoc(IVal), VT, IVal);
16477 Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Lo.getOperand(0));
16478 Hi = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Hi.getOperand(0));
16741 Load = DAG.getNode(ISD::TRUNCATE, SDLoc(EVE), ResultVT, Load);
16859 return DAG.getNode(ISD::TRUNCATE, DL, ScalarVT, BCSrc);
17620 return DAG.getNode(FoundZeroExtend ? ISD::ZERO_EXTEND : ISD::ANY_EXTEND, DL,
17661 return DAG.getNode(ISD::SPLAT_VECTOR, SDLoc(N), VT, V);
17906 SDValue Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), NVT, Scalar);
17950 DAG.getNode(ISD::TRUNCATE, SDLoc(N), MinVT, Op.getOperand(i)));
18313 Src = DAG.getNode(ISD::TRUNCATE, SDLoc(N), InVT, Src);
18615 DAG.getNode(ISD::ANY_EXTEND_VECTOR_INREG,
18913 SDValue Insert = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VT, NewBO);
19211 DAG.getNode(ISD::TRUNCATE, SDLoc(InVal), VT.getScalarType(), InVal);
19212 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), VT, Val);
19403 return DAG.getNode(ISD::FP16_TO_FP, SDLoc(N), N->getValueType(0),
19423 Res = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Res);
19435 return DAG.getNode(NewOpcode, SDLoc(N), N->getValueType(0), N0);
19945 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
19960 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
20119 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2), VT, SCC);
20122 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2), VT, SCC);
20161 return DAG.getNode(ISD::CTTZ, DL, VT, N0);
20168 return DAG.getNode(ISD::CTLZ, DL, VT, N0);
20251 SDValue Ctlz = DAG.getNode(ISD::CTLZ, DL, VT, V);
20449 SDValue Fabs = DAG.getNode(ISD::FABS, DL, VT, Op);
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp 406 SDValue ScVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
528 Value = DAG.getNode(ISD::BITCAST, dl, NVT, Value);
644 Value = DAG.getNode(ISD::TRUNCATE, dl, StVT, Value);
650 Value = DAG.getNode(ISD::TRUNCATE, dl,
703 RVal = DAG.getNode(ISD::BITCAST, dl, VT, Res);
897 Value = DAG.getNode(ExtendOp, dl, Node->getValueType(0), Load);
913 Value = DAG.getNode(ISD::FP16_TO_FP, dl, DestVT, Result);
1446 State.IntValue = DAG.getNode(ISD::BITCAST, DL, IVT, Value);
1493 return DAG.getNode(ISD::BITCAST, DL, State.FloatVT, NewIntValue);
1520 SDValue AbsValue = DAG.getNode(ISD::FABS, DL, FloatVT, Mag);
1521 SDValue NegValue = DAG.getNode(ISD::FNEG, DL, FloatVT, AbsValue);
1539 SignBit = DAG.getNode(ISD::ZERO_EXTEND, DL, MagVT, SignBit);
1550 SignBit = DAG.getNode(ISD::TRUNCATE, DL, MagVT, SignBit);
1826 Vec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, V);
1934 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Node->getOperand(0));
1989 SDValue Vec1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value1);
1992 Vec2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value2);
2405 SDValue Tmp1 = DAG.getNode(ISD::SINT_TO_FP, dl, DestVT, Op0);
2490 return DAG.getNode(OpToUse, dl, DestVT,
2491 DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND,
2530 SDValue Operation = DAG.getNode(OpToUse, dl, NewOutTy, LegalOp);
2534 return DAG.getNode(ISD::TRUNCATE, dl, DestVT, Operation);
2558 Tmp = (Sz > 8 ? DAG.getNode(ISD::BSWAP, dl, VT, Op) : Op);
2697 SDValue FA = DAG.getNode(
2931 Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0),
2980 Op0 = DAG.getNode(ISD::BITCAST, dl, NewVT, Op0);
2981 Op1 = DAG.getNode(ISD::BITCAST, dl, NewVT, Op1);
3026 Tmp1 = DAG.getNode(ISD::BITCAST, dl, Node->getValueType(0), Tmp1);
3039 Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0), Tmp1);
3042 Tmp1 = DAG.getNode(ISD::TRUNCATE, dl, Node->getValueType(0),
3138 DAG.getNode(ISD::FP16_TO_FP, dl, MVT::f32, Node->getOperand(0));
3140 DAG.getNode(ISD::FP_EXTEND, dl, Node->getValueType(0), Res));
3155 DAG.getNode(ISD::FP_TO_FP16, dl, Node->getValueType(0), FloatVal));
3178 Tmp1 = DAG.getNode(ISD::FNEG, dl, VT, Node->getOperand(1));
3263 SDValue Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Halves[2 * i]);
3264 SDValue Hi = DAG.getNode(ISD::ANY_EXTEND, dl, VT, Halves[2 * i + 1]);
3311 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Lo);
3312 Hi = DAG.getNode(ISD::ANY_EXTEND, dl, VT, Hi);
3412 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, PairTy, Node->getOperand(0));
3413 Tmp2 = DAG.getNode(ISD::ANY_EXTEND, dl, PairTy, Node->getOperand(1));
4144 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0));
4156 Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1);
4164 Results.push_back(DAG.getNode(ISD::TRUNCATE, dl, OVT, Tmp1));
4169 Tmp1 = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Node->getOperand(0));
4170 Tmp1 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1);
4176 Results.push_back(DAG.getNode(ISD::TRUNCATE, dl, OVT, Tmp1));
4209 Tmp2 = DAG.getNode(TruncOp, dl, OVT, Tmp1);
4253 Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0));
4254 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
4257 Results.push_back(DAG.getNode(TruncOp, dl, OVT, Tmp1));
4265 Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0));
4266 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
4274 Results.push_back(DAG.getNode(ISD::TRUNCATE, dl, OVT, Tmp1));
4275 Results.push_back(DAG.getNode(ISD::TRUNCATE, dl, OVT, Tmp2));
4293 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
4294 Tmp3 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(2));
4299 Tmp1 = DAG.getNode(TruncOp, dl, Node->getValueType(0), Tmp1);
4310 Tmp1 = DAG.getNode(ISD::BITCAST, dl, NVT, Node->getOperand(0));
4311 Tmp2 = DAG.getNode(ISD::BITCAST, dl, NVT, Node->getOperand(1));
4315 Tmp1 = DAG.getNode(ISD::BITCAST, dl, OVT, Tmp1);
4326 Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(0));
4327 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(1));
4339 Tmp1 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(2));
4340 Tmp2 = DAG.getNode(ExtOp, dl, NVT, Node->getOperand(3));
4354 Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(0));
4355 Tmp2 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(1));
4362 Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(0));
4363 Tmp2 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(1));
4364 Tmp3 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(2));
4372 Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(0));
4402 Tmp1 = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Node->getOperand(0));
4403 Tmp2 = DAG.getNode(Node->getOpcode(), dl, NVT, Tmp1);
4426 NewOps.push_back(DAG.getNode(ISD::BITCAST, SDLoc(Op), MidVT, Op));
4431 SDValue CvtVec = DAG.getNode(ISD::BITCAST, SL, OVT, Concat);
4463 SDValue CastVec = DAG.getNode(ISD::BITCAST, SL, NVT, Node->getOperand(0));
4476 Results.push_back(DAG.getNode(ISD::BITCAST, SL, EltVT, NewVec));
4511 SDValue CastVec = DAG.getNode(ISD::BITCAST, SL, NVT, Node->getOperand(0));
4512 SDValue CastVal = DAG.getNode(ISD::BITCAST, SL, MidVT, Val);
4526 Results.push_back(DAG.getNode(ISD::BITCAST, SL, OVT, NewVec));
4544 SDValue CastVal = DAG.getNode(ISD::BITCAST, SL, MidVT, Val);
4553 SDValue CvtVec = DAG.getNode(ISD::BITCAST, SL, OVT, Concat);
4560 SDValue CastVal = DAG.getNode(ISD::BITCAST, SL, NVT, AM->getVal());
4571 Results.push_back(DAG.getNode(ISD::BITCAST, SL, OVT, NewAtomic));
lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp 284 SignBit = DAG.getNode(ISD::TRUNCATE, dl, LVT, SignBit);
286 SignBit = DAG.getNode(ISD::ANY_EXTEND, dl, LVT, SignBit);
512 Op = DAG.getNode(ISD::FP_EXTEND, SDLoc(N), MVT::f32, Op);
559 return DAG.getNode(ISD::FP_TO_FP16, SDLoc(N), NVT, Op);
702 return DAG.getNode(ISD::FP_TO_FP16, SDLoc(N), NVT, N->getOperand(0));
747 auto ExtendNode = DAG.getNode(ISD::FP_EXTEND, dl, VT, NewL);
810 SDValue Op = DAG.getNode(Signed ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, dl,
873 return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0), Op0);
883 return DAG.getNode(ISD::FP16_TO_FP, SDLoc(N), RVT, Op);
967 return DAG.getNode(ISD::TRUNCATE, dl, RVT, Res);
1201 Hi = DAG.getNode(ISD::FABS, dl, Tmp.getValueType(), Tmp);
1204 DAG.getNode(ISD::FNEG, dl, Lo.getValueType(), Lo),
1400 Lo = DAG.getNode(ISD::FNEG, dl, Lo.getValueType(), Lo);
1401 Hi = DAG.getNode(ISD::FNEG, dl, Hi.getValueType(), Hi);
1408 Hi = DAG.getNode(ISD::FP_EXTEND, dl, NVT, N->getOperand(0));
1557 Src = DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, dl,
1561 Hi = DAG.getNode(ISD::SINT_TO_FP, dl, NVT, Src);
1565 Src = DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, dl,
1569 Src = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::i128, Src);
1941 SDValue Convert = DAG.getNode(GetPromotionOpcode(PromotedVT, OpVT), SDLoc(N),
1961 return DAG.getNode(N->getOpcode(), SDLoc(N), N->getValueType(0), Op);
1973 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, Op);
2013 NewVal = DAG.getNode(GetPromotionOpcode(Promoted.getValueType(), VT), DL,
2118 return DAG.getNode(GetPromotionOpcode(VT, NVT), SDLoc(N), NVT, Cast);
2135 return DAG.getNode(GetPromotionOpcode(VT, NVT), DL, NVT, C);
2198 return DAG.getNode(GetPromotionOpcode(VT, NVT), SDLoc(N), NVT, NewVal);
2222 return DAG.getNode(N->getOpcode(), SDLoc(N), NVT, Op);
2268 SDValue Round = DAG.getNode(GetPromotionOpcode(OpVT, VT), DL, IVT, Op);
2270 return DAG.getNode(GetPromotionOpcode(VT, NVT), DL, NVT, Round);
2291 return DAG.getNode(GetPromotionOpcode(VT, NVT), SDLoc(N), NVT, newL);
2320 SDValue NV = DAG.getNode(N->getOpcode(), DL, NVT, N->getOperand(0));
2322 return DAG.getNode(
2348 SDValue ResultCast = DAG.getNode(GetPromotionOpcode(VT, NFPVT), SL, NFPVT,
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp 296 return DAG.getNode(ISD::BITCAST, dl, NOutVT, GetPromotedInteger(InOp));
300 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, GetSoftenedFloat(InOp));
304 return DAG.getNode(ISD::FP_TO_FP16, dl, NOutVT, GetPromotedFloat(InOp));
313 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT,
328 InOp = DAG.getNode(ISD::ANY_EXTEND, dl,
332 return DAG.getNode(ISD::BITCAST, dl, NOutVT, InOp);
341 return DAG.getNode(ISD::BITCAST, dl, NOutVT, GetWidenedVector(InOp));
358 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, InOp);
364 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT,
389 return DAG.getNode(ISD::SRL, dl, NVT, DAG.getNode(ISD::BSWAP, dl, NVT, Op),
402 DAG.getNode(ISD::BITREVERSE, dl, NVT, Op),
409 return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N),
422 SDValue Result = DAG.getNode(Opc, dl,
435 Op = DAG.getNode(N->getOpcode(), dl, NVT, Op);
446 return DAG.getNode(ISD::CTPOP, SDLoc(N), Op.getValueType(), Op);
462 return DAG.getNode(N->getOpcode(), dl, NVT, Op);
517 Res = DAG.getNode(NewOpc, dl, NVT, N->getOperand(0));
536 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
571 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
936 EOp1 = DAG.getNode(ISD::TRUNCATE, dl, HalfNVT, EOp1);
937 EOp2 = DAG.getNode(ISD::TRUNCATE, dl, HalfNVT, EOp2);
948 SDValue WideTrunc = DAG.getNode(ISD::TRUNCATE, dl, TruncVT, WideInOp);
953 SDValue WideExt = DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVT, WideTrunc);
963 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
1028 return DAG.getNode(ISD::ABS, SDLoc(N), Op0.getValueType(), Op0);
1112 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
1114 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
1293 return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), N->getValueType(0), Op);
1457 Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op);
1557 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), N->getValueType(0), Op);
1568 Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op);
1640 return DAG.getNode(N->getOpcode(), SDLoc(N), VT, Op);
1644 SDValue Reduce = DAG.getNode(N->getOpcode(), dl, EltVT, Op);
1645 return DAG.getNode(ISD::TRUNCATE, dl, VT, Reduce);
2383 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
2445 Lo = DAG.getNode(ISD::BITREVERSE, dl, Lo.getValueType(), Lo);
2446 Hi = DAG.getNode(ISD::BITREVERSE, dl, Hi.getValueType(), Hi);
2453 Lo = DAG.getNode(ISD::BSWAP, dl, Lo.getValueType(), Lo);
2454 Hi = DAG.getNode(ISD::BSWAP, dl, Hi.getValueType(), Hi);
2500 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
2501 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
2516 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
2517 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
2531 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
2532 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
3266 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
3348 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
3353 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
3405 DAG.getNode(ISD::ZERO_EXTEND, dl, VT, LHSLow),
3406 DAG.getNode(ISD::ZERO_EXTEND, dl, VT, RHSLow));
3535 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
3976 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), N->getValueType(0), InL);
3992 SDValue SignedConv = DAG.getNode(ISD::SINT_TO_FP, dl, DstVT, Op);
4137 Op = DAG.getNode(ISD::ANY_EXTEND, dl, NOutVTElem, N->getOperand(i));
4158 SDValue Op = DAG.getNode(ISD::ANY_EXTEND, dl, NOutVTElem, N->getOperand(0));
4160 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NOutVT, Op);
4175 SDValue Op = DAG.getNode(ISD::ANY_EXTEND, dl, NOutElemVT, SplatVal);
4177 return DAG.getNode(ISD::SPLAT_VECTOR, dl, NOutVT, Op);
4244 return DAG.getNode(N->getOpcode(), dl, NVT, Promoted);
4248 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
4261 SDValue ConvElem = DAG.getNode(ISD::ANY_EXTEND, dl,
4272 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
4296 return DAG.getNode(ISD::TRUNCATE, dl, N->getValueType(0), Ext);
4319 SDValue Tr = DAG.getNode(ISD::TRUNCATE, dl, RetSclrTy, Ex);
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp 842 return DAG.getNode(ISD::BITCAST, SDLoc(Op),
852 return DAG.getNode(ISD::BITCAST, SDLoc(Op),
970 Lo = DAG.getNode(ISD::ZERO_EXTEND, dlLo, NVT, Lo);
971 Hi = DAG.getNode(ISD::ANY_EXTEND, dlHi, NVT, Hi);
1049 return DAG.getNode(ExtendCode, dl, BoolVT, Bool);
1059 Lo = DAG.getNode(ISD::TRUNCATE, dl, LoVT, Op);
1068 Hi = DAG.getNode(ISD::TRUNCATE, dl, HiVT, Hi);
lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp 57 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
58 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
68 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
69 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
76 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
77 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
82 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
83 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
93 Lo = DAG.getNode(ISD::BITCAST, dl, NOutVT, Lo);
94 Hi = DAG.getNode(ISD::BITCAST, dl, NOutVT, Hi);
118 SDValue CastInOp = DAG.getNode(ISD::BITCAST, dl, NVT, InOp);
223 OldVec = DAG.getNode(ISD::ANY_EXTEND, dl, NVecVT, N->getOperand(0));
226 SDValue NewVec = DAG.getNode(ISD::BITCAST, dl,
327 Ops.push_back(DAG.getNode(ISD::BITCAST, DL, EltVT, Op));
361 return DAG.getNode(ISD::BITCAST, dl, N->getValueType(0), Vec);
397 return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec);
422 SDValue NewVec = DAG.getNode(ISD::BITCAST, dl,
439 return DAG.getNode(ISD::BITCAST, dl, VecVT, NewVec);
lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp 553 Operands[j] = DAG.getNode(ISD::FP_EXTEND, dl, NVT, Op.getOperand(j));
555 Operands[j] = DAG.getNode(ISD::BITCAST, dl, NVT, Op.getOperand(j));
566 return DAG.getNode(ISD::BITCAST, dl, VT, Op);
584 Operands[j] = DAG.getNode(Opc, dl, NVT, Op.getOperand(j));
610 SDValue Promoted = DAG.getNode(NewOpc, dl, NVT, Op.getOperand(0));
619 return DAG.getNode(ISD::TRUNCATE, dl, VT, Promoted);
929 Op1 = DAG.getNode(ISD::BITCAST, DL, MaskTy, Op1);
930 Op2 = DAG.getNode(ISD::BITCAST, DL, MaskTy, Op2);
939 return DAG.getNode(ISD::BITCAST, DL, Op.getValueType(), Val);
995 return DAG.getNode(
1008 Op = DAG.getNode(ISD::ANY_EXTEND_VECTOR_INREG, DL, VT, Src);
1060 return DAG.getNode(ISD::BITCAST, DL, VT,
1084 Op = DAG.getNode(ISD::BITCAST, DL, ByteVT, Op.getOperand(0));
1086 return DAG.getNode(ISD::BITCAST, DL, VT, Op);
1112 Op = DAG.getNode(ISD::BITCAST, DL, ByteVT, Op.getOperand(0));
1115 Op = DAG.getNode(ISD::BITREVERSE, DL, ByteVT, Op);
1116 return DAG.getNode(ISD::BITCAST, DL, VT, Op);
1166 Op1 = DAG.getNode(ISD::BITCAST, DL, VT, Op1);
1167 Op2 = DAG.getNode(ISD::BITCAST, DL, VT, Op2);
1176 return DAG.getNode(ISD::BITCAST, DL, Op.getValueType(), Val);
1239 SDValue fHI = DAG.getNode(ISD::SINT_TO_FP, DL, Op.getValueType(), HI);
1241 SDValue fLO = DAG.getNode(ISD::SINT_TO_FP, DL, Op.getValueType(), LO);
lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp 281 SDValue OtherVal = DAG.getNode(
302 return DAG.getNode(ISD::BITCAST, SDLoc(N),
312 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, InOp);
354 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, Op);
396 return DAG.getNode(N->getOpcode(), SDLoc(N), DestVT, Op);
425 return DAG.getNode(ISD::ANY_EXTEND, DL, EltVT, Op);
427 return DAG.getNode(ISD::SIGN_EXTEND, DL, EltVT, Op);
429 return DAG.getNode(ISD::ZERO_EXTEND, DL, EltVT, Op);
441 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, InOp);
507 Cond = DAG.getNode(ISD::TRUNCATE, SDLoc(N), BoolVT, Cond);
573 return DAG.getNode(ExtendCode, DL, NVT, Res);
671 return DAG.getNode(ISD::BITCAST, SDLoc(N),
681 SDValue Op = DAG.getNode(N->getOpcode(), SDLoc(N),
685 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), N->getValueType(0), Op);
702 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), N->getValueType(0), Res);
720 ? DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, Res)
721 : DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, Res);
761 Res = DAG.getNode(ExtendCode, DL, NVT, Res);
763 return DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VT, Res);
793 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), N->getValueType(0), Res);
807 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), N->getValueType(0), Res);
814 Res = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), N->getValueType(0), Res);
1086 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
1087 Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
1095 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
1096 Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
1110 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
1111 Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
1295 Lo = DAG.getNode(Opcode, dl, OutLoVT, InLo);
1296 Hi = DAG.getNode(Opcode, dl, OutHiVT, InHi);
1480 Vec = DAG.getNode(ISD::ANY_EXTEND, dl, VecVT, Vec);
1483 Elt = DAG.getNode(ISD::ANY_EXTEND, dl, EltVT, Elt);
1521 Lo = DAG.getNode(ISD::TRUNCATE, dl, LoVT, Lo);
1523 Hi = DAG.getNode(ISD::TRUNCATE, dl, HiVT, Hi);
1531 Lo = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoVT, N->getOperand(0));
1769 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo);
1770 Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi);
1810 DAG.getNode(N->getOpcode(), dl, NewSrcVT, N->getOperand(0));
1814 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo);
1815 Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi);
2146 return DAG.getNode(N->getOpcode(), dl, ResVT, Partial, N->getFlags());
2175 Lo = DAG.getNode(N->getOpcode(), dl, OutVT, Lo);
2176 Hi = DAG.getNode(N->getOpcode(), dl, OutVT, Hi);
2194 return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0),
2251 Vec = DAG.getNode(ISD::ANY_EXTEND, dl, VecVT, Vec);
2609 SDValue HalfLo = DAG.getNode(N->getOpcode(), DL, HalfVT, InLoVec);
2610 SDValue HalfHi = DAG.getNode(N->getOpcode(), DL, HalfVT, InHiVec);
2623 : DAG.getNode(ISD::TRUNCATE, DL, OutVT, InterVec);
2646 return DAG.getNode(ExtendCode, DL, N->getValueType(0), Con);
3277 return DAG.getNode(Opcode, DL, WidenVT, InOp);
3285 return DAG.getNode(ISD::ANY_EXTEND_VECTOR_INREG, DL, WidenVT, InOp);
3287 return DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, DL, WidenVT, InOp);
3289 return DAG.getNode(ISD::ZERO_EXTEND_VECTOR_INREG, DL, WidenVT, InOp);
3306 return DAG.getNode(Opcode, DL, WidenVT, InVec);
3316 return DAG.getNode(Opcode, DL, WidenVT, InVal);
3332 Ops[i] = DAG.getNode(Opcode, DL, EltVT, Val);
3398 return DAG.getNode(Opcode, DL, WidenVT, InOp);
3410 Val = DAG.getNode(ISD::ANY_EXTEND, DL, WidenSVT, Val);
3413 Val = DAG.getNode(ISD::SIGN_EXTEND, DL, WidenSVT, Val);
3416 Val = DAG.getNode(ISD::ZERO_EXTEND, DL, WidenSVT, Val);
3471 return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp);
3512 return DAG.getNode(ISD::BITCAST, dl, WidenVT, InOp);
3528 return DAG.getNode(ISD::BITCAST, dl, WidenVT, InOp);
3562 NewVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NewInVT, InOp);
3564 return DAG.getNode(ISD::BITCAST, dl, WidenVT, NewVec);
3797 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N),
3862 Mask = DAG.getNode(ISD::SIGN_EXTEND, SDLoc(Mask), ExtVT, Mask);
3866 Mask = DAG.getNode(ISD::TRUNCATE, SDLoc(Mask), TruncVT, Mask);
4264 return DAG.getNode(ISD::ANY_EXTEND_VECTOR_INREG, DL, VT, InOp);
4266 return DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, DL, VT, InOp);
4268 return DAG.getNode(ISD::ZERO_EXTEND_VECTOR_INREG, DL, VT, InOp);
4306 Res = DAG.getNode(Opcode, dl, WideVT, InOp);
4330 Ops[i] = DAG.getNode(
4354 SDValue BitOp = DAG.getNode(ISD::BITCAST, dl, NewVT, InOp);
4372 SDValue BitOp = DAG.getNode(ISD::BITCAST, dl, NewVT, InOp);
4580 return DAG.getNode(ExtendCode, dl, VT, CC);
4636 return DAG.getNode(N->getOpcode(), dl, N->getValueType(0), Op, N->getFlags());
4741 SDValue VecOp = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NewVecVT,LdOps[Start]);
4748 VecOp = DAG.getNode(ISD::BITCAST, dl, NewVecVT, VecOp);
4757 return DAG.getNode(ISD::BITCAST, dl, VecTy, VecOp);
4796 SDValue VecOp = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NewVecVT, LdOp);
4797 return DAG.getNode(ISD::BITCAST, dl, WidenVT, VecOp);
5006 SDValue VecOp = DAG.getNode(ISD::BITCAST, dl, NewVecVT, ValOp);
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 1100 ? getNode(ISD::FP_EXTEND, DL, VT, Op)
1106 getNode(ISD::ANY_EXTEND, DL, VT, Op) :
1107 getNode(ISD::TRUNCATE, DL, VT, Op);
1112 getNode(ISD::SIGN_EXTEND, DL, VT, Op) :
1113 getNode(ISD::TRUNCATE, DL, VT, Op);
1118 getNode(ISD::ZERO_EXTEND, DL, VT, Op) :
1119 getNode(ISD::TRUNCATE, DL, VT, Op);
1125 return getNode(ISD::TRUNCATE, SL, VT, Op);
1128 return getNode(TLI->getExtendForContent(BType), SL, VT, Op);
1257 SDValue V = getNode(ISD::BITCAST, DL, VT, getBuildVector(ViaVecVT, DL, Ops));
1709 NewBV = getNode(ISD::BITCAST, dl, VT, NewBV);
1862 return getNode(ISD::BITCAST, SDLoc(V), VT, V);
2199 return getNode(ISD::ANY_EXTEND, SDLoc(V), V.getValueType(), DemandedSrc);
4510 return getNode(OpOpcode, DL, VT, Operand.getOperand(0));
4529 return getNode(ISD::ZERO_EXTEND, DL, VT, Operand.getOperand(0));
4551 return getNode(OpOpcode, DL, VT, Operand.getOperand(0));
4578 return getNode(ISD::TRUNCATE, DL, VT, Operand.getOperand(0));
4584 return getNode(OpOpcode, DL, VT, Operand.getOperand(0));
4586 return getNode(ISD::TRUNCATE, DL, VT, Operand.getOperand(0));
4628 return getNode(ISD::BITCAST, DL, VT, Operand.getOperand(0));
4663 return getNode(ISD::FABS, DL, VT, Operand.getOperand(0));
4851 V1 = getNode(ISD::TRUNCATE, DL, SVT, V1);
4853 V2 = getNode(ISD::TRUNCATE, DL, SVT, V2);
4862 ScalarResult = getNode(ISD::SIGN_EXTEND, DL, LegalSVT, ScalarResult);
4954 ScalarOp = getNode(ISD::TRUNCATE, DL, InSVT, ScalarOp);
4964 ScalarResult = getNode(ISD::SIGN_EXTEND, DL, LegalSVT, ScalarResult);
5649 Value = DAG.getNode(ISD::ZERO_EXTEND, dl, IntVT, Value);
5681 return DAG.getNode(ISD::BITCAST, dl, VT,
6132 Value = DAG.getNode(ISD::TRUNCATE, dl, VT, MemSetValue);
7190 case 1: return getNode(Opcode, DL, VT, static_cast<const SDValue>(Ops[0]));
7207 case 1: return getNode(Opcode, DL, VT, Ops[0], Flags);
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 235 Lo = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[0]);
236 Hi = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[1]);
256 Hi = DAG.getNode(ISD::ANY_EXTEND, DL, TotalVT, Hi);
261 Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, TotalVT, Lo);
269 Lo = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[0]);
270 Hi = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[1]);
296 Val = DAG.getNode(ISD::TRUNCATE, DL, PartEVT, Val);
301 return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
312 return DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
314 return DAG.getNode(ISD::ANY_EXTEND, DL, ValueVT, Val);
324 return DAG.getNode(ISD::FP_EXTEND, DL, ValueVT, Val);
331 Val = DAG.getNode(ISD::BITCAST, DL, MVT::i64, Val);
332 return DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
444 return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
457 return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
463 return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
530 Val = DAG.getNode(ISD::FP_EXTEND, DL, PartVT, Val);
536 Val = DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
542 Val = DAG.getNode(ExtendKind, DL, ValueVT, Val);
544 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
549 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
556 Val = DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
558 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
570 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
597 Val = DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
602 Parts[0] = DAG.getNode(ISD::BITCAST, DL,
620 Part0 = DAG.getNode(ISD::BITCAST, DL, PartVT, Part0);
621 Part1 = DAG.getNode(ISD::BITCAST, DL, PartVT, Part1);
673 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
735 Val = DAG.getNode(ISD::BITCAST, DL, BuiltVectorTy, Val);
1592 DAG.setRoot(DAG.getNode(ISD::CATCHPAD, getCurSDLoc(), MVT::Other,
1756 DAG.getNode(ISD::CLEANUPRET, getCurSDLoc(), MVT::Other, getControlRoot());
2611 Chain = DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, Chain);
2958 DAG.setRoot(DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, DAG.getRoot()));
2967 setValue(&I, DAG.getNode(ISD::FNEG, getCurSDLoc(),
3106 SDValue UnNodeValue = DAG.getNode(Opcode, getCurSDLoc(), Op.getValueType(),
3147 Op2 = DAG.getNode(ISD::ZERO_EXTEND, DL, ShiftTy, Op2);
3154 Op2 = DAG.getNode(ISD::TRUNCATE, DL, ShiftTy, Op2);
3359 DAG.getNode(OpCode, getCurSDLoc(),
3383 setValue(&I, DAG.getNode(ISD::TRUNCATE, getCurSDLoc(), DestVT, N));
3392 setValue(&I, DAG.getNode(ISD::ZERO_EXTEND, getCurSDLoc(), DestVT, N));
3401 setValue(&I, DAG.getNode(ISD::SIGN_EXTEND, getCurSDLoc(), DestVT, N));
3420 setValue(&I, DAG.getNode(ISD::FP_EXTEND, getCurSDLoc(), DestVT, N));
3428 setValue(&I, DAG.getNode(ISD::FP_TO_UINT, getCurSDLoc(), DestVT, N));
3436 setValue(&I, DAG.getNode(ISD::FP_TO_SINT, getCurSDLoc(), DestVT, N));
3444 setValue(&I, DAG.getNode(ISD::UINT_TO_FP, getCurSDLoc(), DestVT, N));
3452 setValue(&I, DAG.getNode(ISD::SINT_TO_FP, getCurSDLoc(), DestVT, N));
3490 setValue(&I, DAG.getNode(ISD::BITCAST, dl,
3555 setValue(&I, DAG.getNode(ISD::SPLAT_VECTOR, DL, VT, FirstElt));
4850 Result = DAG.getNode(ISD::BITCAST, getCurSDLoc(), VT, Result);
4869 return DAG.getNode(ISD::BITCAST, dl, MVT::f32, t2);
4886 return DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, t2);
4901 SDValue IntegerPartOfX = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, t0);
4904 SDValue t1 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, IntegerPartOfX);
4981 SDValue t13 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, TwoToFractionalPartOfX);
4982 return DAG.getNode(ISD::BITCAST, dl, MVT::f32,
5005 return DAG.getNode(ISD::FEXP, dl, Op.getValueType(), Op);
5016 SDValue Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Op);
5104 return DAG.getNode(ISD::FLOG, dl, Op.getValueType(), Op);
5115 SDValue Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Op);
5201 return DAG.getNode(ISD::FLOG2, dl, Op.getValueType(), Op);
5212 SDValue Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Op);
5291 return DAG.getNode(ISD::FLOG10, dl, Op.getValueType(), Op);
5303 return DAG.getNode(ISD::FEXP2, dl, Op.getValueType(), Op);
5655 setValue(&I, DAG.getNode(ISD::RETURNADDR, sdl,
5668 setValue(&I, DAG.getNode(ISD::FRAMEADDR, sdl,
5941 setValue(&I, DAG.getNode(ISD::EH_DWARF_CFA, sdl,
5978 DAG.setRoot(DAG.getNode(ISD::EH_SJLJ_SETUP_DISPATCH, sdl, MVT::Other,
6049 setValue(&I, DAG.getNode(Opcode, sdl,
6068 setValue(&I, DAG.getNode(Opcode, sdl, RetVT,
6167 setValue(&I, DAG.getNode(ISD::BITCAST, sdl, MVT::i16,
6174 setValue(&I, DAG.getNode(ISD::FP_EXTEND, sdl,
6176 DAG.getNode(ISD::BITCAST, sdl, MVT::f16,
6193 setValue(&I, DAG.getNode(ISD::BITREVERSE, sdl,
6198 setValue(&I, DAG.getNode(ISD::BSWAP, sdl,
6206 setValue(&I, DAG.getNode(CI->isZero() ? ISD::CTTZ : ISD::CTTZ_ZERO_UNDEF,
6214 setValue(&I, DAG.getNode(CI->isZero() ? ISD::CTLZ : ISD::CTLZ_ZERO_UNDEF,
6221 setValue(&I, DAG.getNode(ISD::CTPOP, sdl, Ty, Arg));
6461 setValue(&I, DAG.getNode(ISD::ADJUST_TRAMPOLINE, sdl,
6497 DAG.setRoot(DAG.getNode(Op, sdl,MVT::Other, getRoot()));
6683 DAG.getNode(ISD::LOCAL_RECOVER, sdl, PtrVT, OffsetSym);
7512 setValue(&I, DAG.getNode(Opcode, getCurSDLoc(), Tmp.getValueType(), Tmp));
7930 DAG.getNode(ISD::BITCAST, DL, RegVT, OpInfo.CallOperand);
7939 DAG.getNode(ISD::BITCAST, DL, VT, OpInfo.CallOperand);
8440 V = DAG.getNode(ISD::BITCAST, getCurSDLoc(), ResultVT, V);
8446 V = DAG.getNode(ISD::TRUNCATE, getCurSDLoc(), ResultVT, V);
8917 DAG.getNode(ISD::VECREDUCE_FADD, dl, VT, Op2));
8924 DAG.getNode(ISD::VECREDUCE_FMUL, dl, VT, Op2));
8929 Res = DAG.getNode(ISD::VECREDUCE_ADD, dl, VT, Op1);
8932 Res = DAG.getNode(ISD::VECREDUCE_MUL, dl, VT, Op1);
8935 Res = DAG.getNode(ISD::VECREDUCE_AND, dl, VT, Op1);
8938 Res = DAG.getNode(ISD::VECREDUCE_OR, dl, VT, Op1);
8941 Res = DAG.getNode(ISD::VECREDUCE_XOR, dl, VT, Op1);
8944 Res = DAG.getNode(ISD::VECREDUCE_SMAX, dl, VT, Op1);
8947 Res = DAG.getNode(ISD::VECREDUCE_SMIN, dl, VT, Op1);
8950 Res = DAG.getNode(ISD::VECREDUCE_UMAX, dl, VT, Op1);
8953 Res = DAG.getNode(ISD::VECREDUCE_UMIN, dl, VT, Op1);
8956 Res = DAG.getNode(ISD::VECREDUCE_FMAX, dl, VT, Op1);
8959 Res = DAG.getNode(ISD::VECREDUCE_FMIN, dl, VT, Op1);
lib/CodeGen/SelectionDAG/StatepointLowering.cpp 1066 DAG.getNode(ISD::TRAP, getCurSDLoc(), MVT::Other, DAG.getRoot()));
lib/CodeGen/SelectionDAG/TargetLowering.cpp 544 DAG.getNode(ISD::TRUNCATE, dl, SmallVT, Op.getOperand(0)),
545 DAG.getNode(ISD::TRUNCATE, dl, SmallVT, Op.getOperand(1)));
547 SDValue Z = DAG.getNode(ISD::ANY_EXTEND, dl, Op.getValueType(), X);
1336 Op, TLO.DAG.getNode(ISD::ANY_EXTEND, dl, VT, NarrowShl));
1354 SDValue NewExt = TLO.DAG.getNode(ISD::ANY_EXTEND, dl, VT,
1640 return TLO.CombineTo(Op, TLO.DAG.getNode(Opc, dl, VT, Src));
1673 return TLO.CombineTo(Op, TLO.DAG.getNode(Opc, dl, VT, Src));
1697 return TLO.CombineTo(Op, TLO.DAG.getNode(Opc, dl, VT, Src));
1740 return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::TRUNCATE, dl, VT, NewSrc));
1775 TLO.DAG.getNode(ISD::TRUNCATE, dl, VT, Src.getOperand(0));
1844 SDValue Sign = TLO.DAG.getNode(ISD::FGETSIGN, dl, Ty, Src);
1847 Sign = TLO.DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Sign);
3192 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, MinVT, PreExt);
3388 return DAG.getNode(ISD::TRUNCATE, dl, VT, N0);
3448 DAG.getNode(ISD::TRUNCATE, dl, VT, Op0.getOperand(0)),
3452 DAG.getNode(ISD::ANY_EXTEND, dl, VT, Op0.getOperand(0)),
3625 return DAG.getNode(ISD::TRUNCATE, dl, VT,
3635 return DAG.getNode(ISD::TRUNCATE, dl, VT,
3712 SDValue NegN1 = DAG.getNode(ISD::FNEG, dl, N0.getValueType(), N1);
3923 N0 = DAG.getNode(ExtendCode, dl, VT, N0);
5567 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
5636 LL = DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, LHS);
5637 RL = DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, RHS);
5684 LH = DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, LH);
5686 RH = DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, RH);
5708 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Lo);
5709 Hi = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Hi);
5714 SDValue Next = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Hi);
5738 Result.push_back(DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, Next));
5755 DAG.getNode(ISD::ZERO_EXTEND, dl, VT, RL));
5759 DAG.getNode(ISD::ZERO_EXTEND, dl, VT, LL));
5763 Result.push_back(DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, Next));
5765 Result.push_back(DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, Next));
5911 SDValue Bits = DAG.getNode(ISD::BITCAST, dl, IntVT, Src);
5981 Result = DAG.getNode(ISD::FP_TO_SINT, dl, DstVT, Src);
6015 SInt = DAG.getNode(ISD::FP_TO_SINT, dl, DstVT, Val);
6023 SDValue True = DAG.getNode(ISD::FP_TO_SINT, dl, DstVT, Src);
6025 SDValue False = DAG.getNode(ISD::FP_TO_SINT, dl, DstVT,
6059 SDValue Fast = DAG.getNode(ISD::SINT_TO_FP, dl, DstVT, Src);
6067 SDValue SignCvt = DAG.getNode(ISD::SINT_TO_FP, dl, DstVT, Or);
6133 Quiet0 = DAG.getNode(ISD::FCANONICALIZE, dl, VT, Quiet0,
6137 Quiet1 = DAG.getNode(ISD::FCANONICALIZE, dl, VT, Quiet1,
6230 Result = DAG.getNode(ISD::CTLZ, dl, VT, Op);
6238 SDValue CTLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, VT, Op);
6268 Result = DAG.getNode(ISD::CTPOP, dl, VT, Op);
6282 Result = DAG.getNode(ISD::CTTZ, dl, VT, Op);
6290 SDValue CTTZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, VT, Op);
6319 DAG.getNode(ISD::CTLZ, dl, VT, Tmp));
6323 Result = DAG.getNode(ISD::CTPOP, dl, VT, Tmp);
6420 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SL, MemSclVT, Elt);
6421 SDValue ExtElt = DAG.getNode(ISD::ZERO_EXTEND, SL, IntVT, Trunc);
6487 SDValue Result = DAG.getNode(ISD::BITCAST, dl, LoadedVT, newLoad);
6489 Result = DAG.getNode(VT.isFloatingPoint() ? ISD::FP_EXTEND :
6640 SDValue Result = DAG.getNode(ISD::BITCAST, dl, intVT, Val);
6756 MaskInIntReg = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, MaskInIntReg);
6761 Increment = DAG.getNode(ISD::CTPOP, DL, MaskIntVT, MaskInIntReg);
6870 Zext = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Op.getOperand(0));
6873 SDValue Clz = DAG.getNode(ISD::CTLZ, dl, VT, Zext);
6876 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Scc);
7216 LHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, LHS);
7217 RHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, RHS);
7219 BottomHalf = DAG.getNode(ISD::TRUNCATE, dl, VT, Mul);
7222 TopHalf = DAG.getNode(ISD::TRUNCATE, dl, VT,
7308 Overflow = DAG.getNode(ISD::TRUNCATE, dl, RType, Overflow);
7369 Res = DAG.getNode(ISD::ANY_EXTEND, dl, Node->getValueType(0), Res);
lib/Target/AArch64/AArch64ISelLowering.cpp 1611 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f32, LHS);
1612 RHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f32, RHS);
1712 LHS = DAG.getNode(ISD::FP_EXTEND, DL, MVT::f32, LHS);
1713 RHS = DAG.getNode(ISD::FP_EXTEND, DL, MVT::f32, RHS);
2140 LHS = DAG.getNode(ExtendOpc, DL, MVT::i64, LHS);
2141 RHS = DAG.getNode(ExtendOpc, DL, MVT::i64, RHS);
2149 Value = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Add);
2158 UpperBits = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, UpperBits);
2448 return DAG.getNode(
2450 DAG.getNode(ISD::FP_EXTEND, dl, NewVT, Op.getOperand(0)));
2456 DAG.getNode(Op.getOpcode(), dl, InVT.changeVectorElementTypeToInteger(),
2458 return DAG.getNode(ISD::TRUNCATE, dl, VT, Cv);
2466 SDValue Ext = DAG.getNode(ISD::FP_EXTEND, dl, ExtVT, Op.getOperand(0));
2467 return DAG.getNode(Op.getOpcode(), dl, VT, Ext);
2483 return DAG.getNode(
2485 DAG.getNode(ISD::FP_EXTEND, dl, MVT::f32, Op.getOperand(0)));
2517 In = DAG.getNode(Op.getOpcode(), dl, CastVT, In);
2525 In = DAG.getNode(CastOpc, dl, CastVT, In);
2526 return DAG.getNode(Op.getOpcode(), dl, VT, In);
2543 DAG.getNode(Op.getOpcode(), dl, MVT::f32, Op.getOperand(0)),
2606 Op = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, Op.getOperand(0));
2607 Op = DAG.getNode(ISD::BITCAST, DL, MVT::f32, Op);
2645 return DAG.getNode(ExtOpcode, SDLoc(N), NewVT, N);
2738 SDValue FPCR_64 = DAG.getNode(ISD::INTRINSIC_WO_CHAIN, dl, MVT::i64,
2741 SDValue FPCR_32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, FPCR_64);
2814 DAG.getNode(ISD::BITCAST, DL, Op1VT, N00), Op1),
2816 DAG.getNode(ISD::BITCAST, DL, Op1VT, N01), Op1));
2832 SDValue Result = DAG.getNode(ISD::BITCAST, dl, MVT::v1i64,
2834 Result = DAG.getNode(ISD::ABS, dl, MVT::v1i64, Result);
2835 return DAG.getNode(ISD::BITCAST, dl, MVT::i64, Result);
2837 return DAG.getNode(ISD::ABS, dl, Ty, Op.getOperand(1));
2856 return DAG.getNode(AArch64ISD::SUNPKHI, dl, Op.getValueType(),
2859 return DAG.getNode(AArch64ISD::SUNPKLO, dl, Op.getValueType(),
2862 return DAG.getNode(AArch64ISD::UUNPKHI, dl, Op.getValueType(),
2865 return DAG.getNode(AArch64ISD::UUNPKLO, dl, Op.getValueType(),
2918 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, DL, MVT::v8i8, TruncExt);
2920 Trunc = DAG.getNode(ISD::BITCAST, DL, MVT::v2i32, Trunc);
3244 ArgValue = DAG.getNode(ISD::BITCAST, DL, VA.getValVT(), ArgValue);
3522 Val = DAG.getNode(ISD::BITCAST, DL, VA.getValVT(), Val);
3873 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Arg);
3876 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Arg);
3881 Arg = DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, Arg);
3882 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i8, Arg);
3884 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Arg);
3888 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Arg);
3899 Arg = DAG.getNode(ISD::FP_EXTEND, DL, VA.getLocVT(), Arg);
4001 Arg = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Arg);
4029 Callee = DAG.getNode(AArch64ISD::LOADgot, DL, PtrVT, Callee);
4043 Callee = DAG.getNode(AArch64ISD::LOADgot, DL, PtrVT, Callee);
4194 Arg = DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, Arg);
4195 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Arg);
4199 Arg = DAG.getNode(ISD::BITCAST, DL, VA.getLocVT(), Arg);
4314 return DAG.getNode(AArch64ISD::LOADgot, DL, Ty, GotAddr);
4343 SDValue ADRP = DAG.getNode(AArch64ISD::ADRP, DL, Ty, Hi);
4355 return DAG.getNode(AArch64ISD::ADR, DL, Ty, Sym);
4431 SDValue DescAddr = DAG.getNode(AArch64ISD::LOADgot, DL, PtrVT, TLVPAddr);
4550 TPOff = DAG.getNode(AArch64ISD::LOADgot, DL, PtrVT, TPOff);
4627 SDValue ADRP = DAG.getNode(AArch64ISD::ADRP, DL, PtrVT, TLSIndexHi);
4635 TLSIndex = DAG.getNode(ISD::ZERO_EXTEND, DL, PtrVT, TLSIndex);
4821 In2 = DAG.getNode(ISD::FP_EXTEND, DL, VT, In2);
4836 VecVal1 = DAG.getNode(ISD::BITCAST, DL, VecVT, In1);
4837 VecVal2 = DAG.getNode(ISD::BITCAST, DL, VecVT, In2);
4867 BuildVec = DAG.getNode(ISD::BITCAST, DL, MVT::v2f64, BuildVec);
4868 BuildVec = DAG.getNode(ISD::FNEG, DL, MVT::v2f64, BuildVec);
4869 BuildVec = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, BuildVec);
4882 return DAG.getNode(ISD::BITCAST, DL, VT, Sel);
4907 Val = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, Val);
4908 Val = DAG.getNode(ISD::BITCAST, DL, MVT::v8i8, Val);
4910 SDValue CtPop = DAG.getNode(ISD::CTPOP, DL, MVT::v8i8, Val);
4916 UaddLV = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, UaddLV);
4926 Val = DAG.getNode(ISD::CTPOP, DL, VT8Bit, Val);
5035 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f32, LHS);
5036 RHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f32, RHS);
5765 return DAG.getNode(Opcode, SDLoc(Operand), VT, Operand);
6402 Src.ShuffleVec = DAG.getNode(ISD::BITCAST, dl, ShuffleVT, Src.ShuffleVec);
6453 SDValue V = DAG.getNode(ISD::BITCAST, dl, VT, Shuffle);
6791 return DAG.getNode(AArch64ISD::REV64, dl, VT, OpLHS);
6795 return DAG.getNode(AArch64ISD::REV32, dl, VT, OpLHS);
6798 return DAG.getNode(AArch64ISD::REV16, dl, VT, OpLHS);
6874 SDValue V1Cst = DAG.getNode(ISD::BITCAST, DL, IndexVT, V1);
6875 SDValue V2Cst = DAG.getNode(ISD::BITCAST, DL, IndexVT, V2);
6908 return DAG.getNode(ISD::BITCAST, DL, Op.getValueType(), Shuffle);
6947 return DAG.getNode(AArch64ISD::DUP, dl, V1.getValueType(),
6953 return DAG.getNode(AArch64ISD::DUP, dl, VT, V1.getOperand(Lane));
7108 return DAG.getNode(AArch64ISD::DUP, dl, VT, SplatVal);
7145 SDValue Mov = DAG.getNode(NewOp, dl, MovTy,
7147 return DAG.getNode(AArch64ISD::NVCAST, dl, VT, Mov);
7195 return DAG.getNode(AArch64ISD::NVCAST, dl, VT, Mov);
7235 return DAG.getNode(AArch64ISD::NVCAST, dl, VT, Mov);
7266 return DAG.getNode(AArch64ISD::NVCAST, dl, VT, Mov);
7285 SDValue Mov = DAG.getNode(NewOp, dl, MovTy,
7287 return DAG.getNode(AArch64ISD::NVCAST, dl, VT, Mov);
7316 SDValue Mov = DAG.getNode(NewOp, dl, MovTy,
7318 return DAG.getNode(AArch64ISD::NVCAST, dl, VT, Mov);
7625 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value);
7697 return DAG.getNode(AArch64ISD::DUP, dl, VT, Value);
7725 Ops.push_back(DAG.getNode(ISD::BITCAST, dl, NewType, Op.getOperand(i)));
7732 return DAG.getNode(ISD::BITCAST, dl, VT, Val);
7746 Val = DAG.getNode(AArch64ISD::DUP, dl, VT, ConstantValue);
7803 Vec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op0);
8039 SDValue NegShift = DAG.getNode(AArch64ISD::NEG, DL, VT, Op.getOperand(1));
8070 Fcmeq = DAG.getNode(AArch64ISD::FCMEQz, dl, VT, LHS);
8073 return DAG.getNode(AArch64ISD::NOT, dl, VT, Fcmeq);
8077 return DAG.getNode(AArch64ISD::FCMEQz, dl, VT, LHS);
8081 return DAG.getNode(AArch64ISD::FCMGEz, dl, VT, LHS);
8085 return DAG.getNode(AArch64ISD::FCMGTz, dl, VT, LHS);
8089 return DAG.getNode(AArch64ISD::FCMLEz, dl, VT, LHS);
8098 return DAG.getNode(AArch64ISD::FCMLTz, dl, VT, LHS);
8109 Cmeq = DAG.getNode(AArch64ISD::CMEQz, dl, VT, LHS);
8112 return DAG.getNode(AArch64ISD::NOT, dl, VT, Cmeq);
8116 return DAG.getNode(AArch64ISD::CMEQz, dl, VT, LHS);
8120 return DAG.getNode(AArch64ISD::CMGEz, dl, VT, LHS);
8124 return DAG.getNode(AArch64ISD::CMGTz, dl, VT, LHS);
8128 return DAG.getNode(AArch64ISD::CMLEz, dl, VT, LHS);
8136 return DAG.getNode(AArch64ISD::CMLTz, dl, VT, LHS);
8168 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::v4f32, LHS);
8169 RHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::v4f32, RHS);
8212 auto Rdx = DAG.getNode(Op, DL, VecOp.getSimpleValueType(), VecOp);
9289 return DAG.getNode(AArch64ISD::CMGEz, SDLoc(N), VT, Shift.getOperand(0));
9509 SDValue SourceConst = DAG.getNode(N->getOpcode(), DL, VT, SDValue(BV, 0));
9511 SDValue MaskConst = DAG.getNode(ISD::BITCAST, DL, IntVT, SourceConst);
9514 SDValue Res = DAG.getNode(ISD::BITCAST, DL, VT, NewAnd);
9554 return DAG.getNode(Opcode, SDLoc(N), VT, Load);
9630 FixConv = DAG.getNode(ISD::TRUNCATE, DL, N->getValueType(0), FixConv);
9694 ConvInput = DAG.getNode(IsSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, DL,
10001 return DAG.getNode(ISD::TRUNCATE, dl, VT,
10004 DAG.getNode(ISD::BITCAST, dl, MidVT, N00),
10005 DAG.getNode(ISD::BITCAST, dl, MidVT, N10), Mask));
10045 return DAG.getNode(ISD::BITCAST, dl, VT,
10047 DAG.getNode(ISD::BITCAST, dl, RHSTy, N0),
10326 RHS = DAG.getNode(ExtType, SDLoc(N), VT, RHS);
10332 LHS = DAG.getNode(ExtType, SDLoc(N), VT, LHS);
10462 DAG.getNode(Opc, dl,
10543 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), N->getValueType(0),
10599 Src = DAG.getNode(N->getOpcode(), DL, SrcVT, Src);
10616 Lo = DAG.getNode(N->getOpcode(), DL, LoVT, Lo);
10617 Hi = DAG.getNode(N->getOpcode(), DL, HiVT, Hi);
11640 DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, SrcVT, N0.getOperand(0));
11642 DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, SrcVT, N0.getOperand(1));
11648 Mask = DAG.getNode(ISD::BITCAST, DL,
11940 Op = DAG.getNode(ISD::BITCAST, DL, MVT::i32, Op);
11941 Results.push_back(DAG.getNode(ISD::TRUNCATE, DL, MVT::i16, Op));
11954 SDValue SplitVal = DAG.getNode(AcrossOp, dl, LoVT, InterVal);
11960 SDValue Lo = DAG.getNode(ISD::TRUNCATE, DL, MVT::i64, N);
11961 SDValue Hi = DAG.getNode(ISD::TRUNCATE, DL, MVT::i64,
lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp 418 SDValue TiedIn = CurDAG->getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), VT, Lo);
459 TiedIn = CurDAG->getNode(ISD::BITCAST, SDLoc(N), VT, TiedIn);
lib/Target/AMDGPU/AMDGPUISelLowering.cpp 1028 return DAG.getNode(AMDGPUISD::ENDPGM, DL, MVT::Other, Chain);
1233 SDValue Lo = DAG.getNode(ISD::BITCAST, SL, MVT::i32, Op.getOperand(0));
1234 SDValue Hi = DAG.getNode(ISD::BITCAST, SL, MVT::i32, Op.getOperand(1));
1237 return DAG.getNode(ISD::BITCAST, SL, VT, BV);
1336 SDValue Vec = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, Op);
1350 SDValue Vec = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, Op);
1358 SDValue Vec = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, Op);
1573 SDValue fa = DAG.getNode(ToFp, DL, FltVT, ia);
1576 SDValue fb = DAG.getNode(ToFp, DL, FltVT, ib);
1579 fa, DAG.getNode(AMDGPUISD::RCP, DL, FltVT, fb));
1582 fq = DAG.getNode(ISD::FTRUNC, DL, FltVT, fq);
1585 SDValue fqneg = DAG.getNode(ISD::FNEG, DL, FltVT, fq);
1594 SDValue iq = DAG.getNode(ToInt, DL, IntVT, fq);
1597 fr = DAG.getNode(ISD::FABS, DL, FltVT, fr);
1600 fb = DAG.getNode(ISD::FABS, DL, FltVT, fb);
1663 Results.push_back(DAG.getNode(ISD::BITCAST, DL, MVT::i64, DIV));
1664 Results.push_back(DAG.getNode(ISD::BITCAST, DL, MVT::i64, REM));
1674 SDValue Cvt_Lo = DAG.getNode(ISD::UINT_TO_FP, DL, MVT::f32, RHS_Lo);
1675 SDValue Cvt_Hi = DAG.getNode(ISD::UINT_TO_FP, DL, MVT::f32, RHS_Hi);
1679 SDValue Rcp = DAG.getNode(AMDGPUISD::RCP, DL, MVT::f32, Mad1);
1684 SDValue Trunc = DAG.getNode(ISD::FTRUNC, DL, MVT::f32, Mul2);
1688 SDValue Rcp_Lo = DAG.getNode(ISD::FP_TO_UINT, DL, HalfVT, Mad2);
1689 SDValue Rcp_Hi = DAG.getNode(ISD::FP_TO_UINT, DL, HalfVT, Trunc);
1806 REM = DAG.getNode(ISD::BITCAST, DL, MVT::i64, REM);
1819 HBit = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, HBit);
1837 DIV = DAG.getNode(ISD::BITCAST, DL, MVT::i64, DIV);
1863 SDValue RCP = DAG.getNode(AMDGPUISD::URECIP, DL, VT, Den);
1984 DAG.getNode(ISD::SIGN_EXTEND, DL, VT, DIVREM.getValue(0)),
1985 DAG.getNode(ISD::SIGN_EXTEND, DL, VT, DIVREM.getValue(1))
2027 SDValue Floor = DAG.getNode(ISD::FTRUNC, SL, VT, Div);
2041 SDValue Trunc = DAG.getNode(ISD::FTRUNC, SL, MVT::f64, Src);
2082 SDValue VecSrc = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, Src);
2098 SignBit64 = DAG.getNode(ISD::BITCAST, SL, MVT::i64, SignBit64);
2100 SDValue BcInt = DAG.getNode(ISD::BITCAST, SL, MVT::i64, Src);
2119 return DAG.getNode(ISD::BITCAST, SL, MVT::f64, Tmp2);
2137 SDValue Fabs = DAG.getNode(ISD::FABS, SL, MVT::f64, Src);
2153 return DAG.getNode(ISD::FRINT, SDLoc(Op), Op.getValueType(), Op.getOperand(0));
2166 SDValue T = DAG.getNode(ISD::FTRUNC, SL, VT, X);
2172 SDValue AbsDiff = DAG.getNode(ISD::FABS, SL, VT, Diff);
2194 SDValue L = DAG.getNode(ISD::BITCAST, SL, MVT::i64, X);
2203 SDValue BC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, X);
2228 K = DAG.getNode(ISD::BITCAST, SL, MVT::f64, K);
2267 SDValue Trunc = DAG.getNode(ISD::FTRUNC, SL, MVT::f64, Src);
2290 SDValue Log2Operand = DAG.getNode(ISD::FLOG2, SL, VT, Operand);
2304 return DAG.getNode(ISD::FEXP2, SL, VT, Mul, Op->getFlags());
2333 return DAG.getNode(NewOpc, SL, MVT::i32, Src);
2335 SDValue Vec = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, Src);
2349 SDValue OprLo = DAG.getNode(ISDOpc, SL, MVT::i32, Lo);
2350 SDValue OprHi = DAG.getNode(ISDOpc, SL, MVT::i32, Hi);
2386 return DAG.getNode(ISD::ZERO_EXTEND, SL, MVT::i64, NewOpr);
2429 SDValue LZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, SL, MVT::i64, L);
2430 LZ = DAG.getNode(ISD::TRUNCATE, SL, MVT::i32, LZ);
2450 DAG.getNode(ISD::TRUNCATE, SL, MVT::i32, UShl));
2465 R = DAG.getNode(ISD::BITCAST, SL, MVT::f32, R);
2470 SDValue RNeg = DAG.getNode(ISD::FNEG, SL, MVT::f32, R);
2479 SDValue BC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, Src);
2486 SDValue CvtHi = DAG.getNode(Signed ? ISD::SINT_TO_FP : ISD::UINT_TO_FP,
2489 SDValue CvtLo = DAG.getNode(ISD::UINT_TO_FP, SL, MVT::f64, Lo);
2509 SDValue IntToFp32 = DAG.getNode(Op.getOpcode(), DL, MVT::f32, Src);
2536 SDValue IntToFp32 = DAG.getNode(Op.getOpcode(), DL, MVT::f32, Src);
2557 SDValue Trunc = DAG.getNode(ISD::FTRUNC, SL, MVT::f64, Src);
2566 SDValue FloorMul = DAG.getNode(ISD::FFLOOR, SL, MVT::f64, Mul);
2571 SDValue Hi = DAG.getNode(Signed ? ISD::FP_TO_SINT : ISD::FP_TO_UINT, SL,
2573 SDValue Lo = DAG.getNode(ISD::FP_TO_UINT, SL, MVT::i32, Fma);
2577 return DAG.getNode(ISD::BITCAST, SL, MVT::i64, Result);
2586 return DAG.getNode(AMDGPUISD::FP_TO_FP16, DL, Op.getValueType(), N0);
2601 SDValue U = DAG.getNode(ISD::BITCAST, DL, MVT::i64, N0);
2689 SDValue FPExtend = DAG.getNode(ISD::FP_EXTEND, DL, MVT::f32, Src);
2691 DAG.getNode(Op.getOpcode(), DL, MVT::i64, FPExtend);
2712 SDValue FPExtend = DAG.getNode(ISD::FP_EXTEND, DL, MVT::f32, Src);
2714 DAG.getNode(Op.getOpcode(), DL, MVT::i64, FPExtend);
2889 SDValue BC = DAG.getNode(ISD::BITCAST, SL, VT, NewLoad);
2940 SDValue CastVal = DAG.getNode(ISD::BITCAST, SL, NewVT, Val);
2942 SDValue CastBack = DAG.getNode(ISD::BITCAST, SL, VT, CastVal);
2969 return DAG.getNode(ISD::TRUNCATE, SL, N->getValueType(0), NewInReg);
3010 return DAG.getNode(ISD::BITCAST, SL, MVT::i64, Vec);
3043 return DAG.getNode(ISD::BITCAST, SL, MVT::i32, Vec);
3072 SDValue Lo = DAG.getNode(ISD::TRUNCATE, SL, MVT::i32, LHS);
3078 return DAG.getNode(ISD::BITCAST, SL, MVT::i64, Vec);
3101 return DAG.getNode(ISD::BITCAST, SL, MVT::i64, BuildVec);
3110 return DAG.getNode(ISD::BITCAST, SL, MVT::i64, BuildVec);
3154 SDValue VecOp = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, LHS);
3162 return DAG.getNode(ISD::BITCAST, SL, MVT::i64, BuildPair);
3180 Elt0 = DAG.getNode(ISD::BITCAST, SL,
3184 return DAG.getNode(ISD::TRUNCATE, SL, VT, Elt0);
3201 SrcElt = DAG.getNode(ISD::BITCAST, SL,
3205 return DAG.getNode(ISD::TRUNCATE, SL, VT, SrcElt);
3231 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SL, MidVT,
3242 return DAG.getNode(ISD::TRUNCATE, SL, VT, ShrunkShift);
3409 Op = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, Op);
3411 SDValue FFBX = DAG.getNode(Opc, DL, MVT::i32, Op);
3413 FFBX = DAG.getNode(ISD::TRUNCATE, DL, VT, FFBX);
3472 return DAG.getNode(Op, SL, VT, NewSelect);
3524 NewRHS = DAG.getNode(ISD::FNEG, SL, VT, RHS);
3534 return DAG.getNode(LHS.getOpcode(), SL, VT, NewSelect);
3665 LHS = DAG.getNode(ISD::FNEG, SL, VT, LHS);
3670 RHS = DAG.getNode(ISD::FNEG, SL, VT, RHS);
3678 DAG.ReplaceAllUsesWith(N0, DAG.getNode(ISD::FNEG, SL, VT, Res));
3693 RHS = DAG.getNode(ISD::FNEG, SL, VT, RHS);
3699 DAG.ReplaceAllUsesWith(N0, DAG.getNode(ISD::FNEG, SL, VT, Res));
3717 MHS = DAG.getNode(ISD::FNEG, SL, VT, MHS);
3720 RHS = DAG.getNode(ISD::FNEG, SL, VT, RHS);
3728 DAG.ReplaceAllUsesWith(N0, DAG.getNode(ISD::FNEG, SL, VT, Res));
3750 SDValue NegLHS = DAG.getNode(ISD::FNEG, SL, VT, LHS);
3751 SDValue NegRHS = DAG.getNode(ISD::FNEG, SL, VT, RHS);
3758 DAG.ReplaceAllUsesWith(N0, DAG.getNode(ISD::FNEG, SL, VT, Res));
3764 Ops[I] = DAG.getNode(ISD::FNEG, SL, VT, N0->getOperand(I), N0->getFlags());
3770 DAG.ReplaceAllUsesWith(N0, DAG.getNode(ISD::FNEG, SL, VT, Res));
3787 return DAG.getNode(Opc, SL, VT, CvtSrc.getOperand(0));
3795 SDValue Neg = DAG.getNode(ISD::FNEG, SL, CvtSrc.getValueType(), CvtSrc);
3796 return DAG.getNode(Opc, SL, VT, Neg, N0->getFlags());
3811 SDValue Neg = DAG.getNode(ISD::FNEG, SL, CvtSrc.getValueType(), CvtSrc);
3826 return DAG.getNode(ISD::FP16_TO_FP, SL, N->getValueType(0), IntFNeg);
3851 return DAG.getNode(ISD::FP16_TO_FP, SL, N->getValueType(0), IntFAbs);
3899 CastedElts.push_back(DAG.getNode(ISD::BITCAST, DL, DestEltVT, Elt));
3922 return DAG.getNode(ISD::BITCAST, SL, DestVT, BV);
3934 return DAG.getNode(ISD::BITCAST, SL, DestVT, Vec);
4363 return DAG.getNode(AMDGPUISD::RSQ, SDLoc(Operand), VT, Operand);
4384 return DAG.getNode(AMDGPUISD::RCP, SDLoc(Operand), VT, Operand);
lib/Target/AMDGPU/R600ISelLowering.cpp 635 return DAG.getNode(AMDGPUISD::RSQ, DL, VT, Op.getOperand(1));
638 return DAG.getNode(AMDGPUISD::RSQ_CLAMP, DL, VT, Op.getOperand(1));
752 return DAG.getNode(AMDGPUISD::CONST_DATA_PTR, SDLoc(GSD), ConstPtrVT, GA);
763 SDValue FractPart = DAG.getNode(AMDGPUISD::FRACT, DL, VT,
779 SDValue TrigVal = DAG.getNode(TrigNode, DL, VT,
1034 True = DAG.getNode(ISD::BITCAST, DL, CompareVT, True);
1035 False = DAG.getNode(ISD::BITCAST, DL, CompareVT, False);
1054 return DAG.getNode(ISD::BITCAST, DL, VT, SelectNode);
1193 SDValue SExtValue = DAG.getNode(ISD::SIGN_EXTEND, DL, MVT::i32,
1223 Chain = DAG.getNode(AMDGPUISD::DUMMY_CHAIN, DL, MVT::Other, NewStore);
1251 SDValue NewChain = DAG.getNode(AMDGPUISD::DUMMY_CHAIN, DL, MVT::Other, Chain);
1314 Ptr = DAG.getNode(AMDGPUISD::DWORDADDR, DL, PtrVT, DWordAddr);
1335 Ptr = DAG.getNode(AMDGPUISD::DWORDADDR, DL, PtrVT, DWordAddr);
1523 Ptr = DAG.getNode(AMDGPUISD::DWORDADDR, DL, MVT::i32, Ptr);
1827 Slots[i] = DAG.getNode(AMDGPUISD::CONST_ADDRESS, DL, MVT::i32, NewPtr);
1861 return DAG.getNode(ISD::UINT_TO_FP, DL, N->getValueType(0),
1939 DAG.getNode(ISD::ANY_EXTEND, DL, OpVT, InVal) :
1940 DAG.getNode(ISD::TRUNCATE, DL, OpVT, InVal);
lib/Target/AMDGPU/SIISelLowering.cpp 1486 SDValue ArgVal = DAG.getNode(ISD::TRUNCATE, SL, IntVT, Extract);
1487 ArgVal = DAG.getNode(ISD::BITCAST, SL, MemVT, ArgVal);
2192 Val = DAG.getNode(ISD::BITCAST, DL, ValVT, Val);
2197 Val = DAG.getNode(ISD::TRUNCATE, DL, ValVT, Val);
2202 Val = DAG.getNode(ISD::TRUNCATE, DL, ValVT, Val);
2205 Val = DAG.getNode(ISD::TRUNCATE, DL, ValVT, Val);
2320 Arg = DAG.getNode(ISD::BITCAST, DL, VA.getLocVT(), Arg);
2323 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Arg);
2326 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Arg);
2329 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Arg);
2399 Val = DAG.getNode(ISD::BITCAST, DL, VA.getValVT(), Val);
2404 Val = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Val);
2409 Val = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Val);
2412 Val = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Val);
2793 Arg = DAG.getNode(ISD::BITCAST, DL, VA.getLocVT(), Arg);
2796 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Arg);
2799 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Arg);
2802 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Arg);
2805 Arg = DAG.getNode(ISD::FP_EXTEND, DL, VA.getLocVT(), Arg);
3958 SDValue OpLo = DAG.getNode(Opc, SL, Lo.getValueType(), Lo,
3960 SDValue OpHi = DAG.getNode(Opc, SL, Hi.getValueType(), Hi,
4101 Elt = DAG.getNode(ISD::TRUNCATE, DL, MVT::i16, Elt);
4106 return DAG.getNode(ISD::BITCAST, DL, LoadVT, Result);
4110 return DAG.getNode(ISD::BITCAST, DL, LoadVT, Result);
4177 {DAG.getNode(ISD::BITCAST, DL, LoadVT, MemNode), MemNode.getValue(1)},
4201 LHS = DAG.getNode(PromoteOp, DL, MVT::i32, LHS);
4202 RHS = DAG.getNode(PromoteOp, DL, MVT::i32, RHS);
4234 Src0 = DAG.getNode(ISD::FP_EXTEND, SL, MVT::f32, Src0);
4235 Src1 = DAG.getNode(ISD::FP_EXTEND, SL, MVT::f32, Src1);
4272 Results.push_back(DAG.getNode(ISD::BITCAST, SL, MVT::v2f16, Cvt));
4298 Results.push_back(DAG.getNode(ISD::BITCAST, SL, MVT::v2i16, Cvt));
4324 SDValue LHS = DAG.getNode(ISD::BITCAST, SL, NewVT, N->getOperand(1));
4325 SDValue RHS = DAG.getNode(ISD::BITCAST, SL, NewVT, N->getOperand(2));
4329 LHS = DAG.getNode(ISD::ANY_EXTEND, SL, MVT::i32, LHS);
4330 RHS = DAG.getNode(ISD::ANY_EXTEND, SL, MVT::i32, RHS);
4338 NewSelect = DAG.getNode(ISD::TRUNCATE, SL, NewVT, NewSelect);
4339 Results.push_back(DAG.getNode(ISD::BITCAST, SL, VT, NewSelect));
4347 SDValue BC = DAG.getNode(ISD::BITCAST, SL, MVT::i32, N->getOperand(0));
4352 Results.push_back(DAG.getNode(ISD::BITCAST, SL, MVT::v2f16, Op));
4360 SDValue BC = DAG.getNode(ISD::BITCAST, SL, MVT::i32, N->getOperand(0));
4365 Results.push_back(DAG.getNode(ISD::BITCAST, SL, MVT::v2f16, Op));
4563 DAG.getNode(ISD::FP_EXTEND, DL, VT, Op) :
4564 DAG.getNode(ISD::FTRUNC, DL, VT, Op);
4578 SDValue FpToFp16 = DAG.getNode(ISD::FP_TO_FP16, DL, MVT::i32, Src);
4579 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, DL, MVT::i16, FpToFp16);
4580 return DAG.getNode(ISD::BITCAST, DL, MVT::f16, Trunc);
4608 return DAG.getNode(AMDGPUISD::ENDPGM, SL, MVT::Other, Chain);
4720 SDValue Ptr = DAG.getNode(ISD::TRUNCATE, SL, MVT::i32, Src);
4744 DAG.getNode(ISD::BITCAST, SL, MVT::i64, CvtPtr),
4803 SDValue BCVec = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, Vec);
4810 SDValue LoVec = DAG.getNode(ISD::BITCAST, SL, MVT::v2i16, LoHalf);
4811 SDValue HiVec = DAG.getNode(ISD::BITCAST, SL, MVT::v2i16, HiHalf);
4817 DAG.getNode(ISD::BITCAST, SL, MVT::i16, InsVal),
4820 InsHalf = DAG.getNode(ISD::BITCAST, SL, MVT::i32, InsHalf);
4826 return DAG.getNode(ISD::BITCAST, SL, VecVT, Concat);
4839 SDValue ExtVal = DAG.getNode(ISD::BITCAST, SL, IntVT,
4848 SDValue BCVec = DAG.getNode(ISD::BITCAST, SL, IntVT, Vec);
4858 return DAG.getNode(ISD::BITCAST, SL, VecVT, BFI);
4891 SDValue BC = DAG.getNode(ISD::BITCAST, SL, IntVT, Vec);
4895 SDValue Result = DAG.getNode(ISD::TRUNCATE, SL, MVT::i16, Elt);
4896 return DAG.getNode(ISD::BITCAST, SL, ResultVT, Result);
4974 SDValue CastLo = DAG.getNode(ISD::BITCAST, SL, MVT::i32, Lo);
4975 SDValue CastHi = DAG.getNode(ISD::BITCAST, SL, MVT::i32, Hi);
4978 return DAG.getNode(ISD::BITCAST, SL, VT, Blend);
4989 Lo = DAG.getNode(ISD::BITCAST, SL, MVT::i16, Lo);
4990 SDValue ExtLo = DAG.getNode(ISD::ANY_EXTEND, SL, MVT::i32, Lo);
4991 return DAG.getNode(ISD::BITCAST, SL, VT, ExtLo);
4994 Hi = DAG.getNode(ISD::BITCAST, SL, MVT::i16, Hi);
4995 Hi = DAG.getNode(ISD::ZERO_EXTEND, SL, MVT::i32, Hi);
5000 return DAG.getNode(ISD::BITCAST, SL, VT, ShlHi);
5002 Lo = DAG.getNode(ISD::BITCAST, SL, MVT::i16, Lo);
5003 Lo = DAG.getNode(ISD::ZERO_EXTEND, SL, MVT::i32, Lo);
5006 return DAG.getNode(ISD::BITCAST, SL, VT, Or);
5083 return DAG.getNode(AMDGPUISD::LDS, DL, MVT::i32, GA);
5255 SDValue CastRes = DAG.getNode(ISD::BITCAST, DL, CastVT, N);
5281 PreTFCRes = DAG.getNode(ISD::BITCAST, DL, MVT::v4f16, PreTFCRes);
5293 SDValue TFCRes = DAG.getNode(ISD::BITCAST, DL, ResultTypes[1], TFCElt[0]);
5750 return DAG.getNode(AMDGPUISD::RCP, DL, VT, Op.getOperand(1));
5752 return DAG.getNode(AMDGPUISD::RSQ, DL, VT, Op.getOperand(1));
5757 return DAG.getNode(AMDGPUISD::RSQ_LEGACY, DL, VT, Op.getOperand(1));
5761 return DAG.getNode(AMDGPUISD::RCP_LEGACY, DL, VT, Op.getOperand(1));
5764 return DAG.getNode(AMDGPUISD::RSQ_CLAMP, DL, VT, Op.getOperand(1));
5770 SDValue Rsq = DAG.getNode(AMDGPUISD::RSQ, DL, VT, Op.getOperand(1));
5931 return DAG.getNode(AMDGPUISD::SIN_HW, DL, VT, Op.getOperand(1));
5934 return DAG.getNode(AMDGPUISD::COS_HW, DL, VT, Op.getOperand(1));
5956 return DAG.getNode(AMDGPUISD::FRACT, DL, VT, Op.getOperand(1));
6013 return DAG.getNode(AMDGPUISD::FFBH_I32, DL, VT, Op.getOperand(1));
6045 return DAG.getNode(ISD::BITCAST, DL, VT, Node);
6073 SDValue SrcVec = DAG.getNode(ISD::BITCAST, DL, MVT::v2i32,
6754 SDValue IntVData = DAG.getNode(ISD::BITCAST, DL, IntStoreVT, VData);
6758 SDValue ZExt = DAG.getNode(ISD::ZERO_EXTEND, DL, EquivStoreVT, IntVData);
6809 DAG.getNode(ISD::BITCAST, DL, MVT::f32, Src0),
6810 DAG.getNode(ISD::BITCAST, DL, MVT::f32, Src1),
6967 DAG.getNode(ISD::BITCAST, DL,
7012 DAG.getNode(ISD::BITCAST, DL,
7207 SDValue LoadVal = DAG.getNode(ISD::TRUNCATE, DL, IntVT, BufferLoad);
7208 LoadVal = DAG.getNode(ISD::BITCAST, DL, LoadVT, LoadVal);
7219 Ops[1] = DAG.getNode(ISD::BITCAST, DL, MVT::i16, Ops[1]);
7221 SDValue BufferStoreExt = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, Ops[1]);
7234 return DAG.getNode(ISD::TRUNCATE, SL, VT, Op);
7238 return DAG.getNode(ISD::SIGN_EXTEND, SL, VT, Op);
7240 return DAG.getNode(ISD::ZERO_EXTEND, SL, VT, Op);
7242 return DAG.getNode(ISD::ANY_EXTEND, SL, VT, Op);
7315 Cvt = DAG.getNode(ISD::BITCAST, SL, VT, Cvt);
7344 DAG.getNode(ISD::TRUNCATE, DL, MemVT, NewLD),
7356 Elts.push_back(DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, Elt));
7497 SDValue LHS = DAG.getNode(ISD::BITCAST, DL, MVT::v2i32, Op.getOperand(1));
7498 SDValue RHS = DAG.getNode(ISD::BITCAST, DL, MVT::v2i32, Op.getOperand(2));
7511 return DAG.getNode(ISD::BITCAST, DL, VT, Res);
7543 return DAG.getNode(AMDGPUISD::RSQ, SL, VT, RHS.getOperand(0));
7546 return DAG.getNode(AMDGPUISD::RCP, SL, VT, RHS);
7552 SDValue FNegRHS = DAG.getNode(ISD::FNEG, SL, VT, RHS);
7553 return DAG.getNode(AMDGPUISD::RCP, SL, VT, FNegRHS);
7561 SDValue Recip = DAG.getNode(AMDGPUISD::RCP, SL, VT, RHS);
7617 SDValue CvtSrc0 = DAG.getNode(ISD::FP_EXTEND, SL, MVT::f32, Src0);
7618 SDValue CvtSrc1 = DAG.getNode(ISD::FP_EXTEND, SL, MVT::f32, Src1);
7620 SDValue RcpSrc1 = DAG.getNode(AMDGPUISD::RCP, SL, MVT::f32, CvtSrc1);
7635 SDValue r1 = DAG.getNode(ISD::FABS, SL, MVT::f32, RHS);
7656 SDValue r0 = DAG.getNode(AMDGPUISD::RCP, SL, MVT::f32, r1);
7694 SDValue ApproxRcp = DAG.getNode(AMDGPUISD::RCP, SL, MVT::f32,
7696 SDValue NegDivScale0 = DAG.getNode(ISD::FNEG, SL, MVT::f32,
7793 SDValue NegDivScale0 = DAG.getNode(ISD::FNEG, SL, MVT::f64, DivScale0);
7795 SDValue Rcp = DAG.getNode(AMDGPUISD::RCP, SL, MVT::f64, DivScale0);
7820 SDValue NumBC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, X);
7821 SDValue DenBC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, Y);
7822 SDValue Scale0BC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, DivScale0);
7823 SDValue Scale1BC = DAG.getNode(ISD::BITCAST, SL, MVT::v2i32, DivScale1);
7957 TrigVal = DAG.getNode(AMDGPUISD::FRACT, DL, VT, MulVal);
7964 return DAG.getNode(AMDGPUISD::COS_HW, SDLoc(Op), VT, TrigVal);
7966 return DAG.getNode(AMDGPUISD::SIN_HW, SDLoc(Op), VT, TrigVal);
8022 SDValue Cvt = DAG.getNode(AMDGPUISD::CVT_F32_UBYTE0, DL, VT, Src);
8526 return DAG.getNode(ISD::BITCAST, SL, MVT::i64, Vec);
8636 return DCI.DAG.getNode(AMDGPUISD::FP16_ZEXT, SDLoc(N), VT, BCSrc);
8706 return DCI.DAG.getNode(AMDGPUISD::RCP_IFLAG, SDLoc(N), VT, N0,
8945 NewElts[I] = DAG.getNode(ISD::FCANONICALIZE, SL, EltVT, Op);
8978 SDValue Canon0 = DAG.getNode(ISD::FCANONICALIZE, SL, VT,
9041 SDValue Tmp1 = DAG.getNode(ExtOp, SL, NVT, Op0->getOperand(0));
9042 SDValue Tmp2 = DAG.getNode(ExtOp, SL, NVT, Op0->getOperand(1));
9043 SDValue Tmp3 = DAG.getNode(ExtOp, SL, NVT, Op1);
9046 return DAG.getNode(ISD::TRUNCATE, SL, VT, Med3);
9088 return DAG.getNode(AMDGPUISD::CLAMP, SL, VT, Op0.getOperand(0));
9214 return DAG.getNode(AMDGPUISD::CLAMP, SL, VT, Src2);
9235 return DAG.getNode(AMDGPUISD::CLAMP, SL, VT, Src0);
9265 return DAG.getNode(Vec.getOpcode(), SL, EltVT, Elt);
9352 SDValue Cast = DAG.getNode(ISD::BITCAST, SL, NewVT, Vec);
9362 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SL, EltVT.changeTypeToInteger(), Srl);
9364 return DAG.getNode(ISD::BITCAST, SL, EltVT, Trunc);
9477 return DAG.getNode(ISD::TRUNCATE, SL, VT, Mad);
9671 SDValue NegRHS = DAG.getNode(ISD::FNEG, SL, VT, RHS);
9889 return DAG.getNode(AMDGPUISD::CVT_F32_UBYTE0 + SrcOffset / 8, SL,
10047 Src = DAG.getNode(ISD::BITCAST, SL, MVT::i16, Src);
10049 SDValue Ext = DAG.getNode(ISD::ANY_EXTEND, SL, MVT::i32, Src);
10050 return DAG.getNode(ISD::BITCAST, SL, VT, Ext);
lib/Target/ARC/ARCISelLowering.cpp 213 return DAG.getNode(ARCISD::GAWRAPPER, SDLoc(N), MVT::i32, GA);
273 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
276 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
279 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
730 return DAG.getNode(ARCISD::GAWRAPPER, dl, MVT::i32, GA);
lib/Target/ARM/ARMISelLowering.cpp 1995 Val = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), Val);
2143 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
2146 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
2149 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
2152 Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
2297 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2311 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2326 Callee = DAG.getNode(
2345 DAG.getNode(ARMISD::Wrapper, dl, PtrVt, Callee),
2361 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
2782 Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
3014 return DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Res);
3041 CPAddr = DAG.getNode(ARMISD::Wrapper, DL, PtrVT, CPAddr);
3155 TLSIndex = DAG.getNode(ARMISD::Wrapper, DL, PtrVT, TLSIndex);
3168 PtrVT, DL, Chain, DAG.getNode(ARMISD::Wrapper, DL, MVT::i32,
3189 Argument = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Argument);
3240 Offset = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Offset);
3258 Offset = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, Offset);
3411 return DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
3453 SDValue Result = DAG.getNode(ARMISD::WrapperPIC, dl, PtrVT, G);
3462 SDValue Result = DAG.getNode(ARMISD::WrapperPIC, dl, PtrVT, G);
3470 RelAddr = DAG.getNode(ARMISD::Wrapper, dl, PtrVT, G);
3475 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
3491 return DAG.getNode(ARMISD::Wrapper, dl, PtrVT,
3495 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
3519 SDValue Result = DAG.getNode(Wrapper, dl, PtrVT, G);
3550 Result = DAG.getNode(ARMISD::Wrapper, DL, PtrVT,
3578 return DAG.getNode(ARMISD::EH_SJLJ_SETUP_DISPATCH, dl, MVT::Other,
3645 SDValue Result = DAG.getNode(ISD::CTLZ, dl, VTy, OR);
3665 SDValue CLSHi = DAG.getNode(ISD::CTLZ, dl, VTy, ORHi);
3672 SDValue CLZAdjustedLo = DAG.getNode(ISD::CTLZ, dl, VTy, AdjustedLo);
3690 CPAddr = DAG.getNode(ARMISD::Wrapper, dl, MVT::i32, CPAddr);
3702 return DAG.getNode(ISD::ABS, SDLoc(Op), Op.getValueType(),
3749 return DAG.getNode(ARMISD::PREDICATE_CAST, SDLoc(Op), Op.getValueType(),
4086 ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
4091 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
4096 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
4329 Cmp = DAG.getNode(ARMISD::CMPFPw0, dl, MVT::Glue, LHS);
4330 return DAG.getNode(ARMISD::FMSTAT, dl, MVT::Glue, Cmp);
4349 Cmp = DAG.getNode(Opc, DL, MVT::Glue, Cmp.getOperand(0));
4351 return DAG.getNode(ARMISD::FMSTAT, DL, MVT::Glue, Cmp);
4538 return DAG.getNode(ISD::TRUNCATE, dl, VT, Add);
5301 Table = DAG.getNode(ARMISD::WrapperJT, dl, MVT::i32, JTI);
5355 Op = DAG.getNode(Op.getOpcode(), dl, NewTy, Op.getOperand(0));
5356 return DAG.getNode(ISD::TRUNCATE, dl, VT, Op);
5420 Op = DAG.getNode(CastOpc, dl, DestVecType, Op.getOperand(0));
5421 return DAG.getNode(Opc, dl, VT, Op);
5458 SDValue Mask = DAG.getNode(ARMISD::VMOVIMM, dl, MVT::v2i32,
5463 DAG.getNode(ISD::BITCAST, dl, OpVT, Mask),
5466 Tmp0 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f32, Tmp0);
5468 Tmp1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f32, Tmp1);
5471 DAG.getNode(ISD::BITCAST, dl, OpVT, Tmp1),
5475 DAG.getNode(ISD::BITCAST, dl, MVT::v1i64, Tmp1),
5477 Tmp0 = DAG.getNode(ISD::BITCAST, dl, OpVT, Tmp0);
5478 Tmp1 = DAG.getNode(ISD::BITCAST, dl, OpVT, Tmp1);
5482 AllOnes = DAG.getNode(ARMISD::VMOVIMM, dl, MVT::v8i8, AllOnes);
5484 DAG.getNode(ISD::BITCAST, dl, OpVT, AllOnes));
5490 Res = DAG.getNode(ISD::BITCAST, dl, MVT::v2f32, Res);
5494 Res = DAG.getNode(ISD::BITCAST, dl, MVT::f64, Res);
5504 Tmp1 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Tmp1);
5512 DAG.getNode(ISD::BITCAST, dl, MVT::i32, Tmp0), Mask2);
5513 return DAG.getNode(ISD::BITCAST, dl, MVT::f32,
5646 SDValue BitCast = DAG.getNode(ISD::BITCAST, dl, VecVT, ExtractSrc);
5699 return DAG.getNode(ARMISD::VMOVhr, SDLoc(Op),
5729 SDValue Cvt = DAG.getNode(ARMISD::VMOVrh, SDLoc(Op), MVT::i32, Op);
5750 return DAG.getNode(ISD::BITCAST, dl, DstVT,
5761 DAG.getNode(ARMISD::VREV64, dl, SrcVT, Op));
5783 SDValue Vmov = DAG.getNode(ARMISD::VMOVIMM, dl, VmovVT, EncodedVal);
5784 return DAG.getNode(ISD::BITCAST, dl, VT, Vmov);
5904 SDValue One = DAG.getNode(ARMISD::VMOVIMM, dl, VT,
5907 return DAG.getNode(ISD::CTPOP, dl, VT, Bits);
5915 DAG.getNode(ARMISD::VMOVIMM, dl, VT,
5917 SDValue CTLZ = DAG.getNode(ISD::CTLZ, dl, VT, LSB);
5927 SDValue FF = DAG.getNode(ARMISD::VMOVIMM, dl, VT,
5931 SDValue One = DAG.getNode(ARMISD::VMOVIMM, dl, VT,
5935 return DAG.getNode(ISD::CTPOP, dl, VT, Bits);
5941 SDValue rbit = DAG.getNode(ISD::BITREVERSE, dl, VT, N->getOperand(0));
5942 return DAG.getNode(ISD::CTLZ, dl, VT, rbit);
5958 Res = DAG.getNode(ISD::CTPOP, DL, VT8Bit, Res);
6193 SDValue CastOp0 = DAG.getNode(ISD::BITCAST, dl, SplitVT, Op0);
6194 SDValue CastOp1 = DAG.getNode(ISD::BITCAST, dl, SplitVT, Op1);
6197 SDValue Reversed = DAG.getNode(ARMISD::VREV64, dl, SplitVT, Cmp);
6199 Merged = DAG.getNode(ISD::BITCAST, dl, CmpVT, Merged);
6293 Op0 = DAG.getNode(ISD::BITCAST, dl, CmpVT, AndOp.getOperand(0));
6294 Op1 = DAG.getNode(ISD::BITCAST, dl, CmpVT, AndOp.getOperand(1));
6537 return DAG.getNode(ARMISD::VMOVSR, DL, VT,
6564 SDValue VecConstant = DAG.getNode(ARMISD::VMOVFPIMM, DL, MVT::v2f32,
6589 SDValue VecConstant = DAG.getNode(ARMISD::VMOVIMM, DL, VMovVT,
6592 return DAG.getNode(ISD::BITCAST, DL, MVT::f64, VecConstant);
6595 SDValue VecFConstant = DAG.getNode(ISD::BITCAST, DL, MVT::v2f32,
6606 SDValue VecConstant = DAG.getNode(ARMISD::VMVNIMM, DL, VMovVT, NewVal);
6609 return DAG.getNode(ISD::BITCAST, DL, MVT::f64, VecConstant);
6612 SDValue VecFConstant = DAG.getNode(ISD::BITCAST, DL, MVT::v2f32,
7063 return DAG.getNode(ARMISD::PREDICATE_CAST, dl, Op.getValueType(), Ext);
7078 SDValue Base = DAG.getNode(ARMISD::PREDICATE_CAST, dl, VT,
7119 SDValue Vmov = DAG.getNode(ARMISD::VMOVIMM, dl, VmovVT, Val);
7120 return DAG.getNode(ISD::BITCAST, dl, VT, Vmov);
7130 SDValue Vmov = DAG.getNode(ARMISD::VMVNIMM, dl, VmovVT, Val);
7131 return DAG.getNode(ISD::BITCAST, dl, VT, Vmov);
7139 return DAG.getNode(ARMISD::VMOVFPIMM, dl, VT, Val);
7191 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value);
7224 N = DAG.getNode(ARMISD::VDUP, dl, VT, Value);
7247 Ops.push_back(DAG.getNode(ISD::BITCAST, dl, IVT,
7253 return DAG.getNode(ISD::BITCAST, dl, VT, Val);
7258 return DAG.getNode(ARMISD::VDUP, dl, VT, Val);
7303 Ops.push_back(DAG.getNode(ISD::BITCAST, dl, EltVT, Op.getOperand(i)));
7305 return DAG.getNode(ISD::BITCAST, dl, VT, Val);
7474 Src.ShuffleVec = DAG.getNode(ISD::BITCAST, dl, ShuffleVT, Src.ShuffleVec);
7526 return DAG.getNode(ISD::BITCAST, dl, VT, Shuffle);
7638 return DAG.getNode(ARMISD::VREV64, dl, VT, OpLHS);
7641 return DAG.getNode(ARMISD::VREV32, dl, VT, OpLHS);
7644 return DAG.getNode(ARMISD::VREV16, dl, VT, OpLHS);
7701 OpLHS = DAG.getNode(ARMISD::VREV64, DL, VT, OpLHS);
7730 AllOnes = DAG.getNode(ARMISD::VMOVIMM, dl, MVT::v16i8, AllOnes);
7734 AllZeroes = DAG.getNode(ARMISD::VMOVIMM, dl, MVT::v16i8, AllZeroes);
7745 RecastV1 = DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::v16i1, Pred);
7755 return DAG.getNode(ISD::BITCAST, dl, NewVT, PredAsVector);
7770 SDValue cast = DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::i32, V1);
7771 SDValue rbit = DAG.getNode(ISD::BITREVERSE, dl, MVT::i32, cast);
7774 return DAG.getNode(ARMISD::PREDICATE_CAST, dl, VT, srl);
7826 return DAG.getNode(ARMISD::VDUP, dl, VT, V1.getOperand(0));
7840 return DAG.getNode(ARMISD::VDUP, dl, VT, V1.getOperand(0));
7856 return DAG.getNode(ARMISD::VREV64, dl, VT, V1);
7858 return DAG.getNode(ARMISD::VREV32, dl, VT, V1);
7860 return DAG.getNode(ARMISD::VREV16, dl, VT, V1);
7969 V1 = DAG.getNode(ISD::BITCAST, dl, VecVT, V1);
7970 V2 = DAG.getNode(ISD::BITCAST, dl, VecVT, V2);
7982 return DAG.getNode(ISD::BITCAST, dl, VT, Val);
8004 DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::i32, Op->getOperand(0));
8013 return DAG.getNode(ARMISD::PREDICATE_CAST, dl, Op.getValueType(), BFI);
8048 SDValue IElt = DAG.getNode(ISD::BITCAST, dl, IEltVT, Elt);
8049 SDValue IVecIn = DAG.getNode(ISD::BITCAST, dl, IVecVT, VecIn);
8052 return DAG.getNode(ISD::BITCAST, dl, VecVT, IVecOut);
8067 DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::i32, Op->getOperand(0));
8165 DAG.getNode(ISD::BITCAST, dl, MVT::f64, Op0),
8169 DAG.getNode(ISD::BITCAST, dl, MVT::f64, Op1),
8171 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Val);
8319 return DAG.getNode(ExtOpcode, SDLoc(N), NewVT, N);
8366 DAG.getNode(Opcode, SDLoc(newLoad), LD->getValueType(0), newLoad);
8493 DAG.getNode(ISD::BITCAST, DL, Op1VT, N00), Op1),
8495 DAG.getNode(ISD::BITCAST, DL, Op1VT, N01), Op1));
8505 X = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i32, X);
8506 Y = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i32, Y);
8507 X = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, X);
8508 Y = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, Y);
8519 X = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, X);
8522 X = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, X);
8524 X = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::v4i32, X);
8525 X = DAG.getNode(ISD::TRUNCATE, dl, MVT::v4i16, X);
8537 N0 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i32, N0);
8538 N1 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i32, N1);
8539 N0 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, N0);
8540 N1 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, N1);
8557 N0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, N0);
8560 N0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, N0);
8563 N0 = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::v4i32, N0);
8564 N0 = DAG.getNode(ISD::TRUNCATE, dl, MVT::v4i16, N0);
8580 N0 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v8i16, N0);
8581 N1 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v8i16, N1);
8598 N0 = DAG.getNode(ISD::TRUNCATE, dl, MVT::v8i8, N0);
8617 N0 = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v8i16, N0);
8618 N1 = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v8i16, N1);
8645 N0 = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v4i32, N0);
8646 N1 = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v4i32, N1);
8647 N0 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, N0);
8648 SDValue BN1 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::v4f32, N1);
8670 N0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, N0);
8673 N0 = DAG.getNode(ISD::BITCAST, dl, MVT::v4f32, N0);
8676 N0 = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::v4i32, N0);
8677 N0 = DAG.getNode(ISD::TRUNCATE, dl, MVT::v4i16, N0);
8919 SDValue Lower = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Result);
8922 Upper = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Upper);
8951 SDValue Pred = DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::v16i1, Load);
8980 SDValue GRP = DAG.getNode(ARMISD::PREDICATE_CAST, dl, MVT::i32, Build);
9005 SDValue ZeroVec = DAG.getNode(ARMISD::VMOVIMM, dl, VT,
9106 SDValue Exponent = DAG.getNode(ISD::SINT_TO_FP, dl, Ty, Op.getOperand(1));
11134 return DAG.getNode(ExtOp, dl, VT, tmp);
12034 DAG.getNode(ISD::BITCAST, dl, VbicVT, N->getOperand(0));
12036 return DAG.getNode(ISD::BITCAST, dl, VT, Vbic);
12341 DAG.getNode(ISD::BITCAST, dl, VorrVT, N->getOperand(0));
12343 return DAG.getNode(ISD::BITCAST, dl, VT, Vorr);
12393 return DAG.getNode(ISD::BITCAST, dl, VT, Result);
12627 return DAG.getNode(ISD::BITCAST, SDLoc(N),
12669 SDValue V = DAG.getNode(ISD::BITCAST, dl, MVT::f64, N->getOperand(i));
12676 return DAG.getNode(ISD::BITCAST, dl, VT, BV);
12758 V = DAG.getNode(ISD::BITCAST, SDLoc(V), MVT::i32, V);
12765 Vec = DAG.getNode(ISD::BITCAST, dl, VT, Vec);
12782 return DCI.DAG.getNode(ARMISD::PREDICATE_CAST, dl,
12805 SDValue Vec = DAG.getNode(ISD::BITCAST, dl, FloatVT, N->getOperand(0));
12806 SDValue V = DAG.getNode(ISD::BITCAST, dl, MVT::f64, N->getOperand(1));
12812 return DAG.getNode(ISD::BITCAST, dl, VT, InsElt);
13060 StVal = DAG.getNode(ISD::BITCAST, dl, AlignedVecTy, StVal);
13076 LdVal = DAG.getNode(ISD::BITCAST, dl, VecTy, LdVal);
13206 return DCI.DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
13284 SDValue WideVec = DAG.getNode(ISD::BITCAST, DL, WideVecVT, StVal);
13314 SDValue ShuffWide = DAG.getNode(ISD::BITCAST, DL, StoreVecVT, Shuff);
13443 SDValue Vec = DAG.getNode(ISD::BITCAST, dl, FloatVT, IntVec);
13447 SDValue V = DAG.getNode(ISD::BITCAST, dl, MVT::i64, ExtElt);
13517 FixConv = DAG.getNode(ISD::TRUNCATE, dl, N->getValueType(0), FixConv);
13569 ConvInput = DAG.getNode(isSigned ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND,
14317 Res = DAG.getNode(ISD::SRL, dl, VT, DAG.getNode(ISD::CTLZ, dl, VT, Sub),
16124 SrcVal = DAG.getNode(ISD::FP_EXTEND, Loc, MVT::f32, SrcVal);
16139 return DAG.getNode(ISD::FP_EXTEND, Loc, MVT::f64, SrcVal);
lib/Target/ARM/ARMSelectionDAGInfo.cpp 91 Src = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src);
93 Src = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Src);
lib/Target/AVR/AVRISelLowering.cpp 333 Victim = DAG.getNode(Opc8, dl, VT, Victim);
408 return DAG.getNode(AVRISD::WRAPPER, SDLoc(Op), getPointerTy(DL), Result);
418 return DAG.getNode(AVRISD::WRAPPER, SDLoc(Op), getPointerTy(DL), Result);
551 Cmp = DAG.getNode(AVRISD::TST, DL, MVT::Glue, Top);
589 Cmp = DAG.getNode(AVRISD::TST, DL, MVT::Glue, Top);
599 Cmp = DAG.getNode(AVRISD::TST, DL, MVT::Glue,
1095 ArgValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), ArgValue);
1100 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
1105 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
1209 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, RegVT, Arg);
1212 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, RegVT, Arg);
1215 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, RegVT, Arg);
1218 Arg = DAG.getNode(ISD::BITCAST, DL, RegVT, Arg);
lib/Target/BPF/BPFISelLowering.cpp 254 ArgValue = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), ArgValue);
337 Arg = DAG.getNode(ISD::SIGN_EXTEND, CLI.DL, VA.getLocVT(), Arg);
340 Arg = DAG.getNode(ISD::ZERO_EXTEND, CLI.DL, VA.getLocVT(), Arg);
343 Arg = DAG.getNode(ISD::ANY_EXTEND, CLI.DL, VA.getLocVT(), Arg);
423 return DAG.getNode(Opc, DL, MVT::Other, Chain);
560 return DAG.getNode(BPFISD::Wrapper, DL, MVT::i64, GA);
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp 2090 GA.Value = CurDAG->getNode(GA.Value.getOpcode(), SDLoc(GA.Value),
lib/Target/Hexagon/HexagonISelLowering.cpp 399 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
402 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
405 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
948 return DAG.getNode(HexagonISD::AT_PCREL, SDLoc(Op), ValTy, T);
949 return DAG.getNode(HexagonISD::CP, SDLoc(Op), ValTy, T);
958 return DAG.getNode(HexagonISD::AT_PCREL, SDLoc(Op), VT, T);
962 return DAG.getNode(HexagonISD::JT, SDLoc(Op), VT, T);
1011 return DAG.getNode(HexagonISD::BARRIER, dl, MVT::Other, Op.getOperand(0));
1029 return DAG.getNode(HexagonISD::CONST32_GP, dl, PtrVT, GA);
1030 return DAG.getNode(HexagonISD::CONST32, dl, PtrVT, GA);
1037 return DAG.getNode(HexagonISD::AT_PCREL, dl, PtrVT, GA);
1057 return DAG.getNode(HexagonISD::CONST32_GP, dl, PtrVT, A);
1061 return DAG.getNode(HexagonISD::AT_PCREL, dl, PtrVT, A);
1070 return DAG.getNode(HexagonISD::AT_PCREL, SDLoc(Op), PtrVT, GOTSym);
1128 SDValue Sym = DAG.getNode(HexagonISD::CONST32, dl, PtrVT, TGA);
1164 SDValue Sym = DAG.getNode(HexagonISD::CONST32, dl, PtrVT, TGA);
1189 SDValue Sym = DAG.getNode(HexagonISD::CONST32, dl, PtrVT, TGA);
1980 SDValue T1 = DAG.getNode(ISD::BSWAP, dl, MVT::i32, T0);
2007 SDValue T1 = DAG.getNode(ISD::BSWAP, dl, MVT::i64, T0);
2177 return DAG.getNode(HexagonISD::VSPLAT, dl, VecTy, Ext);
2239 return DAG.getNode(HexagonISD::VSPLAT, dl, VecTy, Ext);
2290 return DAG.getNode(HexagonISD::TYPECAST, dl, MVT::i1, VecV);
2313 SDValue T0 = DAG.getNode(HexagonISD::P2D, dl, MVT::i64, VecV);
2323 return DAG.getNode(HexagonISD::D2P, dl, ResTy, T1);
2373 SDValue ValR = DAG.getNode(HexagonISD::P2D, dl, MVT::i64, ValV);
2391 SDValue VecR = DAG.getNode(HexagonISD::P2D, dl, MVT::i64, VecV);
2394 return DAG.getNode(HexagonISD::D2P, dl, VecTy, Ins);
2428 return DAG.getNode(ISD::BITCAST, dl, VecTy, InsV);
2549 SDValue W = DAG.getNode(HexagonISD::P2D, dl, MVT::i64, P);
2580 return DAG.getNode(HexagonISD::D2P, dl, VecTy, WW);
2819 return DAG.getNode(HexagonISD::EH_RETURN, dl, MVT::Other, Chain);
2969 return DAG.getNode(HexagonISD::AT_PCREL, SDLoc(Table), VT, T);
lib/Target/Hexagon/HexagonISelLoweringHVX.cpp 387 return DAG.getNode(HexagonISD::VSPLATW, dl, VecTy, SplatV);
510 SDValue T = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, PredV);
528 SDValue M = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, Q);
548 : DAG.getNode(HexagonISD::P2D, dl, MVT::i64, PredV);
653 return DAG.getNode(HexagonISD::V2Q, dl, VecTy, ByteVec);
688 SDValue ByteVec = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, VecV);
749 SDValue ByteVec = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, VecV);
754 ValV = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::i32, ValV);
757 return DAG.getNode(HexagonISD::V2Q, dl, ty(VecV), InsV);
811 SDValue ByteVec = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, VecV);
833 return DAG.getNode(HexagonISD::V2Q, dl, ResTy, ShuffV);
930 SingleV = DAG.getNode(HexagonISD::VINSERTW0, dl, SingleTy, V);
974 SDValue ByteVec = DAG.getNode(HexagonISD::Q2V, dl, ByteTy, VecV);
998 return DAG.getNode(HexagonISD::V2Q, dl, VecTy, ByteVec);
1009 return DAG.getNode(HexagonISD::Q2V, dl, ResTy, VecV);
1012 SDValue True = DAG.getNode(HexagonISD::VSPLAT, dl, ResTy,
1130 return DAG.getNode(HexagonISD::V2Q, dl, VecTy, Res);
1208 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(Op), ResTy, InpV);
1250 SDValue Vec1 = DAG.getNode(HexagonISD::VSPLATW, dl, ResTy,
1252 SDValue VecW = DAG.getNode(HexagonISD::VSPLATW, dl, ResTy,
1254 SDValue VecN1 = DAG.getNode(HexagonISD::VSPLATW, dl, ResTy,
1263 {VecW, DAG.getNode(ISD::CTLZ, dl, ResTy, A)});
1430 return DAG.getNode(ISD::ZERO_EXTEND_VECTOR_INREG, SDLoc(Op), ty(Op),
lib/Target/Lanai/LanaiISelLowering.cpp 478 ArgValue = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), ArgValue);
667 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Arg);
670 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Arg);
673 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Arg);
1042 SDValue ArgAdjust = DAG.getNode(LanaiISD::ADJDYNALLOC, DL, MVT::i32, Sub);
1142 DAG.getNode(LanaiISD::SMALL, DL, MVT::i32, Small));
1151 Hi = DAG.getNode(LanaiISD::HI, DL, MVT::i32, Hi);
1152 Lo = DAG.getNode(LanaiISD::LO, DL, MVT::i32, Lo);
1176 DAG.getNode(LanaiISD::SMALL, DL, MVT::i32, Small));
1186 Hi = DAG.getNode(LanaiISD::HI, DL, MVT::i32, Hi);
1187 Lo = DAG.getNode(LanaiISD::LO, DL, MVT::i32, Lo);
1202 Hi = DAG.getNode(LanaiISD::HI, DL, MVT::i32, Hi);
1203 Lo = DAG.getNode(LanaiISD::LO, DL, MVT::i32, Lo);
1219 DAG.getNode(LanaiISD::SMALL, DL, MVT::i32, Small));
1228 Hi = DAG.getNode(LanaiISD::HI, DL, MVT::i32, Hi);
1229 Lo = DAG.getNode(LanaiISD::LO, DL, MVT::i32, Lo);
lib/Target/MSP430/MSP430ISelLowering.cpp 653 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
821 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
824 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
827 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
967 Victim = DAG.getNode(ISD::BSWAP, dl, VT, Victim);
972 Victim = DAG.getNode(ISD::BSWAP, dl, VT, Victim);
985 Victim = DAG.getNode(MSP430ISD::RRCL, dl, VT, Victim);
990 Victim = DAG.getNode((Opc == ISD::SHL ? MSP430ISD::RLA : MSP430ISD::RRA),
1004 return DAG.getNode(MSP430ISD::Wrapper, SDLoc(Op), PtrVT, Result);
1014 return DAG.getNode(MSP430ISD::Wrapper, dl, PtrVT, Result);
1024 return DAG.getNode(MSP430ISD::Wrapper, dl, PtrVT, Result);
1231 DAG.getNode(ISD::ANY_EXTEND, dl, VT, Val),
1317 return DAG.getNode(MSP430ISD::Wrapper, SDLoc(JT), PtrVT, Result);
lib/Target/Mips/MipsISelLowering.cpp 1043 CurDAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Mult->getOperand(0)),
1044 CurDAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Mult->getOperand(1)), ACCIn};
1048 SDValue ResLo = CurDAG.getNode(MipsISD::MFLO, DL, MVT::i32, MAdd);
1049 SDValue ResHi = CurDAG.getNode(MipsISD::MFHI, DL, MVT::i32, MAdd);
2061 SDValue Hi = DAG.getNode(MipsISD::TlsHi, DL, PtrVT, TGAHi);
2064 SDValue Lo = DAG.getNode(MipsISD::Lo, DL, PtrVT, TGALo);
2085 SDValue Hi = DAG.getNode(MipsISD::TlsHi, DL, PtrVT, TGAHi);
2086 SDValue Lo = DAG.getNode(MipsISD::Lo, DL, PtrVT, TGALo);
2215 DAG.getNode(ISD::BITCAST, DL, MVT::i32, Op.getOperand(0)) :
2219 DAG.getNode(ISD::BITCAST, DL, MVT::i32, Op.getOperand(1)) :
2242 return DAG.getNode(ISD::BITCAST, DL, Op.getOperand(0).getValueType(), Res);
2259 SDValue X = DAG.getNode(ISD::BITCAST, DL, TyX, Op.getOperand(0));
2260 SDValue Y = DAG.getNode(ISD::BITCAST, DL, TyY, Op.getOperand(1));
2269 E = DAG.getNode(ISD::ZERO_EXTEND, DL, TyX, E);
2271 E = DAG.getNode(ISD::TRUNCATE, DL, TyX, E);
2276 return DAG.getNode(ISD::BITCAST, DL, Op.getOperand(0).getValueType(), I);
2290 SrlY = DAG.getNode(ISD::ZERO_EXTEND, DL, TyX, SrlY);
2292 SrlY = DAG.getNode(ISD::TRUNCATE, DL, TyX, SrlY);
2297 return DAG.getNode(ISD::BITCAST, DL, Op.getOperand(0).getValueType(), Or);
2316 ? DAG.getNode(ISD::BITCAST, DL, MVT::i32, Op.getOperand(0))
2333 return DAG.getNode(ISD::BITCAST, DL, MVT::f32, Res);
2351 SDValue X = DAG.getNode(ISD::BITCAST, DL, MVT::i64, Op.getOperand(0));
2363 return DAG.getNode(ISD::BITCAST, DL, MVT::f64, Res);
2671 SDValue Tr = DAG.getNode(MipsISD::TruncIntFP, SDLoc(Val), FPTy,
2708 SDValue Trunc = DAG.getNode(MipsISD::TruncIntFP, SDLoc(Op), FPTy,
2710 return DAG.getNode(ISD::BITCAST, SDLoc(Op), Op.getValueType(), Trunc);
3160 Arg = DAG.getNode(ISD::BITCAST, DL, LocVT, Arg);
3177 Arg = DAG.getNode(ISD::BITCAST, DL, LocVT, Arg);
3183 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, LocVT, Arg);
3189 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, LocVT, Arg);
3195 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, LocVT, Arg);
3378 Val = DAG.getNode(ISD::BITCAST, DL, VA.getValVT(), Val);
3382 Val = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Val);
3388 Val = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Val);
3394 Val = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Val);
3439 Val = DAG.getNode(ISD::TRUNCATE, DL, ValVT, Val);
3444 Val = DAG.getNode(ISD::TRUNCATE, DL, ValVT, Val);
3449 Val = DAG.getNode(ISD::TRUNCATE, DL, ValVT, Val);
3452 Val = DAG.getNode(ISD::BITCAST, DL, ValVT, Val);
3539 ArgValue = DAG.getNode(ISD::BITCAST, DL, ValVT, ArgValue);
3681 Val = DAG.getNode(ISD::BITCAST, DL, VA.getLocVT(), Val);
3687 Val = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Val);
3693 Val = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Val);
3699 Val = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Val);
lib/Target/Mips/MipsISelLowering.h 401 SDValue Lo = DAG.getNode(MipsISD::Lo, DL, Ty,
428 SDValue Hi = DAG.getNode(MipsISD::GotHi, DL, Ty,
448 DAG.getNode(MipsISD::Hi, DL, Ty, Hi),
449 DAG.getNode(MipsISD::Lo, DL, Ty, Lo));
466 DAG.getNode(MipsISD::Highest, DL, Ty,
471 DAG.getNode(MipsISD::Higher, DL, Ty, Higher));
475 DAG.getNode(MipsISD::Hi, DL, Ty, Hi));
479 DAG.getNode(MipsISD::Lo, DL, Ty, Lo));
lib/Target/Mips/MipsSEISelLowering.cpp 418 SDValue Tmp = DAG.getNode(MipsISD::MTC1_D64, DL, MVT::f64, Op->getOperand(0));
1275 Lo = DAG.getNode(MipsISD::MFLO, DL, Ty, Mult);
1277 Hi = DAG.getNode(MipsISD::MFHI, DL, Ty, Mult);
1295 SDValue Lo = DAG.getNode(MipsISD::MFLO, DL, MVT::i32, Op);
1296 SDValue Hi = DAG.getNode(MipsISD::MFHI, DL, MVT::i32, Op);
1411 Result = DAG.getNode(ISD::BITCAST, DL, ResVecTy,
1438 SplatValueA = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, SplatValue);
1441 SplatValueB = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, SplatValueB);
1458 Result = DAG.getNode(ISD::BITCAST, DL, VecTy, Result);
1483 Exp2Imm = DAG.getNode(
1496 Imm = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, Imm);
1672 return DAG.getNode(MipsISD::VALL_NONZERO, DL, Op->getValueType(0),
1675 return DAG.getNode(MipsISD::VANY_NONZERO, DL, Op->getValueType(0),
1708 return DAG.getNode(MipsISD::VALL_ZERO, DL, Op->getValueType(0),
1711 return DAG.getNode(MipsISD::VANY_ZERO, DL, Op->getValueType(0),
1871 return DAG.getNode(ISD::UINT_TO_FP, DL, Op->getValueType(0),
1875 return DAG.getNode(ISD::SINT_TO_FP, DL, Op->getValueType(0),
1895 DAG.getNode(ISD::FEXP2, SDLoc(Op), ResTy, Op->getOperand(2)));
1899 return DAG.getNode(ISD::FLOG2, DL, Op->getValueType(0), Op->getOperand(1));
1917 return DAG.getNode(ISD::FRINT, DL, Op->getValueType(0), Op->getOperand(1));
1920 return DAG.getNode(ISD::FSQRT, DL, Op->getValueType(0), Op->getOperand(1));
1928 return DAG.getNode(ISD::FP_TO_UINT, DL, Op->getValueType(0),
1932 return DAG.getNode(ISD::FP_TO_SINT, DL, Op->getValueType(0),
2084 return DAG.getNode(ISD::CTLZ, DL, Op->getValueType(0), Op->getOperand(1));
2118 return DAG.getNode(ISD::CTPOP, DL, Op->getValueType(0), Op->getOperand(1));
2306 Offset = DAG.getNode(ISD::SIGN_EXTEND, DL, PtrTy, Offset);
2380 Offset = DAG.getNode(ISD::SIGN_EXTEND, DL, PtrTy, Offset);
2509 Result = DAG.getNode(ISD::BITCAST, SDLoc(Node), ResTy, Result);
lib/Target/NVPTX/NVPTXISelLowering.cpp 1255 return DAG.getNode(NVPTXISD::Wrapper, dl, PtrVT, Op);
1522 StVal = DAG.getNode(Outs[OIdx].Flags.isSExt() ? ISD::SIGN_EXTEND
1528 StVal = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i16, StVal);
1613 theVal = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i16, theVal);
1873 Ret = DAG.getNode(ISD::TRUNCATE, dl, ProxyRegTruncates[i].getValue(), Ret);
1931 return DAG.getNode(ISD::BITCAST, SDLoc(Op), MVT::v2f16, Const);
2102 SDValue AbsA = DAG.getNode(ISD::FABS, SL, VT, A);
2105 SDValue Bitcast = DAG.getNode(ISD::BITCAST, SL, MVT::i32, A);
2114 DAG.getNode(ISD::BITCAST, SL, VT, PointFiveWithSignRaw);
2116 SDValue RoundedA = DAG.getNode(ISD::FTRUNC, SL, VT, AdjustedA);
2128 SDValue RoundedAForSmallA = DAG.getNode(ISD::FTRUNC, SL, VT, A);
2143 SDValue AbsA = DAG.getNode(ISD::FABS, SL, VT, A);
2148 SDValue RoundedA = DAG.getNode(ISD::FTRUNC, SL, VT, AdjustedA);
2160 DAG.getNode(ISD::FTRUNC, SL, VT, A);
2216 Op1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, Op1);
2217 Op2 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, Op2);
2219 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, Select);
2258 SDValue result = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, newLD);
2387 ExtVal = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i16, ExtVal);
2418 Tmp3 = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i16, Tmp3);
2603 Elt = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, Elt);
2606 Elt = DAG.getNode(ISD::BITCAST, dl, MVT::v2f16, Elt);
2613 Elt = DAG.getNode(Extend, dl, Ins[InsIdx].VT, Elt);
2639 SDValue p = DAG.getNode(NVPTXISD::MoveParam, dl, ObjectVT, Arg);
2699 RetVal = DAG.getNode(Outs[i].Flags.isSExt() ? ISD::SIGN_EXTEND
2705 RetVal = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i16, RetVal);
2741 return DAG.getNode(NVPTXISD::RET_FLAG, dl, MVT::Other, Chain);
4527 Val = DCI.DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N),
4694 DCI.DAG.getNode(ISD::TRUNCATE, DL, DemotedVT, LHS);
4696 DCI.DAG.getNode(ISD::TRUNCATE, DL, DemotedVT, RHS);
4896 Res = DAG.getNode(ISD::TRUNCATE, DL, ResVT.getVectorElementType(), Res);
5009 DAG.getNode(ISD::TRUNCATE, DL, ResVT.getVectorElementType(), Res);
5039 Results.push_back(DAG.getNode(ISD::TRUNCATE, DL, MVT::i8,
lib/Target/PowerPC/PPCISelLowering.cpp 2986 return DAG.getNode(ISD::BITCAST, dl, MVT::v2i64,
2988 DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op.getOperand(0)),
2989 DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Op.getOperand(1)),
3547 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, ArgValue);
3687 return DAG.getNode(ISD::TRUNCATE, dl, ObjectVT, ArgVal);
3966 ArgVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, ArgVal);
3969 ArgVal = DAG.getNode(ISD::BITCAST, dl, ObjectVT, ArgVal);
4303 ArgVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, ArgVal);
5197 Val = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val);
5202 Val = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val);
5207 Val = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val);
5576 Arg = DAG.getNode(Flags.isSExt() ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND,
5910 Arg = DAG.getNode(ExtOp, dl, MVT::i64, Arg);
6090 ArgVal = DAG.getNode(ISD::BITCAST, dl, MVT::i64, Arg);
6094 ArgVal = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
6095 ArgVal = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i64, ArgVal);
6101 Lo = DAG.getNode(ISD::BITCAST, dl, MVT::i32, OutVals[i - 1]);
6102 Hi = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
6109 ArgVal = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
6110 ArgVal = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i64, ArgVal);
6473 Arg = DAG.getNode(ExtOp, dl, MVT::i64, Arg);
6537 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, PtrVT, Arg);
6843 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
6846 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
6914 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
6917 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
6920 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
7125 SDValue Result = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, NewLD);
7148 Value = DAG.getNode(ISD::ZERO_EXTEND, dl, getPointerTy(DAG.getDataLayout()),
7159 return DAG.getNode(PPCISD::ANDIo_1_GT_BIT, DL, MVT::i1,
7214 SDValue Conv = DAG.getNode(ISD::BITCAST, DL, WideVT, WideSrc);
7275 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
7278 Sel1 = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Sel1);
7280 DAG.getNode(ISD::FNEG, dl, MVT::f64, LHS), Sel1, FV);
7288 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
7297 LHS = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, LHS);
7299 DAG.getNode(ISD::FNEG, dl, MVT::f64, LHS), TV, FV);
7311 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
7314 Sel1 = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Sel1);
7316 DAG.getNode(ISD::FNEG, dl, MVT::f64, Cmp), Sel1, FV);
7321 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
7327 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
7333 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
7339 Cmp = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Cmp);
7351 Src = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Src);
7357 Tmp = DAG.getNode(
7366 Tmp = DAG.getNode(Op.getOpcode()==ISD::FP_TO_SINT ? PPCISD::FCTIDZ :
7415 Src = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Src);
7421 Tmp = DAG.getNode(
7426 Tmp = DAG.getNode(PPCISD::MFVSR, dl, MVT::i32, Tmp);
7431 Tmp = DAG.getNode(Op.getOpcode()==ISD::FP_TO_SINT ? PPCISD::FCTIDZ :
7434 Tmp = DAG.getNode(PPCISD::MFVSR, dl, MVT::i64, Tmp);
7463 return DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, Res);
7474 True = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, True);
7477 SDValue False = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32,
7618 FP = DAG.getNode(Signed ? PPCISD::MTVSRA : PPCISD::MTVSRZ,
7620 FP = DAG.getNode(ConvOp, dl, SinglePrec ? MVT::f32 : MVT::f64, FP);
7623 FP = DAG.getNode(PPCISD::MTVSRA, dl, MVT::f64, Src);
7624 FP = DAG.getNode(ConvOp, dl, SinglePrec ? MVT::f32 : MVT::f64, FP);
7692 Extend = DAG.getNode(ExtendOp, dl, IntermediateVT, Arrange);
7694 return DAG.getNode(Opc, dl, Op.getValueType(), Extend);
7719 Value = DAG.getNode(PPCISD::QBFLT, dl, MVT::v4f64, Value);
7871 Bits = DAG.getNode(ISD::BITCAST, dl, MVT::f64, SINT);
7873 SDValue FP = DAG.getNode(FCFOp, dl, FCFTy, Bits);
7932 SDValue Ext64 = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::i64,
7947 SDValue FP = DAG.getNode(FCFOp, dl, FCFTy, Ld);
8013 return DAG.getNode((VT.getSizeInBits() < 16 ?
8164 LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, LHS);
8165 RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, RHS);
8171 return DAG.getNode(ISD::BITCAST, dl, VT, T);
8333 StoreValue = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, StoreValue);
8427 Op = DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Z);
8484 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), RetVal);
8500 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
8526 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
8537 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
8548 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
8560 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Res);
8657 OpLHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OpLHS);
8658 OpRHS = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OpRHS);
8660 return DAG.getNode(ISD::BITCAST, dl, VT, T);
8860 SDValue Conv1 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
8865 SDValue Conv2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, Shl);
8868 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Ins);
8870 SDValue Conv2 = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V2);
8873 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Ins);
8935 SDValue Conv1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V1);
8936 SDValue Conv2 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V2);
8942 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Ins);
8946 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Ins);
8962 SDValue Conv1 = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V1);
8964 DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V2.isUndef() ? V1 : V2);
8968 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Shl);
8975 SDValue Conv1 = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1);
8977 DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V2.isUndef() ? V1 : V2);
8981 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, PermDI);
8986 SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, V1);
8987 SDValue ReveHWord = DAG.getNode(PPCISD::XXREVERSE, dl, MVT::v8i16, Conv);
8988 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, ReveHWord);
8990 SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V1);
8991 SDValue ReveWord = DAG.getNode(PPCISD::XXREVERSE, dl, MVT::v4i32, Conv);
8992 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, ReveWord);
8994 SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, V1);
8995 SDValue ReveDWord = DAG.getNode(PPCISD::XXREVERSE, dl, MVT::v2i64, Conv);
8996 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, ReveDWord);
8998 SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v1i128, V1);
8999 SDValue ReveQWord = DAG.getNode(PPCISD::XXREVERSE, dl, MVT::v1i128, Conv);
9000 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, ReveQWord);
9008 SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, V1);
9011 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Splat);
9016 SDValue Conv = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, V1);
9017 SDValue Swap = DAG.getNode(PPCISD::SWAP_NO_CHAIN, dl, MVT::v2f64, Conv);
9018 return DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, Swap);
9053 SDValue V3 = DAG.getNode(PPCISD::QVGPCI, dl, MVT::v4f64,
9468 return DAG.getNode(ISD::BITCAST, dl, Op.getValueType(), Tmp);
9530 DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64,
9560 Op = DAG.getNode(PPCISD::XXREVERSE, dl, MVT::v2i64, Op);
9638 SDValue Mtvsrz = DAG.getNode(PPCISD::MTVSRZ, dl, VT, V2);
9667 Value = DAG.getNode(PPCISD::QBFLT, dl, MVT::v4f64, Value);
9707 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, IntVal);
9867 Value = DAG.getNode(PPCISD::QBFLT, dl, MVT::v4f64, Value);
9937 LHS = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, LHS);
9938 RHS = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, RHS);
9939 RHSSwap = DAG.getNode(ISD::BITCAST, dl, MVT::v8i16, RHSSwap);
9966 EvenParts = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, EvenParts);
9971 OddParts = DAG.getNode(ISD::BITCAST, dl, MVT::v16i8, OddParts);
10215 Results.push_back(DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, NewInt));
11662 return DAG.getNode(PPCISD::FRSQRTE, SDLoc(Operand), VT, Operand);
11679 return DAG.getNode(PPCISD::FRE, SDLoc(Operand), VT, Operand);
11970 return DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, Final);
12250 RepValue = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, RepValue);
12281 Ops[C+i] = DAG.getNode(ISD::TRUNCATE, dl, MVT::i1, Ops[C+i]);
12546 Ops[0] = DAG.getNode(ISD::TRUNCATE, dl, SI0->second, Ops[0]);
12549 Ops[1] = DAG.getNode(ISD::TRUNCATE, dl, SI1->second, Ops[1]);
12701 return DAG.getNode(Opcode, dl, TargetVT, BV);
12827 SDValue BV = DAG.getNode(PPCISD::SExtVElems, dl, Ty, Shuffle);
13057 return DAG.getNode(ConvOp, dl, DstDouble ? MVT::f64 : MVT::f32, Ext);
13059 return DAG.getNode(ConvOp, dl, DstDouble ? MVT::f64 : MVT::f32, Ld);
13091 Src = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Src);
13102 SDValue Tmp = DAG.getNode(FCTOp, dl, MVT::f64, Src);
13103 SDValue FP = DAG.getNode(FCFOp, dl, FCFTy, Tmp);
13175 SDValue N = DAG.getNode(ISD::BITCAST, dl, VecTy, Swap);
13235 Src = DAG.getNode(ISD::BITCAST, dl, MVT::v2f64, Src);
13281 Val = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f64, Val);
13290 Val = DAG.getNode(ConvOpcode,
13449 BSwapOp = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, BSwapOp);
13459 BSwapOp = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, BSwapOp);
13753 DAG.getNode(ISD::BITCAST, dl, VT, Perm) :
13836 return DAG.getNode(ISD::ABS, dl, V2.getValueType(), V2);
13842 return DAG.getNode(ISD::ABS, dl, V1.getValueType(), V1);
13848 return DAG.getNode(ISD::ABS, dl, V1.getValueType(), V1);
13905 ResVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, BSLoad);
lib/Target/RISCV/RISCVISelLowering.cpp 402 SDValue NewOp0 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op0);
403 SDValue FPConv = DAG.getNode(RISCVISD::FMV_W_X_RV64, DL, MVT::f32, NewOp0);
841 SDValue NewOp0 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(0));
842 SDValue NewOp1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(1));
845 return DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, NewRes);
852 SDValue NewOp0 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(0));
853 SDValue NewOp1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, N->getOperand(1));
857 return DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, NewRes);
916 DAG.getNode(RISCVISD::FMV_X_ANYEXTW_RV64, DL, MVT::i64, Op0);
917 Results.push_back(DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, FPConv));
993 DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op0.getOperand(0));
1004 SDValue NewFMV = DAG.getNode(RISCVISD::FMV_X_ANYEXTW_RV64, DL, MVT::i64,
1676 Val = DAG.getNode(RISCVISD::FMV_W_X_RV64, DL, MVT::f32, Val);
1679 Val = DAG.getNode(ISD::BITCAST, DL, VA.getValVT(), Val);
1731 Val = DAG.getNode(RISCVISD::FMV_X_ANYEXTW_RV64, DL, MVT::i64, Val);
1734 Val = DAG.getNode(ISD::BITCAST, DL, LocVT, Val);
lib/Target/Sparc/SparcISelLowering.cpp 325 OutVal = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), OutVal);
328 OutVal = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), OutVal);
331 OutVal = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), OutVal);
346 SDValue NV = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, OutVals[i+1]);
444 WholeValue = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), WholeValue);
452 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::f32, Arg);
456 Arg = DAG.getNode(ISD::TRUNCATE, dl, VA.getLocVT(), Arg);
500 WholeValue = DAG.getNode(ISD::BITCAST, dl, VA.getValVT(), WholeValue);
626 Arg = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Arg);
806 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
809 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
812 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
815 Arg = DAG.getNode(ISD::BITCAST, dl, VA.getLocVT(), Arg);
858 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::v2i32, Arg);
907 Arg = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Arg);
1148 Arg = DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Arg);
1151 Arg = DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Arg);
1154 Arg = DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Arg);
1161 Arg = DAG.getNode(ISD::BITCAST, DL, VA.getLocVT(), Arg);
1202 SDValue NV = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64,
1342 RV = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), RV);
1934 SDValue Hi = DAG.getNode(SPISD::Hi, DL, VT, withTargetFlags(Op, HiTF, DAG));
1935 SDValue Lo = DAG.getNode(SPISD::Lo, DL, VT, withTargetFlags(Op, LoTF, DAG));
1953 Idx = DAG.getNode(SPISD::Lo, DL, Op.getValueType(),
1985 L44 = DAG.getNode(SPISD::Lo, DL, VT, L44);
2076 SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT,
2078 SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT,
2110 SDValue Hi = DAG.getNode(SPISD::Hi, DL, PtrVT,
2112 SDValue Lo = DAG.getNode(SPISD::Lo, DL, PtrVT,
2352 Op = DAG.getNode(SPISD::FTOI, dl, MVT::f32, Op.getOperand(0));
2354 Op = DAG.getNode(SPISD::FTOX, dl, MVT::f64, Op.getOperand(0));
2356 return DAG.getNode(ISD::BITCAST, dl, VT, Op);
2382 SDValue Tmp = DAG.getNode(ISD::BITCAST, dl, floatVT, Op.getOperand(0));
2384 return DAG.getNode(opcode, dl, Op.getValueType(), Tmp);
2609 SDValue Chain = DAG.getNode(SPISD::FLUSHW,
2711 Lo32 = DAG.getNode(opcode, dl, MVT::f32, Lo32);
2713 Hi32 = DAG.getNode(opcode, dl, MVT::f32, Hi32);
2828 SDValue Val = DAG.getNode(ISD::BITCAST, dl, MVT::v2i32, St->getValue());
2862 Lo64 = DAG.getNode(Op.getOpcode(), dl, MVT::f64, Lo64);
2867 Hi64 = DAG.getNode(Op.getOpcode(), dl, MVT::f64, Hi64);
2888 SDValue Src1Lo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src1);
2891 Src1Hi = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src1Hi);
2894 SDValue Src2Lo = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src2);
2897 Src2Hi = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src2Hi);
2920 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Lo);
2921 Hi = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Hi);
3400 SDValue Res = DAG.getNode(ISD::BITCAST, dl, MVT::i64, LoadRes);
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp 639 SDValue Trunc = CurDAG->getNode(ISD::TRUNCATE, DL, VT, Base);
1160 SDValue BitCast = CurDAG->getNode(ISD::BITCAST, DL, VT, Op);
1843 SDValue Result = CurDAG->getNode(SystemZISD::IPM, DL, MVT::i32, CCReg);
1860 Result = CurDAG->getNode(ISD::ANY_EXTEND, DL, VT, Result);
lib/Target/SystemZ/SystemZISelLowering.cpp 1253 Value = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Value);
1260 Value = DAG.getNode(ISD::BITCAST, DL, VA.getValVT(), Value);
1273 return DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Value);
1275 return DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Value);
1277 return DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Value);
1283 Value = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Value);
1562 Callee = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Callee);
1565 Callee = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Callee);
1676 return DAG.getNode(SystemZISD::RET_FLAG, DL, MVT::Other, Chain);
2568 Op0 = DAG.getNode(Extend, DL, MVT::i64, Op0);
2569 Op1 = DAG.getNode(Extend, DL, MVT::i64, Op1);
2573 Hi = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Hi);
2574 Lo = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Mul);
2653 return DAG.getNode(SystemZISD::VEXTEND, DL, MVT::v2f64, Op);
2781 Op = DAG.getNode(SystemZISD::IABS, DL, Op.getValueType(), Op);
2834 Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
2845 Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
2913 TPHi = DAG.getNode(ISD::ANY_EXTEND, DL, PtrVT, TPHi);
2917 TPLo = DAG.getNode(ISD::ZERO_EXTEND, DL, PtrVT, TPLo);
2990 Offset = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Offset);
3022 Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
3033 return DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
3050 return DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result);
3131 In64 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, In);
3135 SDValue Out64 = DAG.getNode(ISD::BITCAST, DL, MVT::f64, In64);
3143 SDValue Out64 = DAG.getNode(ISD::BITCAST, DL, MVT::i64, In64);
3149 return DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Shift);
3356 Op0 = DAG.getNode(ISD::SIGN_EXTEND, DL, MVT::i64, Op0);
3358 Op1 = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Op1);
3430 SDValue Low32 = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, LowOp);
3475 SetCC = DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, SetCC);
3541 SetCC = DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, SetCC);
3554 Op = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Op);
3555 Op = DAG.getNode(SystemZISD::POPCNT, DL, MVT::v16i8, Op);
3560 Op = DAG.getNode(ISD::BITCAST, DL, VT, Op);
3598 Op = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op);
3599 Op = DAG.getNode(SystemZISD::POPCNT, DL, MVT::i64, Op);
3600 Op = DAG.getNode(ISD::TRUNCATE, DL, VT, Op);
3638 return DAG.getNode(SystemZISD::MEMBARRIER, DL, MVT::Other, Op.getOperand(0));
3701 BitShift = DAG.getNode(ISD::TRUNCATE, DL, WideVT, BitShift);
3817 BitShift = DAG.getNode(ISD::TRUNCATE, DL, WideVT, BitShift);
3913 SDValue IPM = DAG.getNode(SystemZISD::IPM, DL, MVT::i32, CCReg);
3962 return DAG.getNode(SystemZISD::UNPACK_HIGH, SDLoc(Op), Op.getValueType(),
3968 return DAG.getNode(SystemZISD::UNPACKL_HIGH, SDLoc(Op), Op.getValueType(),
3974 return DAG.getNode(SystemZISD::UNPACK_LOW, SDLoc(Op), Op.getValueType(),
3980 return DAG.getNode(SystemZISD::UNPACKL_LOW, SDLoc(Op), Op.getValueType(),
4242 Op0 = DAG.getNode(ISD::BITCAST, DL, InVT, Op0);
4243 Op1 = DAG.getNode(ISD::BITCAST, DL, InVT, Op1);
4265 Ops[I] = DAG.getNode(ISD::BITCAST, DL, MVT::v16i8, Ops[I]);
4454 return DAG.getNode(ISD::BITCAST, DL, VT, Op);
4478 return DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VT, Value);
4488 return DAG.getNode(SystemZISD::REPLICATE, DL, VT, Op1);
4491 return DAG.getNode(SystemZISD::REPLICATE, DL, VT, Op0);
4506 Op0 = Op1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op1);
4508 Op0 = Op1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op0);
4510 Op0 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op0);
4511 Op1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Op1);
4610 return DAG.getNode(SystemZISD::REPLICATE, DL, VT, Single);
4646 Op01 = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Op01);
4647 Op23 = DAG.getNode(ISD::BITCAST, DL, MVT::v2i64, Op23);
4650 return DAG.getNode(ISD::BITCAST, DL, VT, Op);
4695 Result = DAG.getNode(SystemZISD::REPLICATE, DL, VT, ReplicatedVal);
4705 Result = DAG.getNode(ISD::BITCAST, DL, VT,
4767 return DAG.getNode(SystemZISD::REPLICATE, DL, VT, Op0.getOperand(Index));
4820 DAG.getNode(ISD::BITCAST, DL, IntVecVT, Op0),
4821 DAG.getNode(ISD::BITCAST, DL, IntVT, Op1), Op2);
4822 return DAG.getNode(ISD::BITCAST, DL, VT, Res);
4847 DAG.getNode(ISD::BITCAST, DL, IntVecVT, Op0), Op1);
4848 return DAG.getNode(ISD::BITCAST, DL, VT, Res);
4863 PackedOp = DAG.getNode(UnpackHigh, SDLoc(PackedOp), OutVT, PackedOp);
4897 SDValue Shift = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Splat);
4914 SDValue Shift = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32,
5321 Op = DAG.getNode(ISD::BITCAST, DL, VT, Op);
5325 Op = DAG.getNode(ISD::TRUNCATE, DL, VT, Op);
5328 Op = DAG.getNode(ISD::BITCAST, DL, ResVT, Op);
5361 Op = DAG.getNode(ISD::BITCAST, DL, VecVT, Op);
5425 DAG.getNode(ISD::TRUNCATE, DL, N0.getValueType(), NewSelect);
5472 SDValue Ext = DAG.getNode(ISD::ANY_EXTEND, SDLoc(Inner), VT,
5508 Op1 = DAG.getNode(ISD::BITCAST, SDLoc(N), InVT, Op1);
5511 SDValue Op = DAG.getNode(Opcode, SDLoc(N), OutVT, Op1);
5513 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
5614 BSwapOp = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), MVT::i32, BSwapOp);
5707 Op = DAG.getNode(ISD::BSWAP, SDLoc(N), EltVT, Op);
5710 Op = DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0), Op);
5730 return DAG.getNode(SystemZISD::REPLICATE, SDLoc(N), N->getValueType(0),
5767 SDValue VRound = DAG.getNode(SystemZISD::VROUND, SDLoc(N),
5818 SDValue VExtend = DAG.getNode(SystemZISD::VEXTEND, SDLoc(N),
5863 ResVal = DAG.getNode(ISD::TRUNCATE, SDLoc(N), MVT::i16, BSLoad);
5901 Vec = DAG.getNode(ISD::BITCAST, SDLoc(N), VecVT, Vec);
5905 Elt = DAG.getNode(ISD::BITCAST, SDLoc(N), EltVT, Elt);
5908 Vec = DAG.getNode(ISD::BSWAP, SDLoc(N), VecVT, Vec);
5910 Elt = DAG.getNode(ISD::BSWAP, SDLoc(N), EltVT, Elt);
5929 Op0 = DAG.getNode(ISD::BITCAST, SDLoc(N), VecVT, Op0);
5933 Op1 = DAG.getNode(ISD::BITCAST, SDLoc(N), VecVT, Op1);
5936 Op0 = DAG.getNode(ISD::BSWAP, SDLoc(N), VecVT, Op0);
5938 Op1 = DAG.getNode(ISD::BSWAP, SDLoc(N), VecVT, Op1);
lib/Target/SystemZ/SystemZSelectionDAGInfo.cpp 171 SDValue IPM = DAG.getNode(SystemZISD::IPM, DL, MVT::i32, CCReg);
lib/Target/WebAssembly/WebAssemblyISelLowering.cpp 797 Callee = DAG.getNode(WebAssemblyISD::Wrapper, DL,
914 InVals.push_back(In.Used ? DAG.getNode(WebAssemblyISD::ARGUMENT, DL, In.VT,
932 DAG.getNode(WebAssemblyISD::ARGUMENT, DL, PtrVT,
1115 DAG.getNode(WebAssemblyISD::Wrapper, DL, PtrVT,
1118 SDValue SymAddr = DAG.getNode(
1129 return DAG.getNode(WebAssemblyISD::Wrapper, DL, VT,
1142 return DAG.getNode(WebAssemblyISD::Wrapper, DL, VT,
1225 return DAG.getNode(WebAssemblyISD::Wrapper, DL, VT,
1237 SDValue SymNode = DAG.getNode(WebAssemblyISD::Wrapper, DL, PtrVT,
1428 Result = DAG.getNode(WebAssemblyISD::LOAD_SPLAT, DL, VecT, SplatValue);
lib/Target/X86/X86ISelDAGToDAG.cpp 820 SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
863 SDValue Res = CurDAG->getNode(NewOpc, SDLoc(N), N->getValueType(0),
909 SDValue Op0 = CurDAG->getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT,
911 SDValue Op1 = CurDAG->getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT,
917 Op0 = CurDAG->getNode(ISD::BITCAST, dl, IntVT, Op0);
918 Op1 = CurDAG->getNode(ISD::BITCAST, dl, IntVT, Op1);
928 Res = CurDAG->getNode(ISD::BITCAST, dl, VecVT, Res);
1650 SDValue NewX = DAG.getNode(ISD::ANY_EXTEND, DL, VT, X);
1759 SDValue NewX = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(X), VT, X);
2157 SDValue Zext = CurDAG->getNode(ISD::ZERO_EXTEND, DL, VT, Shl.getOperand(0));
3354 NBits = CurDAG->getNode(ISD::TRUNCATE, DL, MVT::i8, NBits);
3374 NBits = CurDAG->getNode(ISD::ANY_EXTEND, DL, NVT, NBits);
3421 ShiftAmt = CurDAG->getNode(ISD::ZERO_EXTEND, DL, MVT::i32, ShiftAmt);
3431 Control = CurDAG->getNode(ISD::ANY_EXTEND, DL, XVT, Control);
3441 Extract = CurDAG->getNode(ISD::TRUNCATE, DL, NVT, Extract);
3690 NewShiftAmt = CurDAG->getNode(ISD::TRUNCATE, DL, MVT::i8, NewShiftAmt);
3819 SDValue NewX = CurDAG->getNode(ISD::ANY_EXTEND, dl, NVT, X);
lib/Target/X86/X86ISelLowering.cpp 2424 ValToCopy = DAG.getNode(ISD::ANY_EXTEND, Dl, ValLoc, ValToCopy);
2435 return DAG.getNode(ISD::ANY_EXTEND, Dl, ValLoc, ValArg);
2508 ValToCopy = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), ValToCopy);
2510 ValToCopy = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), ValToCopy);
2515 ValToCopy = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), ValToCopy);
2546 ValToCopy = DAG.getNode(ISD::FP_EXTEND, dl, MVT::f80, ValToCopy);
2558 ValToCopy = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
2790 return DAG.getNode(ISD::SCALAR_TO_VECTOR, Dl, MVT::v1i1, ValReturned);
2812 ValReturned = DAG.getNode(ISD::TRUNCATE, Dl, maskLen, ValReturned);
2895 Val = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val);
3111 ? DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VA.getValVT(), Val)
3112 : DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), Val))
3290 ArgValue = DAG.getNode(X86ISD::MOVDQ2Q, dl, VA.getValVT(), ArgValue);
3298 ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue);
3771 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, RegVT, Arg);
3774 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, RegVT, Arg);
3783 Arg = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, Arg);
3786 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, RegVT, Arg);
4009 Callee = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Callee);
5860 return DAG.getNode(Opcode, DL, VT, In);
7439 V = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, V);
7503 V = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, Elt);
7508 Elt = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, Elt);
7548 SDValue Dup = DAG.getNode(X86ISD::MOVDDUP, DL, MVT::v2f64, NewBV);
8040 SDValue Broadcast = DAG.getNode(Opcode, DL, BroadcastVT, RepeatLoad);
8195 DAG.getNode(X86ISD::VBROADCASTM, dl,
8236 SDValue Brdcst = DAG.getNode(X86ISD::VBROADCAST, dl,
8260 SDValue Brdcst = DAG.getNode(X86ISD::VBROADCAST, dl,
8275 SDValue Brdcst = DAG.getNode(X86ISD::SUBV_BROADCAST, dl, VT, Ld);
8344 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
8353 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
8361 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
8367 return DAG.getNode(X86ISD::VBROADCAST, dl, VT, Ld);
9693 SDValue S2V = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, VarElt);
9708 return DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
9715 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
9723 Item = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, Item);
9725 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, ShufVT, Item);
9737 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
9751 Item = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Item);
9808 return DAG.getBitcast(VT, DAG.getNode(X86ISD::VBROADCAST, dl, BcastVT,
9833 SDValue V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT,
9864 Ops[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
9906 Result = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(0));
9924 Ops[i] = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(i));
10821 return DAG.getNode(X86ISD::VTRUNC, DL, VT, Src);
12214 V = DAG.getNode(X86ISD::VZEXT_MOVL, DL, MVT::v2i64, V);
12297 V2S = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, V2S);
12299 V2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, ExtVT, V2S);
12332 V2 = DAG.getNode(X86ISD::VZEXT_MOVL, DL, ExtVT, V2);
12405 return DAG.getNode(X86ISD::VBROADCAST, DL, VT,
12406 DAG.getNode(ISD::TRUNCATE, DL, EltVT, Scalar));
12637 V = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64,
12671 return DAG.getBitcast(VT, DAG.getNode(Opcode, DL, BroadcastVT, V));
12970 DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64, V1S));
13196 return DAG.getNode(X86ISD::MOVSLDUP, DL, MVT::v4f32, V1);
13198 return DAG.getNode(X86ISD::MOVSHDUP, DL, MVT::v4f32, V1);
15556 V1 = DAG.getNode(X86ISD::VTRUNC, DL, MVT::v16i8, V1);
15557 V2 = DAG.getNode(X86ISD::VTRUNC, DL, MVT::v16i8, V2);
15595 return DAG.getNode(X86ISD::MOVDDUP, DL, MVT::v4f64, V1);
15807 return DAG.getNode(X86ISD::MOVSLDUP, DL, MVT::v8f32, V1);
15809 return DAG.getNode(X86ISD::MOVSHDUP, DL, MVT::v8f32, V1);
16365 return DAG.getNode(X86ISD::MOVDDUP, DL, MVT::v8f64, V1);
16424 return DAG.getNode(X86ISD::MOVSLDUP, DL, MVT::v16f32, V1);
16426 return DAG.getNode(X86ISD::MOVSHDUP, DL, MVT::v16f32, V1);
16957 V1 = DAG.getNode(ISD::SIGN_EXTEND, DL, ExtVT, V1);
16958 V2 = DAG.getNode(ISD::SIGN_EXTEND, DL, ExtVT, V2);
16968 return DAG.getNode(ISD::TRUNCATE, DL, VT, Shuffle);
17291 return DAG.getNode(ISD::TRUNCATE, dl, VT, Extract);
17344 SDValue Ext = DAG.getNode(ISD::SIGN_EXTEND, dl, ExtVecVT, Vec);
17346 return DAG.getNode(ISD::TRUNCATE, dl, EltVT, Elt);
17444 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i16,
17451 return DAG.getNode(ISD::TRUNCATE, dl, VT, Extract);
17472 return DAG.getNode(ISD::TRUNCATE, dl, VT, Res);
17483 return DAG.getNode(ISD::TRUNCATE, dl, VT, Res);
17533 DAG.getNode(ISD::SIGN_EXTEND, dl, ExtVecVT, Vec),
17534 DAG.getNode(ISD::SIGN_EXTEND, dl, ExtEltVT, Elt), Idx);
17535 return DAG.getNode(ISD::TRUNCATE, dl, VecVT, ExtOp);
17539 SDValue EltInVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v1i1, Elt);
17591 SDValue N1Vec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, N1);
17618 N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, N1);
17636 N1 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, N1);
17662 N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
17667 N1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4f32, N1);
17698 Op = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT128, Op.getOperand(0));
17710 SDValue AnyExt = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Op.getOperand(0));
17712 OpVT, DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32, AnyExt));
17798 Result = DAG.getNode(getGlobalWrapperKind(), DL, PtrVT, Result);
17819 Result = DAG.getNode(getGlobalWrapperKind(), DL, PtrVT, Result);
17845 Result = DAG.getNode(getGlobalWrapperKind(), dl, PtrVT, Result);
17906 Result = DAG.getNode(getGlobalWrapperKind(GV, OpFlags), dl, PtrVT, Result);
18020 SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
18063 SDValue Offset = DAG.getNode(WrapperKind, dl, PtrVT, TGA);
18128 SDValue Offset = DAG.getNode(WrapperKind, DL, PtrVT, Result);
18216 SDValue Offset = DAG.getNode(X86ISD::Wrapper, dl, PtrVT, TGA);
18348 SDValue InVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecInVT, Src);
18349 SDValue CvtVec = DAG.getNode(Op.getOpcode(), dl, VecVT, InVec);
18413 SDValue VCast = DAG.getNode(Cast.getOpcode(), DL, ToVT, VecOp);
18433 return DAG.getNode(X86ISD::CVTSI2P, dl, VT,
18576 SDValue XR1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
18614 SDValue Load = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v4i32,
18628 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f64, Load)),
18630 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2f64, Bias)));
18657 return DAG.getNode(X86ISD::CVTUI2P, DL, MVT::v2f64, N0);
18671 SDValue fHI = DAG.getNode(X86ISD::CVTSI2P, DL, MVT::v2f64, HI);
18673 SDValue fLO = DAG.getNode(X86ISD::CVTSI2P, DL, MVT::v2f64, LO);
18817 N0 = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, N0);
18818 return DAG.getNode(ISD::SINT_TO_FP, dl, DstVT, N0);
19059 return DAG.getNode(ExtendInVecOpc, dl, VT, In);
19078 SDValue OpLo = DAG.getNode(ExtendInVecOpc, dl, HalfVT, In);
19103 Lo = DAG.getNode(ExtOpc, dl, MVT::v8i16, Lo);
19104 Hi = DAG.getNode(ExtOpc, dl, MVT::v8i16, Hi);
19106 return DAG.getNode(ISD::TRUNCATE, dl, VT, Res);
19122 SDValue Extend = DAG.getNode(ISD::SIGN_EXTEND, DL, VT, In);
19156 SelectedVal = DAG.getNode(ISD::TRUNCATE, DL, WideVT, SelectedVal);
19334 In = DAG.getNode(ISD::SIGN_EXTEND, DL, InVT, In);
19340 Lo = DAG.getNode(ISD::TRUNCATE, DL, MVT::v8i1, Lo);
19341 Hi = DAG.getNode(ISD::TRUNCATE, DL, MVT::v8i1, Hi);
19349 In = DAG.getNode(ISD::SIGN_EXTEND, DL, ExtVT, In);
19390 Lo = DAG.getNode(ISD::TRUNCATE, DL, LoVT, Lo);
19391 Hi = DAG.getNode(ISD::TRUNCATE, DL, HiVT, Hi);
19546 SDValue Res = DAG.getNode(Opc, dl, ResVT, Src);
19547 Res = DAG.getNode(ISD::TRUNCATE, dl, TruncVT, Res);
19554 return DAG.getNode(IsSigned ? X86ISD::CVTTP2SI : X86ISD::CVTTP2UI, dl, VT,
19579 SDValue Res = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i64, Src);
19580 return DAG.getNode(ISD::TRUNCATE, dl, VT, Res);
19592 SDValue Res = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, Src);
19593 return DAG.getNode(ISD::TRUNCATE, dl, VT, Res);
19620 return DAG.getNode(X86ISD::VFPEXT, DL, VT,
19794 Operand = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LogicVT, Operand);
19808 Sign = DAG.getNode(ISD::FP_EXTEND, dl, VT, Sign);
19843 Sign = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LogicVT, Sign);
19857 Mag = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LogicVT, Mag);
19878 SDValue Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, N0);
19879 Res = DAG.getNode(X86ISD::MOVMSK, dl, MVT::i32, Res);
20177 Op0 = DAG.getNode(ExtendOp, dl, CmpVT, Op0);
20178 Op1 = DAG.getNode(ExtendOp, dl, CmpVT, Op1);
20203 SDValue TruncFPSW = DAG.getNode(ISD::TRUNCATE, dl, MVT::i16, Cmp);
20204 SDValue FNStSW = DAG.getNode(X86ISD::FNSTSW16r, dl, MVT::i16, TruncFPSW);
20207 SDValue TruncSrl = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Srl);
20211 return DAG.getNode(X86ISD::SAHF, dl, MVT::i32, TruncSrl);
20255 return DAG.getNode(Opcode, SDLoc(Op), VT, Op);
20289 return DAG.getNode(Opcode, SDLoc(Op), VT, Op);
20422 Src = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i32, Src);
20430 Src = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Src);
20435 BitNo = DAG.getNode(ISD::ANY_EXTEND, dl, Src.getValueType(), BitNo);
21250 SDValue VOp1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VecVT, Op1);
21251 SDValue VOp2 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VecVT, Op2);
21252 SDValue VCmp = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VecVT, Cmp);
21270 SDValue Cmp = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v1i1, Cond);
21388 Neg = DAG.getNode(ISD::TRUNCATE, DL, VT, CmpOp0);
21391 DAG.getNode(ISD::ANY_EXTEND, DL, VT, CmpOp0.getOperand(0)),
21492 return DAG.getNode(ISD::TRUNCATE, DL, Op.getValueType(), Cmov);
21505 Op1 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, Op1);
21506 Op2 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i32, Op2);
21509 return DAG.getNode(ISD::TRUNCATE, DL, Op.getValueType(), Cmov);
21554 V = DAG.getNode(Op.getOpcode(), dl, WideVT, In);
21564 V = DAG.getNode(ISD::TRUNCATE, dl, WideVT, V);
21632 return DAG.getNode(Op.getOpcode(), dl, VT, In);
21639 return DAG.getNode(ExtOpc, dl, VT, In);
21653 SDValue Lo = DAG.getNode(Opc, dl, HalfVT, In);
21655 Hi = DAG.getNode(Opc, dl, HalfVT, Hi);
21732 return DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, dl, VT, In);
21747 SDValue OpLo = DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, dl, HalfVT, In);
21755 OpHi = DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, dl, HalfVT, OpHi);
21849 StoredVal = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, StoredVal);
21932 SDValue Val = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i16, NewLd);
22543 ShAmt = DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(ShAmt), MVT::v2i64, ShAmt);
22550 ShAmt = DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(ShAmt), AmtTy, ShAmt);
22552 ShAmt = DAG.getNode(ISD::ZERO_EXTEND_VECTOR_INREG, SDLoc(ShAmt),
22565 ShAmt = DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(ShAmt), MVT::v4i32, ShAmt);
22566 ShAmt = DAG.getNode(ISD::ZERO_EXTEND_VECTOR_INREG, SDLoc(ShAmt),
22720 DAG.getNode(ISD::LOCAL_RECOVER, dl, PtrVT, OffsetSymVal);
22797 return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Op.getOperand(1));
22810 return DAG.getNode(Opc, dl, Op.getValueType(), Op.getOperand(1));
22893 return getVectorMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src),
22910 return getVectorMaskingNode(DAG.getNode(Opc, dl, VT, Src),
23183 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
23205 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32,
23313 return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Src);
23343 return DAG.getNode(IntrData->Opc0, dl, Op.getValueType(), Src);
23447 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
23509 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, SetCC);
23545 return DAG.getNode(getGlobalWrapperKind(), dl, VT,
23560 return DAG.getNode(X86ISD::Wrapper, dl, VT, Result);
23662 ShAmt = DAG.getNode(X86ISD::MMX_MOVW2D, DL, MVT::x86mmx, ShAmt);
24129 SDValue Ret = DAG.getNode(ISD::ZERO_EXTEND, dl, Op->getValueType(0), SetCC);
24362 return DAG.getNode(X86ISD::EH_SJLJ_SETUP_DISPATCH, DL, MVT::Other,
24582 return DAG.getNode((VT.getSizeInBits() < 16 ?
24603 DAG.getNode(Op.getOpcode(), dl, NewVT, Lo),
24604 DAG.getNode(Op.getOpcode(), dl, NewVT, Hi));
24650 Op = DAG.getNode(ISD::ZERO_EXTEND, dl, NewVT, Op.getOperand(0));
24651 SDValue CtlzNode = DAG.getNode(ISD::CTLZ, dl, NewVT, Op);
24652 SDValue TruncNode = DAG.getNode(ISD::TRUNCATE, dl, VT, CtlzNode);
24693 HiZ = DAG.getNode(ISD::SIGN_EXTEND, DL, CurrVT, HiZ);
24720 HiZ = DAG.getNode(ISD::SIGN_EXTEND, DL, CurrVT, HiZ);
24778 Op = DAG.getNode(ISD::ZERO_EXTEND, dl, OpVT, Op);
24798 Op = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Op);
25041 return DAG.getNode(
25044 DAG.getNode(ISD::ANY_EXTEND, dl, ExVT, A),
25045 DAG.getNode(ISD::ANY_EXTEND, dl, ExVT, B)));
25256 SDValue ExA = DAG.getNode(ExAVX, dl, ExVT, A);
25257 SDValue ExB = DAG.getNode(ExAVX, dl, ExVT, B);
25260 return DAG.getNode(ISD::TRUNCATE, dl, VT, Mul);
25275 ALo = DAG.getNode(ExAVX, dl, ExVT, ALo);
25276 BLo = DAG.getNode(ExAVX, dl, ExVT, BLo);
25277 AHi = DAG.getNode(ExAVX, dl, ExVT, AHi);
25278 BHi = DAG.getNode(ExAVX, dl, ExVT, BHi);
25313 ALo = DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, dl, ExVT, A);
25316 AHi = DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, dl, ExVT, AHi);
25355 BLo = DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, dl, ExVT, B);
25358 BHi = DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, dl, ExVT, BHi);
25568 return DAG.getNode(ISD::SIGN_EXTEND, dl, VT, CMP);
25625 BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, BaseShAmt);
25627 BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, BaseShAmt);
25642 BaseShAmt = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i32, BaseShAmt);
25740 return DAG.getNode(ISD::FP_TO_SINT, dl, VT, Amt);
25991 R = DAG.getNode(ExtOpc, dl, ExtVT, R);
25992 Amt = DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVT, Amt);
25993 return DAG.getNode(ISD::TRUNCATE, dl, VT,
26679 return DAG.getNode(X86ISD::MFENCE, dl, MVT::Other, Op.getOperand(0));
26686 return DAG.getNode(X86ISD::MEMBARRIER, dl, MVT::Other, Op.getOperand(0));
26737 Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, Lo);
26738 Hi = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, Hi);
26746 Lo = DAG.getNode(X86ISD::MOVMSK, DL, MVT::i32, Lo);
26747 Hi = DAG.getNode(X86ISD::MOVMSK, DL, MVT::i32, Hi);
26753 return DAG.getNode(X86ISD::MOVMSK, DL, MVT::i32, V);
26819 Src = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, Src);
26823 Src = DAG.getNode(ISD::BITCAST, dl, V2X64VT, Src);
26826 return DAG.getNode(X86ISD::MOVDQ2Q, dl, DstVT, Src);
26964 Op = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, Op0);
26965 Op = DAG.getNode(ISD::CTPOP, DL, NewVT, Op);
26966 return DAG.getNode(ISD::TRUNCATE, DL, VT, Op);
26982 SDValue PopCnt8 = DAG.getNode(ISD::CTPOP, DL, ByteVT, ByteOp);
27009 SDValue Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VecVT, In);
27010 Res = DAG.getNode(ISD::BITREVERSE, DL, VecVT, Res);
27184 SDValue NewChain = DAG.getNode(X86ISD::MEMBARRIER, DL, MVT::Other, Chain);
27222 SDValue SclToVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64,
27274 SetCC = DAG.getNode(ISD::TRUNCATE, DL, MVT::i1, SetCC);
27836 DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, MVT::v2i64, N->getOperand(0));
27837 Wide = DAG.getNode(ISD::CTPOP, dl, MVT::v2i64, Wide);
27840 Wide = DAG.getNode(ISD::BITCAST, dl, MVT::v4i32, Wide);
27843 Wide = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Wide);
27855 SDValue Op0 = DAG.getNode(ISD::ANY_EXTEND, dl, MulVT, N->getOperand(0));
27856 SDValue Op1 = DAG.getNode(ISD::ANY_EXTEND, dl, MulVT, N->getOperand(1));
27858 Res = DAG.getNode(ISD::TRUNCATE, dl, VT, Res);
27997 Ops[i] = DAG.getNode(ISD::TRUNCATE, dl, EltVT, Val);
28008 Results.push_back(DAG.getNode(X86ISD::VTRUNC, dl, WidenVT, In));
28015 Results.push_back(DAG.getNode(X86ISD::VTRUNC, dl, WidenVT, In));
28027 Lo = DAG.getNode(X86ISD::VTRUNC, dl, MVT::v16i8, Lo);
28028 Hi = DAG.getNode(X86ISD::VTRUNC, dl, MVT::v16i8, Hi);
28058 In = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i32, In);
28068 Lo = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, Lo);
28071 Hi = DAG.getNode(ISD::BITCAST, dl, MVT::v2i64, Hi);
28090 In = DAG.getNode(N->getOpcode(), dl, InVT, In);
28131 SDValue Res = DAG.getNode(ISD::FP_TO_SINT, dl, PromoteVT, Src);
28142 Res = DAG.getNode(ISD::TRUNCATE, dl, VT, Res);
28171 SDValue Res = DAG.getNode(Opc, dl, MVT::v4i32, Src);
28197 Res = DAG.getNode(N->getOpcode(), SDLoc(N), VecVT, Res);
28212 Results.push_back(DAG.getNode(X86ISD::CVTSI2P, dl, MVT::v4f32, Src));
28223 Results.push_back(DAG.getNode(X86ISD::CVTUI2P, dl, MVT::v4f32, Src));
28228 SDValue ZExtIn = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::v2i64, Src);
28236 Results.push_back(DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, Sub));
28242 SDValue V = DAG.getNode(X86ISD::VFPROUND, dl, MVT::v4f32, N->getOperand(0));
28471 SDValue Res = DAG.getNode(X86ISD::MOVQ2DQ, dl, WideVT, N->getOperand(0));
28499 Mask = DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i32, Mask);
28530 Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VecVT, Res);
32347 return DAG.getBitcast(RootVT, DAG.getNode(X86ISD::SUBV_BROADCAST, DL,
32447 Res = DAG.getNode(X86ISD::VBROADCAST, DL, MaskVT, Res);
32454 Res = DAG.getNode(X86ISD::VBROADCAST, DL, MaskVT, Res);
32468 Res = DAG.getNode(Shuffle, DL, ShuffleVT, Res);
33482 return DAG.getNode(X86ISD::VBROADCAST, DL, VT,
33492 return DAG.getBitcast(VT, DAG.getNode(X86ISD::VBROADCAST, DL, NewVT, BC));
33497 return DAG.getNode(X86ISD::VBROADCAST, DL, VT,
33502 return DAG.getNode(X86ISD::VBROADCAST, DL, VT, Src.getOperand(0));
33604 SDValue SclVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VT, Scl);
33707 DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VT,
34226 SDValue Movl = DAG.getNode(X86ISD::VZEXT_MOVL, dl, In.getValueType(), In);
34557 TLO.DAG.getNode(Opc, DL, Ext0.getValueType(), Ext0);
34573 Src = TLO.DAG.getNode(X86ISD::SUBV_BROADCAST, DL, SrcVT, Src);
35196 return DAG.getNode(ISD::SIGN_EXTEND, DL, SExtVT, Src);
35296 : DAG.getNode(ISD::SIGN_EXTEND, DL, SExtVT, Src);
35304 V = DAG.getNode(X86ISD::MOVMSK, DL, MVT::i32, V);
35399 V = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v4f32, V);
35401 return DAG.getNode(X86ISD::MOVDQ2Q, DL, MVT::x86mmx, V);
35407 return DAG.getNode(X86ISD::MMX_MOVW2D, DL, MVT::x86mmx, V);
35488 SDValue V = DAG.getNode(X86ISD::MOVMSK, dl, MVT::i32,
35498 N0 = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::i8, N0);
35524 return DAG.getNode(ISD::TRUNCATE, dl, VT, N0);
35533 return DAG.getNode(ISD::TRUNCATE, dl, VT, N0);
35546 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT,
35575 return DAG.getNode(X86ISD::MMX_MOVW2D, DL, VT,
35598 return DAG.getNode(X86ISD::MMX_MOVW2D, dl, VT, N00);
35616 return DAG.getNode(X86ISD::MOVDQ2Q, SDLoc(N00), VT,
35625 return DAG.getNode(X86ISD::MOVDQ2Q, DL, VT,
35811 MinPos = DAG.getNode(X86ISD::PHMINPOS, DL, MVT::v8i16, MinPos);
35924 SDValue Result = DAG.getNode(ISD::CTPOP, DL, CmpVT, Movmsk);
36424 Scl = DAG.getNode(ISD::TRUNCATE, dl, SrcVT.getScalarType(), Scl);
36454 return DAG.getNode(X86ISD::MMX_MOVD2W, dl, MVT::i32, MMXSrc);
36706 SDValue R = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Cond);
37014 Cond = DAG.getNode(ISD::SIGN_EXTEND, DL, VT, Cond);
37621 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, TrueC->getValueType(0), Cond);
37635 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL,
37668 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, FalseC->getValueType(0),
37892 SDValue NewN0 = DAG.getNode(ISD::TRUNCATE, DL, ReducedVT, N0);
37893 SDValue NewN1 = DAG.getNode(ISD::TRUNCATE, DL, ReducedVT, N1);
37899 return DAG.getNode((Mode == MULU8) ? ISD::ZERO_EXTEND : ISD::SIGN_EXTEND,
38495 return DAG.getNode(X86ISD::VTRUNC, SDLoc(N), VT, N0.getOperand(0));
38501 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Concat);
38730 SDValue Vector64 = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v2f64,
38741 SDValue OneBitOfTruth = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8,
38829 N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N1);
39024 Sub = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Sub);
39069 SDValue Hi = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32,
39072 SDValue Lo = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, X);
39077 DAG.getNode(ISD::CTPOP, DL, MVT::i32, X),
39079 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Parity);
39091 SDValue Hi = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8,
39094 SDValue Lo = DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, X);
39101 return DAG.getNode(ISD::ZERO_EXTEND, DL, N->getValueType(0), Setnp);
39189 SDValue LHS = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, N->getOperand(0));
39190 SDValue RHS = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, N->getOperand(1));
39191 return DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64,
39495 SDValue Clz = DAG.getNode(ISD::CTLZ, dl, VT, Cmp->getOperand(0));
39585 Ret = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), N->getValueType(0), Ret);
39711 DAG.getNode(ISD::TRUNCATE, DL, MVT::i8, Amt));
39815 Cond = DAG.getNode(ISD::ZERO_EXTEND, DL, ResultType, Cond);
39982 return DAG.getNode(X86ISD::VTRUNCUS, DL, VT, Mid);
40054 SDValue Res = DAG.getNode(TruncOpc, DL, TruncVT, SatVal);
40145 Operands[1] = DAG.getNode(ISD::TRUNCATE, DL, VT, Operands[1]);
40608 SDValue Ext = DAG.getNode(ISD::ANY_EXTEND, dl, MVT::v16i32, St->getValue());
40967 SDValue Trunc0 = DAG.getNode(ISD::TRUNCATE, DL, VT, N0);
40968 SDValue Trunc1 = DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
41385 return DAG.getNode(X86ISD::MMX_MOVD2W, DL, MVT::i32, BCSrc);
41401 return DAG.getNode(X86ISD::VTRUNCS, DL, VT, SSatVal);
41403 return DAG.getNode(X86ISD::VTRUNCUS, DL, VT, USatVal);
42008 SDValue Convert = DAG.getNode(N->getOpcode(), dl, VT,
42043 SDValue Convert = DAG.getNode(N->getOpcode(), dl, VT,
42135 CMovOp0 = DAG.getNode(IntermediateOpc, DL, DstVT, CMovOp0);
42136 CMovOp1 = DAG.getNode(IntermediateOpc, DL, DstVT, CMovOp1);
42146 CMovOp0 = DAG.getNode(ISD::ZERO_EXTEND, DL, CMovVT, CMovOp0);
42147 CMovOp1 = DAG.getNode(ISD::ZERO_EXTEND, DL, CMovVT, CMovOp1);
42154 CMov = DAG.getNode(ISD::TRUNCATE, DL, DstVT, CMov);
42190 return DAG.getNode(ISD::SIGN_EXTEND, dl, MVT::v4i64, Tmp);
42250 SDValue NewExt = DAG.getNode(Ext->getOpcode(), SDLoc(Ext), VT, AddOp0);
42305 CMovOp0 = DAG.getNode(ExtendOpcode, DL, ExtendVT, CMovOp0);
42306 CMovOp1 = DAG.getNode(ExtendOpcode, DL, ExtendVT, CMovOp1);
42313 Res = DAG.getNode(ExtendOpcode, DL, TargetVT, Res);
42369 Vec = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, BroadcastVT, N00);
42379 Vec = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VT, Scl);
42473 SDValue Zext = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0));
42799 return DAG.getNode(ISD::TRUNCATE, DL, VT, SetCC.getValue(0));
42806 SDValue MovMsk = DAG.getNode(X86ISD::MOVMSK, DL, MVT::i32, Cmp);
42884 return DAG.getNode(ISD::TRUNCATE, DL, VT, Setcc);
42921 return DAG.getNode(X86ISD::MOVMSK, SDLoc(N), VT, Src.getOperand(0));
42930 DAG.getNode(X86ISD::MOVMSK, DL, VT, NotSrc),
42982 Index = DAG.getNode(ISD::TRUNCATE, DL, NewVT, Index);
43011 Index = DAG.getNode(ISD::TRUNCATE, DL, NewVT, Index);
43134 SDValue SourceConst = DAG.getNode(N->getOpcode(), DL, VT, SDValue(BV, 0));
43178 return DAG.getNode(N->getOpcode(), DL, N->getValueType(0), NewExtElt);
43194 SDValue P = DAG.getNode(ISD::ZERO_EXTEND, dl, DstVT, Op0);
43197 return DAG.getNode(ISD::SINT_TO_FP, dl, VT, P);
43204 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, Op0);
43229 SDValue P = DAG.getNode(ISD::SIGN_EXTEND, dl, DstVT, Op0);
43230 return DAG.getNode(ISD::SINT_TO_FP, dl, VT, P);
43246 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, TruncVT, Op0);
43247 return DAG.getNode(ISD::SINT_TO_FP, dl, VT, Trunc);
43255 return DAG.getNode(X86ISD::CVTSI2P, dl, VT, Shuf);
43427 SDValue Op0 = DAG.getNode(ISD::TRUNCATE, dl, VT, Op.getOperand(0));
43428 SDValue Op1 = DAG.getNode(ISD::TRUNCATE, dl, VT, Op.getOperand(1));
43732 SDValue N0 = DAG.getNode(ISD::TRUNCATE, DL, ReducedVT, MulOp->getOperand(0));
43733 SDValue N1 = DAG.getNode(ISD::TRUNCATE, DL, ReducedVT, MulOp->getOperand(1));
43808 Sad = DAG.getNode(ISD::BITCAST, DL, ResVT, Sad);
43930 DAG.getNode(ISD::TRUNCATE, DL, TruncVT, Ops[0]),
43931 DAG.getNode(ISD::TRUNCATE, DL, TruncVT, Ops[1]));
44102 SDValue SExt = DAG.getNode(ISD::SIGN_EXTEND, DL, VT, Op0.getOperand(0));
44110 SDValue SExt = DAG.getNode(ISD::SIGN_EXTEND, DL, VT, Op1.getOperand(0));
44304 return DAG.getNode(Op0.getOpcode(), DL, VT, Op0.getOperand(0));
44309 return DAG.getNode(X86ISD::VBROADCAST, DL, VT,
44319 return DAG.getNode(X86ISD::VBROADCAST, DL, VT, Op0.getOperand(0));
44500 return DAG.getNode(X86ISD::VBROADCAST, dl, OpVT, SubVec.getOperand(0));
44686 return DAG.getNode(X86ISD::VBROADCAST, SDLoc(N), VT, InVec.getOperand(0));
44710 return DAG.getNode(X86ISD::CVTSI2P, SDLoc(N), VT, InVec.getOperand(0));
44715 return DAG.getNode(X86ISD::CVTUI2P, SDLoc(N), VT, InVec.getOperand(0));
44720 return DAG.getNode(X86ISD::VFPEXT, SDLoc(N), VT, InVec.getOperand(0));
44732 return DAG.getNode(ExtOp, SDLoc(N), VT, InVec.getOperand(0));
44761 return DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v1i1,
44779 VT, DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, MVT::v4i32,
45606 SDValue Result = DAG.getNode(ISD::ZERO_EXTEND, DL, OpInfo.ConstraintVT, CC);
lib/Target/XCore/XCoreISelLowering.cpp 254 return DAG.getNode(XCoreISD::PCRelativeWrapper, dl, MVT::i32, GA);
259 return DAG.getNode(XCoreISD::CPRelativeWrapper, dl, MVT::i32, GA);
261 return DAG.getNode(XCoreISD::DPRelativeWrapper, dl, MVT::i32, GA);
317 return DAG.getNode(XCoreISD::PCRelativeWrapper, DL, PtrVT, Result);
335 return DAG.getNode(XCoreISD::CPRelativeWrapper, dl, MVT::i32, Res);
933 return DAG.getNode(XCoreISD::MEMBARRIER, DL, MVT::Other, Op.getOperand(0));
1150 Arg = DAG.getNode(ISD::SIGN_EXTEND, dl, VA.getLocVT(), Arg);
1153 Arg = DAG.getNode(ISD::ZERO_EXTEND, dl, VA.getLocVT(), Arg);
1156 Arg = DAG.getNode(ISD::ANY_EXTEND, dl, VA.getLocVT(), Arg);
unittests/CodeGen/AArch64SelectionDAGTest.cpp 89 auto Op = DAG->getNode(ISD::ZERO_EXTEND_VECTOR_INREG, Loc, OutVecVT, InVec);
119 auto Op = DAG->getNode(ISD::SIGN_EXTEND_VECTOR_INREG, Loc, OutVecVT, InVec);