reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/CodeGen/SelectionDAG.h
  578   SDValue getConstant(uint64_t Val, const SDLoc &DL, EVT VT,

References

gen/lib/Target/AMDGPU/AMDGPUGenDAGISel.inc
79788   return CurDAG->getConstant(-N->getSExtValue(), SDLoc(N), MVT::i32);
include/llvm/CodeGen/SelectionDAG.h
  598     return getConstant(Val, DL, VT, true, isOpaque);
  848     return getObjectPtrOffset(SL, Op, getConstant(Offset, SL, VT));
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
 2243       return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
 2476                                  DAG.getConstant(1, DL, VT));
 2492                          DAG.getConstant(0, DL, VT), Carry);
 2535     Cst = DAG.getConstant(1, DL, VT);
 2608     return CombineTo(N, N0, DAG.getConstant(0, DL, CarryVT));
 2614                        DAG.getConstant(0, DL, CarryVT));
 2619                                 DAG.getConstant(0, DL, VT), N0.getOperand(0));
 2643     SDValue One = DAG.getConstant(1, SDLoc(N), Y.getValueType());
 2653                          DAG.getConstant(0, SDLoc(N), VT), Carry);
 2703                                     DAG.getConstant(1, DL, VT)),
 2704                      DAG.getConstant(0, DL, CarryVT));
 2758     Z = DAG.getConstant(1, SDLoc(Carry0.getOperand(1)), VT);
 2770                        DAG.getConstant(0, DL, X.getValueType()),
 2847     return DAG.getConstant(0, DL, VT);
 2849     return DAG.getConstant(0, DL, VT);
 3055     return DAG.getNode(ISD::ADD, DL, VT, Add, DAG.getConstant(1, DL, VT));
 3121           return DAG.getConstant((uint64_t)GA->getOffset() - GB->getOffset(),
 3130                                  DAG.getConstant(1, DL, VT));
 3151       SDValue Zero = DAG.getConstant(0, DL, VT);
 3179     return DAG.getConstant(0, DL, VT);
 3183     return DAG.getConstant(0, DL, VT);
 3212     return CombineTo(N, DAG.getConstant(0, DL, VT),
 3243     return CombineTo(N, DAG.getConstant(0, DL, VT),
 3244                      DAG.getConstant(0, DL, CarryVT));
 3256     return CombineTo(N, N0, DAG.getConstant(0, DL, CarryVT));
 3261                      DAG.getConstant(0, DL, CarryVT));
 3303     return DAG.getConstant(0, SDLoc(N), VT);
 3312     return DAG.getConstant(0, SDLoc(N), VT);
 3324     return DAG.getConstant(0, SDLoc(N), VT);
 3380                        DAG.getConstant(0, DL, VT), N0);
 3399                        DAG.getConstant(0, DL, VT),
 3401                             DAG.getConstant(Log2Val, DL,
 3430           DAG.getNode(ISD::SHL, DL, VT, N0, DAG.getConstant(ShAmt, DL, VT));
 3433         R = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), R);
 3598     return DAG.getConstant(0, DL, VT);
 3609     return DAG.getConstant(IsDiv ? 1 : 0, DL, VT);
 3618     return IsDiv ? N0 : DAG.getConstant(0, DL, VT);
 3643     return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), N0);
 3647                          DAG.getConstant(1, DL, VT),
 3648                          DAG.getConstant(0, DL, VT));
 3715     SDValue Bits = DAG.getConstant(BitWidth, DL, ShiftAmtTy);
 3724                                DAG.getConstant(BitWidth - 1, DL, ShiftAmtTy));
 3737     SDValue One = DAG.getConstant(1, DL, VT);
 3746     SDValue Zero = DAG.getConstant(0, DL, VT);
 3790                          DAG.getConstant(1, DL, VT),
 3791                          DAG.getConstant(0, DL, VT));
 3887                          DAG.getConstant(0, DL, VT), N0);
 3961       return DAG.getConstant(0, DL, VT);
 3970                        DAG.getConstant(N0.getScalarValueSizeInBits() - 1, DL,
 3975     return DAG.getConstant(0, DL, VT);
 3988             DAG.getConstant(SimpleSize, DL,
 4008       return DAG.getConstant(0, DL, VT);
 4016     return DAG.getConstant(0, DL, N0.getValueType());
 4019     return DAG.getConstant(0, DL, VT);
 4027         ISD::SUB, DL, VT, DAG.getConstant(NumEltBits, DL, VT), LogBase2);
 4044             DAG.getConstant(SimpleSize, DL,
 4121             DAG.getConstant(SimpleSize, DL,
 4142     SDValue Zero = DAG.getConstant(0, DL, VT);
 4148     SDValue Zero = DAG.getConstant(0, DL, VT);
 4164             DAG.getConstant(SimpleSize, DL,
 4192     return CombineTo(N, DAG.getConstant(0, DL, VT),
 4193                      DAG.getConstant(0, DL, CarryVT));
 4488     SDValue One = DAG.getConstant(1, DL, OpVT);
 4489     SDValue Two = DAG.getConstant(2, DL, OpVT);
 4505       SDValue Zero = DAG.getConstant(0, DL, OpVT);
 4530           SDValue Zero = DAG.getConstant(0, DL, OpVT);
 4568     return DAG.getConstant(0, DL, VT);
 4645           SDValue ShiftK = DAG.getConstant(ShiftBits, SL, ShiftVT);
 5029   SDValue Zero = DAG.getConstant(0, DL, VT);
 5081     return DAG.getConstant(0, SDLoc(N), VT);
 5431                       DAG.getConstant(OpSizeInBits - 16, DL,
 5592   SDValue ShAmt = DAG.getConstant(16, DL, getShiftAmountTy(VT));
 6876     return DAG.getConstant(0, DL, VT);
 6928                     DAG.getConstant(1, DL0, V.getValueType()));
 7037     return DAG.getNode(ISD::ROTL, DL, VT, DAG.getConstant(~1, DL, VT),
 7247                          DAG.getConstant(RotAmt, dl, N1.getValueType()));
 7269         SDValue BitsizeC = DAG.getConstant(Bitsize, dl, ShiftVT);
 7330     return DAG.getConstant(0, SDLoc(N), VT);
 7353       return DAG.getConstant(0, SDLoc(N), VT);
 7394       return DAG.getConstant(0, SDLoc(N), VT);
 7452                            DAG.getConstant(C2 - C1, DL, ShiftVT));
 7454                          DAG.getConstant(C1 - C2, DL, ShiftVT));
 7476                               DAG.getConstant(c2 - c1, DL, ShiftVT));
 7481                               DAG.getConstant(c1 - c2, DL, ShiftVT));
 7591       ShiftValues.push_back(DAG.getConstant(ShiftSum, DL, ShiftSVT));
 7632         SDValue Amt = DAG.getConstant(ShiftAmt, DL,
 7697         SDValue Amt = DAG.getConstant(N1C->getZExtValue() + TruncBits, DL,
 7750     return DAG.getConstant(0, SDLoc(N), VT);
 7762       return DAG.getConstant(0, SDLoc(N), VT);
 7793           return DAG.getConstant(0, DL, VT);
 7797                                        DAG.getConstant(c1 + c2, DL,
 7828                           DAG.getConstant(ShiftAmt, DL0,
 7853     if (Known.One.getBoolValue()) return DAG.getConstant(0, SDLoc(N0), VT);
 7858     if (UnknownBits == 0) return DAG.getConstant(1, SDLoc(N0), VT);
 7872                   DAG.getConstant(ShAmt, DL,
 7879                          Op, DAG.getConstant(1, DL, VT));
 7963                          DAG.getConstant(RotAmt, SDLoc(N), ShAmtTy));
 7976                          DAG.getConstant(IsFSHL ? BitWidth - ShAmt : ShAmt,
 7980                          DAG.getConstant(IsFSHL ? ShAmt : BitWidth - ShAmt,
 8201     SDValue ShAmtC = DAG.getConstant(X.getScalarValueSizeInBits() - 1, DL, VT);
 8208     SDValue ShAmtC = DAG.getConstant(X.getScalarValueSizeInBits() - 1, DL, VT);
 8287         SDValue ShAmtC = DAG.getConstant(C1Val.exactLogBase2(), DL, VT);
 8314         DAG.getNode(ISD::XOR, DL, CondVT, Cond, DAG.getConstant(1, DL, CondVT));
 8664     SDValue ShAmtC = DAG.getConstant(Pow2C.exactLogBase2(), DL, VT);
 8716                                   DAG.getConstant(VT.getScalarSizeInBits() - 1,
 8952       Elts.push_back(IsZext ? DAG.getConstant(0, DL, SVT) : DAG.getUNDEF(SVT));
 9131                           DAG.getConstant(Stride, DL, BasePtr.getValueType()));
 9403     SDValue ShiftAmount = DAG.getConstant(VT.getSizeInBits() - 1, DL, VT);
 9594     SDValue Zero = DAG.getConstant(0, DL, VT);
 9628     return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Zext);
 9891       SDValue VecOnes = DAG.getConstant(1, DL, VT);
 9913             DL, N0.getOperand(0), N0.getOperand(1), DAG.getConstant(1, DL, VT),
 9914             DAG.getConstant(0, DL, VT),
10092             DL, N0.getOperand(0), N0.getOperand(1), DAG.getConstant(1, DL, VT),
10093             DAG.getConstant(0, DL, VT),
10316                                DAG.getConstant(PtrOff, DL, PtrType),
10346       Result = DAG.getConstant(0, DL, VT);
10349                           Result, DAG.getConstant(ShLeftAmt, DL, ShImmTy));
10362     SDValue ShiftC = DAG.getConstant(ShAmt, DL, VT);
10608                          DAG.getConstant(Index, DL, IndexTy));
10778                          DAG.getConstant(Idx, SL, IdxVT));
11104                         DAG.getConstant(OrigXWidth-VTWidth, DL,
13364                               Op0, DAG.getConstant(0, DL, Op0.getValueType()),
14393                               DAG->getConstant(Offset, DL, ArithType));
14804                        DAG.getConstant(ByteShift*8, DL,
14821                       Ptr, DAG.getConstant(StOffset, DL, Ptr.getValueType()));
14934                                    DAG.getConstant(PtrOff, SDLoc(LD),
16074       Tmp = DAG.getConstant((uint32_t)CFP->getValueAPF().
16086       Tmp = DAG.getConstant(CFP->getValueAPF().bitcastToAPInt().
16098       SDValue Lo = DAG.getConstant(Val & 0xFFFFFFFF, SDLoc(CFP), MVT::i32);
16099       SDValue Hi = DAG.getConstant(Val >> 32, SDLoc(CFP), MVT::i32);
16110                         DAG.getConstant(4, DL, Ptr.getValueType()));
16487                   DAG.getConstant(HalfValBitSize / 8, DL, Ptr.getValueType()));
16702     Offset = DAG.getConstant(PtrOff, DL, PtrType);
16708         DAG.getConstant(VecEltVT.getStoreSize(), DL, PtrType));
16930                          DAG.getConstant(OrigElt, DL, IndexTy));
17037       Index = DAG.getConstant(Elt, DL, Index.getValueType());
17124                                DAG.getConstant(0, DL, SourceType);
17171   SDValue ZeroIdx = DAG.getConstant(0, DL, IdxTy);
17205                              DAG.getConstant(NumElems, DL, IdxTy));
17350   SDValue ZeroVec = DAG.getConstant(0, DL, VecVT);
17465                                      DAG.getConstant(SplitSize, DL, IdxTy));
17467                                      DAG.getConstant(0, DL, IdxTy));
17518     Shuffles.push_back(VT.isInteger() ? DAG.getConstant(0, DL, VT)
18130     SDValue NewExtIndex = DAG.getConstant(ExtBOIdx, DL, ExtBOIdxVT);
18170     SDValue IndexC = DAG.getConstant(ExtBOIdx, DL, ExtBOIdxVT);
18810   SDValue NewInsIndex = DAG.getConstant(ShufOp0Index, SDLoc(Shuf),
19227             SDValue ZeroIdx = DAG.getConstant(0, SDLoc(N), IdxTy);
19333         NewIdx = DAG.getConstant(InsIdx * Scale, DL, IdxVT);
19338           NewIdx = DAG.getConstant(InsIdx / Scale, DL, IdxVT);
19421         DAG.getConstant(0, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
19513     SDValue Zero = DAG.getConstant(0, DL, ClearVT);
19557       DAG.getConstant(Index0, DL, TLI.getVectorIdxTy(DAG.getDataLayout()));
19940     SDValue ShiftAmt = DAG.getConstant(ShCt, DL, ShiftAmtTy);
19955   SDValue ShiftAmt = DAG.getConstant(XType.getSizeInBits() - 1, DL, ShiftAmtTy);
20078         DAG.getConstant(AndMask.countLeadingZeros(), SDLoc(AndLHS),
20085         DAG.getConstant(AndMask.getBitWidth() - 1, SDLoc(Shl),
20133                        DAG.getConstant(N2C->getAPIntValue().logBase2(),
20252   SDValue Base = DAG.getConstant(EltBits - 1, DL, VT);
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
  470                           DAG.getConstant(4, dl, Ptr.getValueType()));
  581                         DAG.getConstant(IncrementSize, dl,
  585           DAG.getConstant(RoundWidth, dl,
  597           DAG.getConstant(ExtraWidth, dl,
  605                         DAG.getConstant(IncrementSize, dl,
  797                          DAG.getConstant(IncrementSize, dl,
  812           DAG.getConstant(RoundWidth, dl,
  828                          DAG.getConstant(IncrementSize, dl,
  843           DAG.getConstant(ExtraWidth, dl,
 1410     SDValue Idx = DAG.getConstant(Offset, dl, FIPtr.getValueType());
 1475                       DAG.getConstant(ByteOffset, DL, StackPtr.getValueType()));
 1523                                 DAG.getConstant(0, DL, IntVT), ISD::SETNE);
 1543     SDValue ShiftCnst = DAG.getConstant(ShiftAmount, DL, ShiftVT);
 1546     SDValue ShiftCnst = DAG.getConstant(-ShiftAmount, DL, ShiftVT);
 1604                        DAG.getConstant(-(uint64_t)Align, dl, VT));
 2362     SDValue WordOff = DAG.getConstant(sizeof(int), dl,
 2375       SDValue SignBit = DAG.getConstant(0x80000000u, dl, MVT::i32);
 2384     SDValue InitialHi = DAG.getConstant(0x43300000u, dl, MVT::i32);
 2408                                  DAG.getConstant(0, dl, SrcVT), ISD::SETLT);
 2563     Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Tmp2, DAG.getConstant(4, dl, SHVT));
 2564     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Tmp3, DAG.getConstant(4, dl, SHVT));
 2570     Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Tmp2, DAG.getConstant(2, dl, SHVT));
 2571     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Tmp3, DAG.getConstant(2, dl, SHVT));
 2577     Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Tmp2, DAG.getConstant(1, dl, SHVT));
 2578     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Tmp3, DAG.getConstant(1, dl, SHVT));
 2583   Tmp = DAG.getConstant(0, dl, VT);
 2587           DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(J - I, dl, SHVT));
 2590           DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(I - J, dl, SHVT));
 2610     return DAG.getNode(ISD::ROTL, dl, VT, Op, DAG.getConstant(8, dl, SHVT));
 2612     Tmp4 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, dl, SHVT));
 2613     Tmp3 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, dl, SHVT));
 2614     Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, dl, SHVT));
 2615     Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, dl, SHVT));
 2617                        DAG.getConstant(0xFF0000, dl, VT));
 2618     Tmp2 = DAG.getNode(ISD::AND, dl, VT, Tmp2, DAG.getConstant(0xFF00, dl, VT));
 2623     Tmp8 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(56, dl, SHVT));
 2624     Tmp7 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(40, dl, SHVT));
 2625     Tmp6 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(24, dl, SHVT));
 2626     Tmp5 = DAG.getNode(ISD::SHL, dl, VT, Op, DAG.getConstant(8, dl, SHVT));
 2627     Tmp4 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(8, dl, SHVT));
 2628     Tmp3 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(24, dl, SHVT));
 2629     Tmp2 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(40, dl, SHVT));
 2630     Tmp1 = DAG.getNode(ISD::SRL, dl, VT, Op, DAG.getConstant(56, dl, SHVT));
 2632                        DAG.getConstant(255ULL<<48, dl, VT));
 2634                        DAG.getConstant(255ULL<<40, dl, VT));
 2636                        DAG.getConstant(255ULL<<32, dl, VT));
 2638                        DAG.getConstant(255ULL<<24, dl, VT));
 2640                        DAG.getConstant(255ULL<<16, dl, VT));
 2642                        DAG.getConstant(255ULL<<8 , dl, VT));
 2687     Results.push_back(DAG.getConstant(0, dl, Node->getValueType(0)));
 2699         DAG.getConstant(0, dl, TLI.getPointerTy(DAG.getDataLayout())));
 2705     Results.push_back(DAG.getConstant(1, dl, Node->getValueType(0)));
 2720                    DAG.getConstant(0, dl, Node->getValueType(0)));
 2726     Results.push_back(DAG.getConstant(0, dl, MVT::i32));
 2731     SDValue Zero = DAG.getConstant(0, dl, Node->getValueType(0));
 2807       Results.push_back(DAG.getConstant(0, dl, VT));
 2865       SDValue One = DAG.getConstant(1, dl, VT);
 2867       SDValue Zero = DAG.getConstant(0, dl, VT);
 2878     SDValue ShiftCst = DAG.getConstant(BitsDiff, dl, ShiftAmountTy);
 3016             DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout()))));
 3020             DAG.getConstant(Idx - NumElems, dl,
 3035                          DAG.getConstant(OpTy.getSizeInBits() / 2, dl,
 3071     Results.push_back(DAG.getConstant(0, dl, Node->getValueType(0)));
 3192     Tmp1 = DAG.getNode(ISD::ADD, dl, VT, Tmp1, DAG.getConstant(1, dl, VT));
 3265         SDValue Shift = DAG.getConstant(
 3314           DAG.getConstant(HalfType.getSizeInBits(), dl,
 3371     SDValue Zero = DAG.getConstant(0, dl, VT);
 3416         DAG.getConstant(PairTy.getSizeInBits() / 2, dl,
 3431                              DAG.getConstant(0, dl, Tmp1.getValueType()),
 3455           DAG.getConstant(llvm::Log2_32(EntrySize), dl, Index.getValueType()));
 3458                           DAG.getConstant(EntrySize, dl, Index.getValueType()));
 3498                            DAG.getConstant(1, dl, Tmp2.getValueType()));
 3501                          DAG.getConstant(0, dl, Tmp3.getValueType()),
 3543                        DAG.getConstant(TrueValue, dl, VT),
 3544                        DAG.getConstant(0, dl, VT),
 3615         Tmp2 = DAG.getConstant(0, dl, Tmp1.getValueType());
 3644       Tmp3 = DAG.getConstant(0, dl, Tmp2.getValueType());
 3671           DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3674           DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4161                           DAG.getConstant(NVT.getSizeInBits() -
 4173         DAG.getConstant(DiffBits, dl,
 4273         DAG.getConstant(OriginalSize, dl, TLI.getScalarShiftAmountTy(DL, NVT)));
 4460     SDValue Factor = DAG.getConstant(NewEltsPerOldElt, SL, IdxVT);
 4467       SDValue IdxOffset = DAG.getConstant(I, SL, IdxVT);
 4508     SDValue Factor = DAG.getConstant(NewEltsPerOldElt, SDLoc(), IdxVT);
 4516       SDValue IdxOffset = DAG.getConstant(I, SL, IdxVT);
lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
  271       ISD::SHL, dl, RVT, DAG.getConstant(1, dl, RVT),
  272       DAG.getConstant(RSize - 1, dl,
  281                     DAG.getConstant(SizeDiff, dl,
  289                     DAG.getConstant(-SizeDiff, dl,
  296       ISD::SHL, dl, LVT, DAG.getConstant(1, dl, LVT),
  297       DAG.getConstant(LSize - 1, dl,
  299   Mask = DAG.getNode(ISD::SUB, dl, LVT, Mask, DAG.getConstant(1, dl, LVT));
  927     NewRHS = DAG.getConstant(0, SDLoc(N), NewLHS.getValueType());
  983     NewRHS = DAG.getConstant(0, SDLoc(N), NewLHS.getValueType());
 1612   Lo = DAG.getSelectCC(dl, Src, DAG.getConstant(0, dl, SrcVT),
 1716     NewRHS = DAG.getConstant(0, SDLoc(N), NewLHS.getValueType());
 1776     NewRHS = DAG.getConstant(0, SDLoc(N), NewLHS.getValueType());
 2178                           DAG.getConstant(IdxVal - LoElts, DL,
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp
  357                              DAG.getConstant(0, dl, IdxTy));
  390                      DAG.getConstant(DiffBits, dl, ShiftVT));
  403                      DAG.getConstant(DiffBits, dl, ShiftVT));
  439       DAG.getConstant(NVT.getScalarSizeInBits() - OVT.getScalarSizeInBits(), dl,
  690     SDValue ShiftAmount = DAG.getConstant(SHLAmount, dl, SHVT);
  754                               DAG.getConstant(DiffSize, dl, ShiftTy));
  759                        DAG.getConstant(DiffSize, dl, ShiftTy));
  957     SDValue ZeroIdx = DAG.getConstant(0, dl, IdxTy);
 1063                              DAG.getConstant(Shift, DL, ShiftTy));
 1065                             DAG.getConstant(0, DL, Hi.getValueType()),
 1117                        DAG.getConstant(i * RegVT.getSizeInBits(), dl,
 1342                    DAG.getConstant(OVT.getSizeInBits(), dl,
 1846       Lo = Hi = DAG.getConstant(0, DL, NVT);
 1848       Lo = DAG.getConstant(0, DL, NVT);
 1852       Lo = DAG.getConstant(0, DL, NVT);
 1867       Lo = Hi = DAG.getConstant(0, DL, NVT);
 1871       Hi = DAG.getConstant(0, DL, NVT);
 1874       Hi = DAG.getConstant(0, DL, NVT);
 1889                           DAG.getConstant(NVTBits - 1, DL, ShTy));
 1894                      DAG.getConstant(NVTBits - 1, DL, ShTy));
 1898                      DAG.getConstant(NVTBits - 1, DL, ShTy));
 1945       Lo = DAG.getConstant(0, dl, NVT);              // Low part is zero.
 1949       Hi = DAG.getConstant(0, dl, NVT);              // Hi part is zero.
 1954                        DAG.getConstant(NVTBits - 1, dl, ShTy));
 1967                                DAG.getConstant(NVTBits - 1, dl, ShTy));
 1983     SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, dl, ShTy));
 2014   SDValue NVBitsNode = DAG.getConstant(NVTBits, dl, ShTy);
 2020                                 Amt, DAG.getConstant(0, dl, ShTy),
 2034     LoL = DAG.getConstant(0, dl, NVT);                    // Lo part is zero.
 2051     HiL = DAG.getConstant(0, dl, NVT);                    // Hi part is zero.
 2067                       DAG.getConstant(NVTBits - 1, dl, ShTy));
 2201       OVF = DAG.getNode(ISD::AND, dl, OvfVT, DAG.getConstant(1, dl, OvfVT), OVF);
 2227                                    DAG.getConstant(1, dl, NVT),
 2228                                    DAG.getConstant(0, dl, NVT));
 2232                                    DAG.getConstant(1, dl, NVT), Carry1);
 2245       Borrow = DAG.getSelect(dl, NVT, Cmp, DAG.getConstant(1, dl, NVT),
 2246                              DAG.getConstant(0, dl, NVT));
 2416                      DAG.getConstant(NVTBits - 1, dl,
 2437     Hi = DAG.getConstant(0, dl, NVT);
 2478                             DAG.getConstant(0, dl, VT), N0);
 2485                                  DAG.getConstant(0, dl, NVT), Hi, ISD::SETGT);
 2498                                    DAG.getConstant(0, dl, NVT), ISD::SETNE);
 2505                                  DAG.getConstant(NVT.getSizeInBits(), dl,
 2507   Hi = DAG.getConstant(0, dl, NVT);
 2518   Hi = DAG.getConstant(0, dl, NVT);
 2529                                    DAG.getConstant(0, dl, NVT), ISD::SETNE);
 2536                                  DAG.getConstant(NVT.getSizeInBits(), dl,
 2538   Hi = DAG.getConstant(0, dl, NVT);
 2551                    DAG.getConstant(NBitWidth - 1, dl, ShiftAmtTy));
 2678                        DAG.getConstant(LoSize - 1, dl,
 2682       Hi = DAG.getConstant(0, dl, NVT);
 2700                       DAG.getConstant(IncrementSize, dl, Ptr.getValueType()));
 2725                       DAG.getConstant(IncrementSize, dl, Ptr.getValueType()));
 2742                       DAG.getConstant(ExcessBits, dl,
 2747                        DAG.getConstant(NVT.getSizeInBits() - ExcessBits, dl,
 2814     SDValue Shift = DAG.getConstant(HalfBits, dl, ShiftAmtTy);
 2899         SDValue Zero = DAG.getConstant(0, dl, VT);
 2959     SDValue ShiftAmount = DAG.getConstant(Scale % NVTSize, dl, ShiftTy);
 2993   SDValue NVTZero = DAG.getConstant(0, dl, NVT);
 2994   SDValue NVTNeg1 = DAG.getConstant(-1, dl, NVT);
 3001                                        DAG.getConstant(Scale, dl, ShiftTy));
 3010                                        DAG.getConstant(Scale - NVTSize, dl,
 3108   SDValue Zero = DAG.getConstant(0, dl, LHS.getValueType());
 3271         DAG.getConstant(LoSize - 1, dl, TLI.getPointerTy(DAG.getDataLayout())));
 3304                      DAG.getConstant(Hi.getValueSizeInBits() - 1, dl,
 3351                    DAG.getConstant(NVT.getSizeInBits(), dl,
 3383     SDValue HalfZero = DAG.getConstant(0, dl, HalfVT);
 3432       DAG.getStore(DAG.getEntryNode(), dl, DAG.getConstant(0, dl, PtrVT), Temp,
 3468                              DAG.getConstant(0, dl, PtrVT),
 3536     Hi = DAG.getConstant(0, dl, NVT);   // The high part is just a zero.
 3560   SDValue Zero = DAG.getConstant(0, dl, VT);
 3668     NewRHS = DAG.getConstant(0, dl, NewLHS.getValueType());
 3798     NewRHS = DAG.getConstant(0, SDLoc(N), NewLHS.getValueType());
 3816     NewRHS = DAG.getConstant(0, SDLoc(N), NewLHS.getValueType());
 3949                      DAG.getConstant(NVT.getSizeInBits() - ExcessBits, dl,
 3954                     DAG.getConstant(ExcessBits, dl,
 4019                                    DAG.getConstant(0, dl, Hi.getValueType()),
 4091       BaseIdx, DAG.getConstant(i, dl, BaseIdx.getValueType()));
 4208           DAG.getConstant(j, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4318           DAG.getConstant(i, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp
  973                    DAG.getConstant(LVT.getSizeInBits(), dlHi, ShiftAmtVT));
 1067                    DAG.getConstant(LoVT.getSizeInBits(), dl, ShiftAmountTy));
lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp
  124             DAG.getConstant(i, dl, TLI.getVectorIdxTy(DAG.getDataLayout()))));
  173                          DAG.getConstant(IncrementSize, dl,
  238                     DAG.getConstant(1, dl, Idx.getValueType()));
  266                     DAG.getConstant(IncrementSize, dl, Ptr.getValueType()));
  435                     DAG.getConstant(1, dl, Idx.getValueType()));
lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp
  703       SDValue ShAmt = DAG.getConstant(
  712           ShAmt = DAG.getConstant(
  733             DAG.getConstant(WideBits - SrcEltBits, dl,
  921           DAG.getConstant(0, DL, BitTy));
  955   SDValue ShiftSz = DAG.getConstant(BW - OrigBW, DL, VT);
  982         DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 1015   SDValue ShiftAmount = DAG.getConstant(EltWidth - SrcEltWidth, DL, VT);
 1042         DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 1046   SDValue Zero = DAG.getConstant(0, DL, SrcVT);
 1221   SDValue HalfWord = DAG.getConstant(BW / 2, DL, VT);
 1227   SDValue HalfWordMask = DAG.getConstant(HWMask, DL, VT);
 1382     SDValue Idx = DAG.getConstant(i, dl,
 1426         DAG.getConstant(i, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 1429         DAG.getConstant(i, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 1437                            DAG.getConstant(0, dl, EltVT));
lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
  394         DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
  420         DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
  458         DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
  492                            Cond, DAG.getConstant(1, SDLoc(N), CondVT));
  560         DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
  563         DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 1160                    DAG.getConstant(IdxVal + LoVT.getVectorNumElements(), dl,
 1211                   DAG.getConstant(IncrementSize, dl, StackPtr.getValueType()));
 1379                     DAG.getConstant(i, dl, TLI.getVectorIdxTy(
 1464                       DAG.getConstant(IdxVal - LoNumElts, dl,
 1510                          DAG.getConstant(IncrementSize, dl,
 1911             DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout()))));
 2215                        DAG.getConstant(IdxVal - LoElts, dl,
 2236                                   DAG.getConstant(IdxVal - LoElts, SDLoc(N),
 2540           DAG.getConstant(i, DL, TLI.getVectorIdxTy(DAG.getDataLayout()))));
 2978             DAG.getConstant(i, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3062           DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3065           DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3079             DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3082             DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3152             DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3179               DAG.getConstant(Idx, dl, 
 3227     SDValue Zero = DAG.getConstant(
 3247     SDValue Zero = DAG.getConstant(
 3313           DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3330         DAG.getConstant(i, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3367         DAG.getConstant(i, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3407       DAG.getConstant(i, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3653           DAG.getConstant(j, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3693                     DAG.getConstant(IdxVal + i, dl,
 3877     SDValue ZeroIdx = DAG.getConstant(0, SDLoc(Mask), IdxTy);
 4242               DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4246               DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4309         DAG.getConstant(0, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4322           DAG.getConstant(i, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4334               DAG.getConstant(i, dl, TLI.getVectorIdxTy(DAG.getDataLayout()))));
 4357           DAG.getConstant(0, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4374             DAG.getConstant(0, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4417           DAG.getConstant(j, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4575       DAG.getConstant(0, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4596     NeutralElem = DAG.getConstant(0, dl, ElemVT);
 4599     NeutralElem = DAG.getConstant(1, dl, ElemVT);
 4634         DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4655       DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4755         DAG.getConstant(Idx++, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 4992             DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 5012             DAG.getConstant(Idx++, dl,
 5056       DAG.getConstant(0, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 5065         DAG.getConstant(0, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 5093     SDValue FillVal = FillWithZeroes ? DAG.getConstant(0, dl, InVT) :
 5105         DAG.getConstant(0, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 5115         DAG.getConstant(Idx, dl, TLI.getVectorIdxTy(DAG.getDataLayout())));
 5117   SDValue FillVal = FillWithZeroes ? DAG.getConstant(0, dl, EltVT) :
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
 1171     return getConstant(0, DL, VT);
 1176     return getConstant(1, DL, VT);
 1292   return getConstant(Val, DL, TLI->getPointerTy(getDataLayout()), isTarget);
 1298   return getConstant(Val, DL, ShiftVT);
 1911                      getConstant(MA->value() - 1, dl, VAList.getValueType()));
 1915                 getConstant(-(int64_t)MA->value(), dl, VAList.getValueType()));
 1920                  getConstant(getDataLayout().getTypeAllocSize(
 4330       return getConstant(Val.countPopulation(), DL, VT, C->isTargetOpcode(),
 4334       return getConstant(Val.countLeadingZeros(), DL, VT, C->isTargetOpcode(),
 4338       return getConstant(Val.countTrailingZeros(), DL, VT, C->isTargetOpcode(),
 4403         return getConstant((uint16_t)V.bitcastToAPInt().getZExtValue(), DL, VT);
 4405         return getConstant((uint32_t)V.bitcastToAPInt().getZExtValue(), DL, VT);
 4407         return getConstant(V.bitcastToAPInt().getZExtValue(), DL, VT);
 4513       return getConstant(0, DL, VT);
 4532       return getConstant(0, DL, VT);
 5250                      getConstant(N2C->getZExtValue() % Factor, DL,
 5384         return getConstant(0, DL, VT);    // fold op(undef, arg2) -> 0
 5396         return getConstant(0, DL, VT);
 5409       return getConstant(0, DL, VT);  // fold op(arg1, undef) -> 0
 5675       return DAG.getConstant(0, dl, VT);
 5682                          DAG.getConstant(0, dl,
 5714   return getNode(ISD::ADD, DL, VT, Base, getConstant(Offset, DL, VT));
 7134     return getConstant(0, SDLoc(X.getNode()), X.getValueType());
 9058         getConstant(0, SDLoc(Op), TLI->getVectorIdxTy(getDataLayout())));
 9138                     getConstant(i, dl, TLI->getVectorIdxTy(getDataLayout())));
 9214                   getConstant(0, dl, OvEltVT));
 9317                getConstant(0, DL, TLI->getVectorIdxTy(getDataLayout())));
 9319                getConstant(LoVT.getVectorNumElements(), DL,
 9330                  getConstant(0, DL, TLI->getVectorIdxTy(getDataLayout())));
 9345                            Op, getConstant(i, SL, IdxTy)));
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
  259                         DAG.getConstant(Lo.getValueSizeInBits(), DL,
  439           DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
  473            DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
  687             DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
  743                            DAG.getConstant(i * IntermediateNumElts, DL, IdxVT));
  747           DAG.getConstant(i, DL, IdxVT));
  853         Parts[i] = DAG.getConstant(0, dl, RegisterVT);
 1454       return DAG.getConstant(0, getCurSDLoc(),
 1520           Constants[i] = DAG.getConstant(0, getCurSDLoc(), EltVT);
 1547         Op = DAG.getConstant(0, getCurSDLoc(), EltVT);
 2339       SDValue True = DAG.getConstant(1, dl, CondLHS.getValueType());
 2385     SDValue True = DAG.getConstant(1, dl, Cond.getValueType());
 2576                              Sub, DAG.getConstant(0, dl, VT), ISD::SETNE);
 2697         ShiftOp, DAG.getConstant(countTrailingZeros(B.Mask), dl, VT),
 2703         ShiftOp, DAG.getConstant(countTrailingOnes(B.Mask), dl, VT),
 2708                                     DAG.getConstant(1, dl, VT), ShiftOp);
 2712                                 VT, SwitchVal, DAG.getConstant(B.Mask, dl, VT));
 2715         AndOp, DAG.getConstant(0, dl, VT), ISD::SETNE);
 2893     Ops[0] = DAG.getConstant(0, dl, TLI.getPointerTy(DAG.getDataLayout()));
 3553                                    DAG.getConstant(0, DL, 
 3650           DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
 3696               DAG.getConstant(StartIdx[Input], DL,
 3731                         EltVT, Src, DAG.getConstant(Idx, DL, IdxVT));
 3872                         DAG.getConstant(Offset, dl, N.getValueType()), Flags);
 3925                              DAG.getConstant(Amt, dl, IdxN.getValueType()));
 3927           SDValue Scale = DAG.getConstant(ElementSize.getZExtValue(), dl,
 3967                           DAG.getConstant(TySize, dl, IntPtr));
 3983                           DAG.getConstant(StackAlign - 1, dl, IntPtr), Flags);
 3988                   DAG.getConstant(~(uint64_t)(StackAlign - 1), dl, IntPtr));
 3990   SDValue Ops[] = {getRoot(), AllocSize, DAG.getConstant(Align, dl, IntPtr)};
 4089                             DAG.getConstant(Offsets[i], dl, PtrVT),
 4250                               DAG.getConstant(Offsets[i], dl, PtrVT), Flags);
 4414     Base = DAG.getConstant(0, sdl, TLI.getPointerTy(DAG.getDataLayout()));
 4535     Base = DAG.getConstant(0, sdl, TLI.getPointerTy(DAG.getDataLayout()));
 4641   Ops[1] = DAG.getConstant((unsigned)I.getOrdering(), dl,
 4643   Ops[2] = DAG.getConstant(I.getSyncScopeID(), dl,
 4866                            DAG.getConstant(0x007fffff, dl, MVT::i32));
 4868                            DAG.getConstant(0x3f800000, dl, MVT::i32));
 4880                            DAG.getConstant(0x7f800000, dl, MVT::i32));
 4883       DAG.getConstant(23, dl, TLI.getPointerTy(DAG.getDataLayout())));
 4885                            DAG.getConstant(127, dl, MVT::i32));
 4910       DAG.getConstant(23, dl, DAG.getTargetLoweringInfo().getPointerTy(
 5923     Res = DAG.getConstant(TypeID, sdl, MVT::i32);
 6231     SDValue BitWidthC = DAG.getConstant(VT.getScalarSizeInBits(), sdl, VT);
 6232     SDValue Zero = DAG.getConstant(0, sdl, VT);
 7267     setValue(&I, DAG.getConstant(0, getCurSDLoc(), CallVT));
 9311                                     CLI.DAG.getConstant(Offsets[i], CLI.DL,
lib/CodeGen/SelectionDAG/StatepointLowering.cpp
  861     ActualCallee = DAG.getConstant(0, getCurSDLoc(), TLI.getPointerTy(DL, AS));
lib/CodeGen/SelectionDAG/TargetLowering.cpp
  386   NewRHS = DAG.getConstant(0, dl, RetVT);
 1071       return TLO.CombineTo(Op, TLO.DAG.getConstant(0, dl, VT));
 1303               SDValue NewSA = TLO.DAG.getConstant(Diff, dl, Op1.getValueType());
 1334                               TLO.DAG.getConstant(ShAmt, dl, ShTy));
 1352               SDValue NewSA = TLO.DAG.getConstant(ShAmt - InnerShAmt, dl,
 1409               SDValue NewSA = TLO.DAG.getConstant(Diff, dl, ShiftVT);
 1482             TLO.DAG.getConstant(BitWidth - 1 - Log2, dl, Op1.getValueType());
 1560             TLO.DAG.getConstant(BitWidth - ExVTBits, dl, ShiftAmtTy);
 1764           Shift = TLO.DAG.getConstant(ShVal, dl, getShiftAmountTy(VT, DL));
 1849         SDValue ShAmt = TLO.DAG.getConstant(ShVal, dl, VT);
 2469         return TLO.CombineTo(Op, TLO.DAG.getConstant(0, SDLoc(Op), VT));
 2546         return TLO.CombineTo(Op, TLO.DAG.getConstant(0, SDLoc(Op), VT));
 2805   SDValue Zero = DAG.getConstant(0, DL, OpVT);
 2926   SDValue ShiftAmt = DAG.getConstant(MaskedBits, DL, XVT);
 3024     return DAG.getSetCC(DL, VT, Y, DAG.getConstant(0, DL, OpVT), Cond);
 3032     return DAG.getSetCC(DL, VT, X, DAG.getConstant(0, DL, OpVT), Cond);
 3041   SDValue One = DAG.getConstant(1, DL, ShiftVT);
 3101         SDValue Zero = DAG.getConstant(0, dl, N0.getValueType());
 3125         return DAG.getSetCC(dl, VT, And, DAG.getConstant(0, dl, CTVT), CC);
 3133         SDValue Zero = DAG.getConstant(0, dl, CTVT);
 3195             return DAG.getSetCC(dl, VT, Trunc, DAG.getConstant(0, dl, MVT::i1),
 3279                               DAG.getConstant(bestOffset, dl, PtrType));
 3288                               DAG.getConstant(0LL, dl, newVT), Cond);
 3305           return DAG.getConstant(0, dl, VT);
 3309           return DAG.getConstant(1, dl, VT);
 3313           return DAG.getConstant(C1.isNegative(), dl, VT);
 3317           return DAG.getConstant(C1.isNonNegative(), dl, VT);
 3358         return DAG.getConstant(Cond == ISD::SETNE, dl, VT);
 3449                           DAG.getConstant(1, dl, VT));
 3453                         DAG.getConstant(1, dl, VT));
 3456                               DAG.getConstant(0, dl, Op0.getValueType()),
 3462                               DAG.getConstant(0, dl, Op0.getValueType()),
 3592                             DAG.getConstant(0, dl, N1.getValueType()),
 3627                                            DAG.getConstant(ShCt, dl, ShiftTy)));
 3637                                            DAG.getConstant(ShCt, dl, ShiftTy)));
 3657                                         DAG.getConstant(ShiftBits, dl,
 3688                                       DAG.getConstant(ShiftBits, dl, ShiftTy));
 4589     Shifts.push_back(DAG.getConstant(Shift, dl, ShSVT));
 4680     Factors.push_back(DAG.getConstant(NumeratorFactor, dl, SVT));
 4681     Shifts.push_back(DAG.getConstant(magics.s, dl, ShSVT));
 4682     ShiftMasks.push_back(DAG.getConstant(ShiftMask, dl, SVT));
 4732   SDValue SignShift = DAG.getConstant(EltBits - 1, dl, ShVT);
 4793     PreShifts.push_back(DAG.getConstant(PreShift, dl, ShSVT));
 4799     PostShifts.push_back(DAG.getConstant(PostShift, dl, ShSVT));
 4857       NPQ = DAG.getNode(ISD::SRL, dl, VT, NPQ, DAG.getConstant(1, dl, ShVT));
 4868   SDValue One = DAG.getConstant(1, dl, VT);
 5034                                 DAG.getConstant(0, DL, ShSVT));
 5237                                 DAG.getConstant(0, DL, SVT));
 5241                                 DAG.getConstant(0, DL, ShSVT));
 5651         SDValue Zero = DAG.getConstant(0, dl, HiLoVT);
 5678   SDValue Shift = DAG.getConstant(ShiftAmount, dl, ShiftAmountTy);
 5725   SDValue Zero = DAG.getConstant(0, dl, HiLoVT);
 5735                        Merge(Lo, Hi), DAG.getConstant(0, dl, BoolType));
 5806   SDValue BitWidthC = DAG.getConstant(EltSizeInBits, DL, ShVT);
 5807   SDValue Zero = DAG.getConstant(0, DL, ShVT);
 5811     SDValue Mask = DAG.getConstant(EltSizeInBits - 1, DL, ShVT);
 5844   SDValue BitWidthC = DAG.getConstant(EltSizeInBits, DL, ShVT);
 5869   SDValue BitWidthMinusOneC = DAG.getConstant(EltSizeInBits - 1, DL, ShVT);
 5904   SDValue ExponentMask = DAG.getConstant(0x7F800000, dl, IntVT);
 5905   SDValue ExponentLoBit = DAG.getConstant(23, dl, IntVT);
 5906   SDValue Bias = DAG.getConstant(127, dl, IntVT);
 5908   SDValue SignLowBit = DAG.getConstant(SrcEltBits - 1, dl, IntVT);
 5909   SDValue MantissaMask = DAG.getConstant(0x007FFFFF, dl, IntVT);
 5925                           DAG.getConstant(0x00800000, dl, IntVT));
 5944   Result = DAG.getSelectCC(dl, Exponent, DAG.getConstant(0, dl, IntVT),
 5945                            DAG.getConstant(0, dl, DstVT), Ret, ISD::SETLT);
 6007     SDValue Ofs = DAG.getSelect(dl, DstVT, Sel, DAG.getConstant(0, dl, DstVT),
 6061     SDValue ShiftConst = DAG.getConstant(1, dl, ShiftVT);
 6063     SDValue AndConst = DAG.getConstant(1, dl, SrcVT);
 6078         dl, SetCCVT, Src, DAG.getConstant(0, dl, SrcVT), ISD::SETLT);
 6098     SDValue TwoP52 = DAG.getConstant(UINT64_C(0x4330000000000000), dl, SrcVT);
 6101     SDValue TwoP84 = DAG.getConstant(UINT64_C(0x4530000000000000), dl, SrcVT);
 6102     SDValue LoMask = DAG.getConstant(UINT64_C(0x00000000FFFFFFFF), dl, SrcVT);
 6103     SDValue HiShift = DAG.getConstant(32, dl, ShiftVT);
 6195                                            DAG.getConstant(1, dl, ShVT)),
 6201                                            DAG.getConstant(2, dl, ShVT)),
 6207                                            DAG.getConstant(4, dl, ShVT))),
 6213                     DAG.getConstant(Len - 8, dl, ShVT));
 6239     SDValue Zero = DAG.getConstant(0, dl, VT);
 6242                          DAG.getConstant(NumBitsPerElt, dl, VT), CTLZ);
 6263     SDValue Tmp = DAG.getConstant(1ULL << i, dl, ShVT);
 6291     SDValue Zero = DAG.getConstant(0, dl, VT);
 6294                          DAG.getConstant(NumBitsPerElt, dl, VT), CTTZ);
 6313       DAG.getNode(ISD::SUB, dl, VT, Op, DAG.getConstant(1, dl, VT)));
 6318         DAG.getNode(ISD::SUB, dl, VT, DAG.getConstant(NumBitsPerElt, dl, VT),
 6342                   DAG.getConstant(VT.getScalarSizeInBits() - 1, dl, ShVT));
 6415     SDValue CurrVal = DAG.getConstant(0, SL, IntVT);
 6419                                 DAG.getConstant(Idx, SL, IdxVT));
 6425           DAG.getConstant(ShiftIntoIdx * MemSclVT.getSizeInBits(), SL, IntVT);
 6444                               DAG.getConstant(Idx, SL, IdxVT));
 6512     SDValue PtrIncrement = DAG.getConstant(RegBytes, dl, PtrVT);
 6513     SDValue StackPtrIncrement = DAG.getConstant(RegBytes, dl, StackPtrVT);
 6604       DAG.getConstant(NumBits, dl, getShiftAmountTy(Hi.getValueType(),
 6666     SDValue PtrIncrement = DAG.getConstant(RegBytes, dl, PtrVT);
 6667     SDValue StackPtrIncrement = DAG.getConstant(RegBytes, dl, StackPtrVT);
 6717   SDValue ShiftAmount = DAG.getConstant(
 6764     SDValue Scale = DAG.getConstant(DataVT.getScalarSizeInBits() / 8, DL,
 6768     Increment = DAG.getConstant(DataVT.getStoreSize(), DL, AddrVT);
 6790                      DAG.getConstant(NElts - 1, dl, IdxVT));
 6812                       DAG.getConstant(EltSize, dl, IdxVT));
 6875                                 DAG.getConstant(Log2b, dl, MVT::i32));
 6929   SDValue Zero = DAG.getConstant(0, dl, VT);
 6992       SDValue Zero = DAG.getConstant(0, dl, VT);
 7047                                DAG.getConstant(Scale, dl, ShiftTy));
 7075                                DAG.getConstant(VTSize - 1, dl, ShiftTy));
 7079     SDValue Zero = DAG.getConstant(0, dl, VT);
 7112     SDValue CarryIn = DAG.getConstant(0, dl, Node->getValueType(1));
 7154   SDValue Zero = DAG.getConstant(0, dl, LHS.getValueType());
 7188       SDValue ShiftAmt = DAG.getConstant(C.logBase2(), dl, ShiftAmtTy);
 7220     SDValue ShiftAmt = DAG.getConstant(VT.getScalarSizeInBits(), dl,
 7251                       DAG.getConstant(LoSize - 1, dl,
 7255                       DAG.getConstant(LoSize - 1, dl,
 7258         HiLHS = DAG.getConstant(0, dl, VT);
 7259         HiRHS = DAG.getConstant(0, dl, VT);
 7295     SDValue ShiftAmt = DAG.getConstant(
 7302                             DAG.getConstant(0, dl, VT), ISD::SETNE);
lib/Target/AArch64/AArch64ISelDAGToDAG.cpp
  353   return SelectArithImmed(CurDAG->getConstant(Immed, SDLoc(N), MVT::i32), Val,
lib/Target/AArch64/AArch64ISelLowering.cpp
  995                           TLO.DAG.getConstant(NewImm, DL, VT));
 1727   SDValue Condition = DAG.getConstant(Predicate, DL, MVT_CC);
 1730   SDValue NZCVOp = DAG.getConstant(NZCV, DL, MVT::i32);
 1989           RHS = DAG.getConstant(C, dl, VT);
 1999           RHS = DAG.getConstant(C, dl, VT);
 2010           RHS = DAG.getConstant(C, dl, VT);
 2021           RHS = DAG.getConstant(C, dl, VT);
 2078         Cmp = emitComparison(SExt, DAG.getConstant(ValueofRHS, dl,
 2097   AArch64cc = DAG.getConstant(AArch64CC, dl, MVT_CC);
 2144                                 DAG.getConstant(0, DL, MVT::i64));
 2157                                         DAG.getConstant(32, DL, MVT::i64));
 2160                                         DAG.getConstant(31, DL, MVT::i64));
 2173                                         DAG.getConstant(32, DL, MVT::i64));
 2177                         DAG.getConstant(0, DL, MVT::i64),
 2188                                       DAG.getConstant(63, DL, MVT::i64));
 2199                       DAG.getConstant(0, DL, MVT::i64),
 2249     SDValue TVal = DAG.getConstant(1, dl, MVT::i32);
 2250     SDValue FVal = DAG.getConstant(0, dl, MVT::i32);
 2254     SDValue CCVal = DAG.getConstant(getInvertedCondCode(CC), dl, MVT::i32);
 2303                        DAG.getConstant(-1ULL, dl, Other.getValueType()));
 2360   SDValue TVal = DAG.getConstant(1, dl, MVT::i32);
 2361   SDValue FVal = DAG.getConstant(0, dl, MVT::i32);
 2366   SDValue CCVal = DAG.getConstant(getInvertedCondCode(CC), dl, MVT::i32);
 2402                      DAG.getConstant(PrfOp, DL, MVT::i32), Op.getOperand(1));
 2739                                 DAG.getConstant(Intrinsic::aarch64_get_fpcr, dl,
 2743                                   DAG.getConstant(1U << 22, dl, MVT::i32));
 2745                               DAG.getConstant(22, dl, MVT::i32));
 2747                      DAG.getConstant(3, dl, MVT::i32));
 2922                                      Trunc, DAG.getConstant(0, DL, MVT::i64));
 3252                                DAG.getConstant(32, DL, RegVT));
 3434           DAG.getNode(ISD::ADD, DL, PtrVT, FIN, DAG.getConstant(8, DL, PtrVT));
 3463                           DAG.getConstant(16, DL, PtrVT));
 3526                         DAG.getConstant(32, DL, VA.getLocVT()));
 3890                         DAG.getConstant(32, DL, VA.getLocVT()));
 3987             DAG.getConstant(Outs[i].Flags.getByValSize(), DL, MVT::i64);
 4209                         DAG.getConstant(32, DL, VA.getLocVT()));
 4637                              DAG.getConstant(3, DL, PtrVT));
 4700       RHS = DAG.getConstant(0, dl, LHS.getValueType());
 4720     SDValue CCVal = DAG.getConstant(OFCC, dl, MVT::i32);
 4745                              DAG.getConstant(Log2_64(Mask), dl, MVT::i64),
 4761                              DAG.getConstant(Log2_64(Mask), dl, MVT::i64),
 4772                            DAG.getConstant(Mask, dl, MVT::i64), Dest);
 4782                          DAG.getConstant(Mask, dl, MVT::i64), Dest);
 4799   SDValue CC1Val = DAG.getConstant(CC1, dl, MVT::i32);
 4803     SDValue CC2Val = DAG.getConstant(CC2, dl, MVT::i32);
 4862   SDValue BuildVec = DAG.getConstant(EltMask, DL, VecVT);
 4913         DAG.getConstant(Intrinsic::aarch64_neon_uaddlv, DL, MVT::i32), CtPop);
 4937         DAG.getConstant(Intrinsic::aarch64_neon_uaddlp, DL, MVT::i32), Val);
 4955   SDValue TVal = DAG.getConstant(1, dl, VT);
 4956   SDValue FVal = DAG.getConstant(0, dl, VT);
 4994     SDValue CC1Val = DAG.getConstant(CC1, dl, MVT::i32);
 5007     SDValue CC1Val = DAG.getConstant(CC1, dl, MVT::i32);
 5011     SDValue CC2Val = DAG.getConstant(CC2, dl, MVT::i32);
 5028       RHS = DAG.getConstant(0, dl, LHS.getValueType());
 5149         FVal = DAG.getConstant(0, dl, FVal.getValueType());
 5190   SDValue CC1Val = DAG.getConstant(CC1, dl, MVT::i32);
 5196     SDValue CC2Val = DAG.getConstant(CC2, dl, MVT::i32);
 5232     SDValue CCVal = DAG.getConstant(OFCC, DL, MVT::i32);
 5247     RHS = DAG.getConstant(0, DL, CCVal.getValueType());
 5367         DAG.getNode(ISD::ADD, DL, PtrVT, VAList, DAG.getConstant(8, DL, PtrVT));
 5371                         DAG.getConstant(GPRSize, DL, PtrVT));
 5383                             DAG.getConstant(16, DL, PtrVT));
 5387                         DAG.getConstant(FPRSize, DL, PtrVT));
 5396       DAG.getNode(ISD::ADD, DL, PtrVT, VAList, DAG.getConstant(24, DL, PtrVT));
 5398       Chain, DL, DAG.getConstant(-GPRSize, DL, MVT::i32), GROffsAddr,
 5403       DAG.getNode(ISD::ADD, DL, PtrVT, VAList, DAG.getConstant(28, DL, PtrVT));
 5405       Chain, DL, DAG.getConstant(-FPRSize, DL, MVT::i32), VROffsAddr,
 5435                        DAG.getConstant(VaListSize, DL, MVT::i32), PtrSize,
 5461                          DAG.getConstant(Align - 1, DL, PtrVT));
 5463                          DAG.getConstant(-(int64_t)Align, DL, PtrVT));
 5483                                DAG.getConstant(ArgSize, DL, PtrVT));
 5566   SDValue Offset = DAG.getConstant(8, DL, getPointerTy(DAG.getDataLayout()));
 5582     SDValue Offset = DAG.getConstant(8, DL, getPointerTy(DAG.getDataLayout()));
 5609                                  DAG.getConstant(VTBits, dl, MVT::i64), ShAmt);
 5614   SDValue Cmp = emitComparison(ShAmt, DAG.getConstant(0, dl, MVT::i64),
 5616   SDValue CCVal = DAG.getConstant(AArch64CC::EQ, dl, MVT::i32);
 5618       DAG.getNode(AArch64ISD::CSEL, dl, VT, DAG.getConstant(0, dl, MVT::i64),
 5622                                    DAG.getConstant(VTBits, dl, MVT::i64));
 5628   Cmp = emitComparison(ExtraShAmt, DAG.getConstant(0, dl, MVT::i64), ISD::SETGE,
 5630   CCVal = DAG.getConstant(AArch64CC::GE, dl, MVT::i32);
 5641                         DAG.getConstant(VTBits - 1, dl, MVT::i64))
 5642           : DAG.getConstant(0, dl, VT);
 5664                                  DAG.getConstant(VTBits, dl, MVT::i64), ShAmt);
 5669   SDValue Cmp = emitComparison(ShAmt, DAG.getConstant(0, dl, MVT::i64),
 5671   SDValue CCVal = DAG.getConstant(AArch64CC::EQ, dl, MVT::i32);
 5673       DAG.getNode(AArch64ISD::CSEL, dl, VT, DAG.getConstant(0, dl, MVT::i64),
 5677                                    DAG.getConstant(VTBits, dl, MVT::i64));
 5684   Cmp = emitComparison(ExtraShAmt, DAG.getConstant(0, dl, MVT::i64), ISD::SETGE,
 5686   CCVal = DAG.getConstant(AArch64CC::GE, dl, MVT::i32);
 5692   SDValue LoForBigShift = DAG.getConstant(0, dl, VT);
 6229                      V64Reg, DAG.getConstant(0, DL, MVT::i32));
 6370                       DAG.getConstant(NumSrcElts, dl, MVT::i64));
 6376                       DAG.getConstant(0, dl, MVT::i64));
 6381                       DAG.getConstant(0, dl, MVT::i64));
 6384                       DAG.getConstant(NumSrcElts, dl, MVT::i64));
 6389                                    DAG.getConstant(Imm, dl, MVT::i32));
 6736                      DAG.getConstant(0, DL, MVT::i64));
 6740                      DAG.getConstant(0, DL, MVT::i64));
 6818     SDValue Lane = DAG.getConstant(OpNum - OP_VDUP0, dl, MVT::i64);
 6826                        DAG.getConstant(Imm, dl, MVT::i32));
 6863       TBLMask.push_back(DAG.getConstant(Offset, DL, MVT::i32));
 6883         DAG.getConstant(Intrinsic::aarch64_neon_tbl1, DL, MVT::i32), V1Cst,
 6891           DAG.getConstant(Intrinsic::aarch64_neon_tbl1, DL, MVT::i32), V1Cst,
 6903           DAG.getConstant(Intrinsic::aarch64_neon_tbl2, DL, MVT::i32), V1Cst,
 6971     return DAG.getNode(Opcode, dl, VT, V1, DAG.getConstant(Lane, dl, MVT::i64));
 6988                        DAG.getConstant(Imm, dl, MVT::i32));
 6992                        DAG.getConstant(Imm, dl, MVT::i32));
 7030     SDValue DstLaneV = DAG.getConstant(Anomaly, dl, MVT::i64);
 7038     SDValue SrcLaneV = DAG.getConstant(SrcLane, dl, MVT::i64);
 7146                                 DAG.getConstant(Value, dl, MVT::i32));
 7188                           DAG.getConstant(Value, dl, MVT::i32),
 7189                           DAG.getConstant(Shift, dl, MVT::i32));
 7192                           DAG.getConstant(Value, dl, MVT::i32),
 7193                           DAG.getConstant(Shift, dl, MVT::i32));
 7228                           DAG.getConstant(Value, dl, MVT::i32),
 7229                           DAG.getConstant(Shift, dl, MVT::i32));
 7232                           DAG.getConstant(Value, dl, MVT::i32),
 7233                           DAG.getConstant(Shift, dl, MVT::i32));
 7264                                 DAG.getConstant(Value, dl, MVT::i32),
 7265                                 DAG.getConstant(Shift, dl, MVT::i32));
 7286                                 DAG.getConstant(Value, dl, MVT::i32));
 7317                                 DAG.getConstant(Value, dl, MVT::i32));
 7412                   DAG.getConstant(Intrin, DL, MVT::i32), X, Y,
 7488       Lane = DAG.getConstant(LowBits.getZExtValue(), dl, MVT::i32);
 7675                       DAG.getConstant(0, dl, MVT::i64));
 7678                       DAG.getConstant(NumElts, dl, MVT::i64));
 7753       SDValue LaneIdx = DAG.getConstant(i, dl, MVT::i64);
 7812       SDValue LaneIdx = DAG.getConstant(i, dl, MVT::i64);
 8018                          DAG.getConstant(Cnt, DL, MVT::i32));
 8020                        DAG.getConstant(Intrinsic::aarch64_neon_ushl, DL,
 8030                          DAG.getConstant(Cnt, DL, MVT::i32));
 8042                     DAG.getConstant(Opc, DL, MVT::i32), Op.getOperand(0),
 8214                      DAG.getConstant(0, DL, MVT::i64));
 8235         DAG.getConstant(Intrinsic::aarch64_neon_fmaxnmv, dl, MVT::i32),
 8242         DAG.getConstant(Intrinsic::aarch64_neon_fminnmv, dl, MVT::i32),
 8261   RHS = DAG.getNode(ISD::SUB, dl, VT, DAG.getConstant(0, dl, VT), RHS);
 8278   RHS = DAG.getNode(ISD::XOR, dl, VT, DAG.getConstant(-1ULL, dl, VT), RHS);
 8296                      DAG.getConstant(4, dl, MVT::i64));
 8308                      DAG.getConstant(4, dl, MVT::i64));
 8332                        DAG.getConstant(-(uint64_t)Align, dl, VT));
 8347                      DAG.getConstant(-(uint64_t)Align, dl, VT));
 9307         SDValue Neg = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
 9312                         N0.getOperand(0), DAG.getConstant(0, DL, VT));
 9314                            DAG.getConstant(AArch64CC::PL, DL, MVT::i32),
 9349   SDValue Zero = DAG.getConstant(0, DL, VT);
 9350   SDValue Pow2MinusOne = DAG.getConstant((1ULL << Lg2) - 1, DL, VT);
 9364       DAG.getNode(ISD::SRA, DL, VT, CSel, DAG.getConstant(Lg2, DL, MVT::i64));
 9372   return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), SRA);
 9458                                    DAG.getConstant(ShiftAmt, DL, MVT::i64));
 9467     return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Res);
 9471                        DAG.getConstant(TrailingZeroes, DL, MVT::i64));
 9626                   DAG.getConstant(IntrinsicOpcode, DL, MVT::i32),
 9627                   Op->getOperand(0), DAG.getConstant(C, DL, MVT::i32));
 9700                      DAG.getConstant(IntrinsicOpcode, DL, MVT::i32), ConvInput,
 9701                      DAG.getConstant(C, DL, MVT::i32));
 9765                      DAG.getConstant(ShiftRHS, DL, MVT::i64));
 9959     SDValue HalfIdx = DAG.getConstant(NumElements, dl, MVT::i64);
10020                        DAG.getConstant(0, dl, MVT::i64));
10145                      DAG.getConstant(NumElems, dl, MVT::i64));
10270     CCVal = DAG.getConstant(
10281   LHS = DAG.getNode(ISD::ADD, dl, VT, RHS, DAG.getConstant(1, dl, VT));
10432                        DAG.getConstant(-ShiftAmount, dl, MVT::i32));
10436                        DAG.getConstant(ShiftAmount, dl, MVT::i32));
10465                      DAG.getConstant(0, dl, MVT::i64));
10613                    DAG.getConstant(0, DL, MVT::i64));
10615                    DAG.getConstant(InNVT.getVectorNumElements(), DL, MVT::i64));
10655                     DAG.getConstant(BaseOffset + Offset, DL, MVT::i64));
10851                                    DAG.getConstant(0, DL, MVT::i64));
10853                                    DAG.getConstant(NumElts, DL, MVT::i64));
10859                                   DAG.getConstant(8, DL, MVT::i64));
11557                      DAG.getConstant(Bit, DL, MVT::i64), N->getOperand(3));
11712                      DAG.getConstant(MinOffset, DL, MVT::i64));
11963                                        DAG.getConstant(64, DL, MVT::i64)));
11972       DAG.getNode(ISD::SRL, dl, MVT::i128, V, DAG.getConstant(64, dl, MVT::i64)),
lib/Target/AArch64/AArch64SelectionDAGInfo.cpp
  140   SDValue Ops[] = {DAG.getConstant(ObjSize, dl, MVT::i64), Addr, Chain};
lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp
 2617     return CurDAG->getConstant(C->getZExtValue() << 16, SL, MVT::i32);
 2622     return CurDAG->getConstant(
lib/Target/AMDGPU/AMDGPUISelLowering.cpp
 1121   auto Ops = {DAG.getConstant(0, SDLoc(), Op.getValueType()), Op.getOperand(0)};
 1215       return DAG.getConstant(Offset, SDLoc(Op), Op.getValueType());
 1338   const SDValue Zero = DAG.getConstant(0, SL, MVT::i32);
 1339   const SDValue One = DAG.getConstant(1, SL, MVT::i32);
 1351   const SDValue Zero = DAG.getConstant(0, SL, MVT::i32);
 1359   const SDValue One = DAG.getConstant(1, SL, MVT::i32);
 1391                            DAG.getConstant(0, DL, IdxTy));
 1394       HiVT, N, DAG.getConstant(LoVT.getVectorNumElements(), DL, IdxTy));
 1443                        DAG.getConstant(0, SL, IdxTy));
 1447                        DAG.getConstant(LoVT.getVectorNumElements(), SL, IdxTy));
 1477                    DAG.getConstant(0, SL, getVectorIdxTy(DAG.getDataLayout()))),
 1552   SDValue jq = DAG.getConstant(1, DL, IntVT);
 1560                      DAG.getConstant(BitSize - 2, DL, VT));
 1563     jq = DAG.getNode(ISD::OR, DL, VT, jq, DAG.getConstant(1, DL, VT));
 1608   jq = DAG.getNode(ISD::SELECT, DL, VT, cv, jq, DAG.getConstant(0, DL, VT));
 1624     SDValue TruncMask = DAG.getConstant((UINT64_C(1) << DivBits) - 1, DL, VT);
 1642   SDValue One = DAG.getConstant(1, DL, HalfVT);
 1643   SDValue Zero = DAG.getConstant(0, DL, HalfVT);
 1693     SDValue Zero64 = DAG.getConstant(0, DL, VT);
 1694     SDValue One64  = DAG.getConstant(1, DL, VT);
 1695     SDValue Zero1 = DAG.getConstant(0, DL, MVT::i1);
 1743     SDValue MinusOne = DAG.getConstant(0xffffffffu, DL, HalfVT);
 1815     SDValue POS = DAG.getConstant(bitPos, DL, HalfVT);
 1822     REM = DAG.getNode(ISD::SHL, DL, VT, REM, DAG.getConstant(1, DL, VT));
 1826     SDValue BIT = DAG.getConstant(1ULL << bitPos, DL, HalfVT);
 1872   SDValue NEG_RCP_LO = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
 1876   SDValue ABS_RCP_LO = DAG.getSelectCC(DL, RCP_HI, DAG.getConstant(0, DL, VT),
 1890   SDValue Tmp0 = DAG.getSelectCC(DL, RCP_HI, DAG.getConstant(0, DL, VT),
 1904                                                  DAG.getConstant(-1, DL, VT),
 1905                                                  DAG.getConstant(0, DL, VT),
 1910                                                   DAG.getConstant(-1, DL, VT),
 1911                                                   DAG.getConstant(0, DL, VT),
 1921                                        DAG.getConstant(1, DL, VT));
 1925                                        DAG.getConstant(1, DL, VT));
 1928   SDValue Div = DAG.getSelectCC(DL, Tmp1, DAG.getConstant(0, DL, VT),
 1932   Div = DAG.getSelectCC(DL, Remainder_GE_Zero, DAG.getConstant(0, DL, VT),
 1944   SDValue Rem = DAG.getSelectCC(DL, Tmp1, DAG.getConstant(0, DL, VT),
 1948   Rem = DAG.getSelectCC(DL, Remainder_GE_Zero, DAG.getConstant(0, DL, VT),
 1965   SDValue Zero = DAG.getConstant(0, DL, VT);
 1966   SDValue NegOne = DAG.getConstant(-1, DL, VT);
 2065                                 DAG.getConstant(FractBits - 32, SL, MVT::i32),
 2066                                 DAG.getConstant(ExpBits, SL, MVT::i32));
 2068                             DAG.getConstant(1023, SL, MVT::i32));
 2079   const SDValue Zero = DAG.getConstant(0, SL, MVT::i32);
 2080   const SDValue One = DAG.getConstant(1, SL, MVT::i32);
 2093   const SDValue SignBitMask = DAG.getConstant(UINT32_C(1) << 31, SL, MVT::i32);
 2102     = DAG.getConstant((UINT64_C(1) << FractBits) - 1, SL, MVT::i64);
 2111   const SDValue FiftyOne = DAG.getConstant(FractBits - 1, SL, MVT::i32);
 2196   const SDValue Zero = DAG.getConstant(0, SL, MVT::i32);
 2197   const SDValue One = DAG.getConstant(1, SL, MVT::i32);
 2198   const SDValue NegOne = DAG.getConstant(-1, SL, MVT::i32);
 2199   const SDValue FiftyOne = DAG.getConstant(51, SL, MVT::i32);
 2209   const SDValue Mask = DAG.getConstant(INT64_C(0x000fffffffffffff), SL,
 2214                           DAG.getConstant(INT64_C(0x0008000000000000), SL,
 2220                               DAG.getConstant(0, SL, MVT::i64), Tmp0,
 2224                              D, DAG.getConstant(0, SL, MVT::i64));
 2337   const SDValue Zero = DAG.getConstant(0, SL, MVT::i32);
 2338   const SDValue One = DAG.getConstant(1, SL, MVT::i32);
 2352   const SDValue Bits32 = DAG.getConstant(32, SL, MVT::i32);
 2378     const SDValue Bits32 = DAG.getConstant(64, SL, MVT::i32);
 2416     const SDValue SignBit = DAG.getConstant(63, SL, MVT::i64);
 2427   SDValue ZeroI32 = DAG.getConstant(0, SL, MVT::i32);
 2428   SDValue ZeroI64 = DAG.getConstant(0, SL, MVT::i64);
 2432   SDValue K = DAG.getConstant(127U + 63U, SL, MVT::i32);
 2440     DAG.getConstant((-1ULL) >> 1, SL, MVT::i64));
 2443                           DAG.getConstant(0xffffffffffULL, SL, MVT::i64));
 2446                              U, DAG.getConstant(40, SL, MVT::i64));
 2449     DAG.getNode(ISD::SHL, SL, MVT::i32, E, DAG.getConstant(23, SL, MVT::i32)),
 2452   SDValue C = DAG.getConstant(0x8000000000ULL, SL, MVT::i64);
 2456   SDValue One = DAG.getConstant(1, SL, MVT::i32);
 2482                            DAG.getConstant(0, SL, MVT::i32));
 2484                            DAG.getConstant(1, SL, MVT::i32));
 2492                               DAG.getConstant(32, SL, MVT::i32));
 2599   SDValue Zero = DAG.getConstant(0, DL, MVT::i32);
 2600   SDValue One = DAG.getConstant(1, DL, MVT::i32);
 2603                            DAG.getConstant(32, DL, MVT::i64));
 2607                           DAG.getConstant(20, DL, MVT::i64));
 2609                   DAG.getConstant(ExpMask, DL, MVT::i32));
 2613                   DAG.getConstant(-ExpBiasf64 + ExpBiasf16, DL, MVT::i32));
 2616                           DAG.getConstant(8, DL, MVT::i32));
 2618                   DAG.getConstant(0xffe, DL, MVT::i32));
 2621                                   DAG.getConstant(0x1ff, DL, MVT::i32));
 2629       DAG.getSelectCC(DL, M, Zero, DAG.getConstant(0x0200, DL, MVT::i32),
 2630                       Zero, ISD::SETNE), DAG.getConstant(0x7c00, DL, MVT::i32));
 2635                   DAG.getConstant(12, DL, MVT::i32)));
 2642                   DAG.getConstant(13, DL, MVT::i32));
 2645                                    DAG.getConstant(0x1000, DL, MVT::i32));
 2654                               DAG.getConstant(0x7, DL, MVT::i32));
 2656                   DAG.getConstant(2, DL, MVT::i32));
 2657   SDValue V0 = DAG.getSelectCC(DL, VLow3, DAG.getConstant(3, DL, MVT::i32),
 2659   SDValue V1 = DAG.getSelectCC(DL, VLow3, DAG.getConstant(5, DL, MVT::i32),
 2664   V = DAG.getSelectCC(DL, E, DAG.getConstant(30, DL, MVT::i32),
 2665                       DAG.getConstant(0x7c00, DL, MVT::i32), V, ISD::SETGT);
 2666   V = DAG.getSelectCC(DL, E, DAG.getConstant(1039, DL, MVT::i32),
 2671                             DAG.getConstant(16, DL, MVT::i32));
 2673                      DAG.getConstant(0x8000, DL, MVT::i32));
 2806     return DAG.getConstant(Result, DL, MVT::i32);
 2809   return DAG.getConstant(Src0 >> Offset, DL, MVT::i32);
 2998   SDValue LoRHS = DAG.getConstant(ValLo, SL, MVT::i32);
 2999   SDValue HiRHS = DAG.getConstant(ValHi, SL, MVT::i32);
 3042        { DAG.getConstant(0, SL, MVT::i16), LHS->getOperand(0) });
 3070   SDValue ShiftAmt = DAG.getConstant(RHSVal - 32, SL, MVT::i32);
 3075   const SDValue Zero = DAG.getConstant(0, SL, MVT::i32);
 3098                                    DAG.getConstant(31, SL, MVT::i32));
 3108                                    DAG.getConstant(31, SL, MVT::i32));
 3151   SDValue One = DAG.getConstant(1, SL, MVT::i32);
 3152   SDValue Zero = DAG.getConstant(0, SL, MVT::i32);
 3157   SDValue NewConst = DAG.getConstant(ShiftAmt - 32, SL, MVT::i32);
 3825                                   DAG.getConstant(0x8000, SL, SrcVT));
 3850                                   DAG.getConstant(0x7fff, SL, SrcVT));
 3920                                  DAG.getConstant(Lo_32(CVal), SL, MVT::i32),
 3921                                  DAG.getConstant(Hi_32(CVal), SL, MVT::i32));
 3931                                 DAG.getConstant(Lo_32(CVal), SL, MVT::i32),
 3932                                 DAG.getConstant(Hi_32(CVal), SL, MVT::i32));
 3992       return DAG.getConstant(0, DL, MVT::i32);
 4044       SDValue ShiftVal = DAG.getConstant(OffsetVal, DL, MVT::i32);
 4146   SDValue Ptr = DAG.getConstant(Offset, SL, MVT::i32);
 4170                      DAG.getConstant(Mask >> Shift, SL, VT));
lib/Target/AMDGPU/R600ISelLowering.cpp
  512         DAG.getConstant(0, DL, MVT::i32), // SWZ_X
  513         DAG.getConstant(1, DL, MVT::i32), // SWZ_Y
  514         DAG.getConstant(2, DL, MVT::i32), // SWZ_Z
  515         DAG.getConstant(3, DL, MVT::i32) // SWZ_W
  547         DAG.getConstant(TextureOp, DL, MVT::i32),
  549         DAG.getConstant(0, DL, MVT::i32),
  550         DAG.getConstant(1, DL, MVT::i32),
  551         DAG.getConstant(2, DL, MVT::i32),
  552         DAG.getConstant(3, DL, MVT::i32),
  556         DAG.getConstant(0, DL, MVT::i32),
  557         DAG.getConstant(1, DL, MVT::i32),
  558         DAG.getConstant(2, DL, MVT::i32),
  559         DAG.getConstant(3, DL, MVT::i32),
  572           DAG.getConstant(0, DL, MVT::i32)),
  574           DAG.getConstant(0, DL, MVT::i32)),
  576           DAG.getConstant(1, DL, MVT::i32)),
  578           DAG.getConstant(1, DL, MVT::i32)),
  580           DAG.getConstant(2, DL, MVT::i32)),
  582           DAG.getConstant(2, DL, MVT::i32)),
  584           DAG.getConstant(3, DL, MVT::i32)),
  586           DAG.getConstant(3, DL, MVT::i32))
  594       return DAG.getConstant(ByteOffset, DL, PtrVT);
  702         DAG.getConstant(i, DL, getVectorIdxTy(DAG.getDataLayout()))));
  796   SDValue Zero = DAG.getConstant(0, DL, VT);
  797   SDValue One  = DAG.getConstant(1, DL, VT);
  799   SDValue Width  = DAG.getConstant(VT.getSizeInBits(), DL, VT);
  800   SDValue Width1 = DAG.getConstant(VT.getSizeInBits() - 1, DL, VT);
  832   SDValue Zero = DAG.getConstant(0, DL, VT);
  833   SDValue One  = DAG.getConstant(1, DL, VT);
  837   SDValue Width  = DAG.getConstant(VT.getSizeInBits(), DL, VT);
  838   SDValue Width1 = DAG.getConstant(VT.getSizeInBits() - 1, DL, VT);
  912                      DAG.getConstant(ByteOffset, DL, MVT::i32), // PTR
 1065     HWTrue = DAG.getConstant(-1, DL, CompareVT);
 1066     HWFalse = DAG.getConstant(0, DL, CompareVT);
 1106                      DAG.getConstant(SRLPad, DL, MVT::i32));
 1149     Mask = DAG.getConstant(0xff, DL, MVT::i32);
 1152     Mask = DAG.getConstant(0xffff, DL, MVT::i32);
 1173                             DAG.getConstant(0xfffffffc, DL, MVT::i32));
 1185                                 DAG.getConstant(0x3, DL, MVT::i32));
 1189                                  DAG.getConstant(3, DL, MVT::i32));
 1271                                   DAG.getConstant(2, DL, PtrVT));
 1280         MaskConstant = DAG.getConstant(0xFF, DL, MVT::i32);
 1284         MaskConstant = DAG.getConstant(0xFFFF, DL, MVT::i32);
 1288                                       DAG.getConstant(0x00000003, DL, PtrVT));
 1290                                      DAG.getConstant(3, DL, VT));
 1303         DAG.getConstant(0, DL, MVT::i32),
 1304         DAG.getConstant(0, DL, MVT::i32),
 1404                             DAG.getConstant(0xfffffffc, DL, MVT::i32));
 1414                                 LoadPtr, DAG.getConstant(0x3, DL, MVT::i32));
 1418                                  DAG.getConstant(3, DL, MVT::i32));
 1477                       DAG.getConstant(4, DL, MVT::i32)),
 1478                       DAG.getConstant(LoadNode->getAddressSpace() -
 1485                            DAG.getConstant(0, DL, MVT::i32));
 1522     Ptr = DAG.getNode(ISD::SRL, DL, MVT::i32, Ptr, DAG.getConstant(2, DL, MVT::i32));
 1549   return DAG.getConstant(Offset * 4 * TFL->getStackWidth(MF), SDLoc(Op),
 1641         DAG.getConstant(PartOffset, DL, MVT::i32), DAG.getUNDEF(MVT::i32),
 1787       Swz[i] = DAG.getConstant(SwizzleRemap[Idx], DL, MVT::i32);
 1795       Swz[i] = DAG.getConstant(SwizzleRemap[Idx], DL, MVT::i32);
 1826         DAG.getConstant(4 * i + ConstantBlock * 16, DL, MVT::i32));
 1838                          DAG.getConstant(0, DL, MVT::i32));
 1889                            DAG.getConstant(-1, DL, MVT::i32), // True
 1890                            DAG.getConstant(0, DL, MVT::i32),  // False
lib/Target/AMDGPU/SIISelLowering.cpp
 1437                       DAG.getConstant(0, SL, MVT::i32));
 1483     SDValue ShiftAmt = DAG.getConstant(OffsetDiff * 8, SL, MVT::i32);
 2822       SDValue PtrOff = DAG.getConstant(Offset, DL, PtrVT);
 2859             DAG.getConstant(Outs[i].Flags.getByValSize(), DL, MVT::i32);
 4351                              DAG.getConstant(0x80008000, SL, MVT::i32));
 4364                              DAG.getConstant(0x7fff7fff, SL, MVT::i32));
 4539     return DAG.getConstant(0, DL, VT);
 4545     return DAG.getConstant(0, DL, VT);
 4706   SDValue FlatNullPtr = DAG.getConstant(0, SL, MVT::i64);
 4718       SDValue SegmentNullPtr = DAG.getConstant(NullVal, SL, MVT::i32);
 4734       SDValue SegmentNullPtr = DAG.getConstant(NullVal, SL, MVT::i32);
 4778                               DAG.getConstant(I, SL, MVT::i32));
 4780                       DAG.getConstant(IdxVal + I, SL, MVT::i32));
 4806                                  DAG.getConstant(0, SL, MVT::i32));
 4808                                  DAG.getConstant(1, SL, MVT::i32));
 4818       DAG.getConstant(InsertLo ? Idx : (Idx - 2), SL, MVT::i32));
 4843   SDValue ScaleFactor = DAG.getConstant(Log2_32(EltSize), SL, MVT::i32);
 4850                             DAG.getConstant(0xffff, SL, IntVT),
 4886   SDValue ScaleFactor = DAG.getConstant(Log2_32(EltSize), SL, MVT::i32);
 4935                                     DAG.getConstant(EltIdx, SL, MVT::i32));
 4947                                  Vec0, DAG.getConstant(EltIdx0, SL, MVT::i32));
 4951                                  Vec1, DAG.getConstant(EltIdx1, SL, MVT::i32));
 4998                               DAG.getConstant(16, SL, MVT::i32));
 5679       DAG.getConstant(0, DL, MVT::i32),                 // vindex
 5858     return DAG.getConstant(MF.getSubtarget<GCNSubtarget>().getWavefrontSize(),
 5882         DAG.getConstant(2, DL, MVT::i32), // P0
 6077                                 DAG.getConstant(1, SL, MVT::i32));
 6293       DAG.getConstant(0, DL, MVT::i32), // vindex
 6364       DAG.getConstant(0, DL, MVT::i32), // vindex
 6494       DAG.getConstant(0, DL, MVT::i32), // vindex
 6661       DAG.getConstant(0, DL, MVT::i32), // vindex
 6734         DAG.getConstant(0, DL, getVectorIdxTy(DAG.getDataLayout())));
 6897       DAG.getConstant(0, DL, MVT::i32), // vindex
 6976       DAG.getConstant(0, DL, MVT::i32), // vindex
 7142       auto OverflowVal = DAG.getConstant(Overflow, DL, MVT::i32);
 7152     N0 = DAG.getConstant(0, DL, MVT::i32);
 7169       Offsets[0] = DAG.getConstant(0, DL, MVT::i32);
 7170       Offsets[1] = DAG.getConstant(SOffset, DL, MVT::i32);
 7183       Offsets[1] = DAG.getConstant(SOffset, DL, MVT::i32);
 7189   Offsets[1] = DAG.getConstant(0, DL, MVT::i32);
 7354                                 DAG.getConstant(I, DL, MVT::i32));
 7494   SDValue Zero = DAG.getConstant(0, DL, MVT::i32);
 7495   SDValue One = DAG.getConstant(1, DL, MVT::i32);
 7715       const SDValue EnableDenormValue = DAG.getConstant(FP_DENORM_FLUSH_NONE,
 7760           DAG.getConstant(FP_DENORM_FLUSH_IN_FLUSH_OUT, SL, MVT::i32);
 7817     const SDValue Hi = DAG.getConstant(1, SL, MVT::i32);
 8263                                     DAG.getConstant(Offset, SL, MVT::i32),
 8264                                     DAG.getConstant(Bits, SL, MVT::i32));
 8269                                     DAG.getConstant(NB, SDLoc(CRHS), MVT::i32));
 8286                          LHS.getOperand(1), DAG.getConstant(Sel, DL, MVT::i32));
 8325                            X, DAG.getConstant(Mask, DL, MVT::i32));
 8349                          DAG.getConstant(NewMask, DL, MVT::i32));
 8360                            LHS, DAG.getConstant(0, SDLoc(N), MVT::i32));
 8406                            DAG.getConstant(Sel, DL, MVT::i32));
 8440                          Src, DAG.getConstant(NewMask, DL, MVT::i32));
 8457                        LHS.getOperand(1), DAG.getConstant(Sel, DL, MVT::i32));
 8495                            DAG.getConstant(Sel, DL, MVT::i32));
 8687       return DAG.getConstant(0, SDLoc(N), MVT::i1);
 9322       SDValue IC = DAG.getConstant(I, SL, IdxVT);
 9356                               DAG.getConstant(EltIdx, SL, MVT::i32));
 9359                               DAG.getConstant(LeftoverBitIdx, SL, MVT::i32));
 9397     SDValue IC = DAG.getConstant(I, SL, IdxVT);
 9542     SDValue Args[] = { LHS, DAG.getConstant(0, SL, MVT::i32), Cond };
 9800                            DAG.getConstant(-1, SL, MVT::i1));
 9826                            DAG.getConstant(-1, SL, MVT::i1));
 9858                          DAG.getConstant(Mask, SL, MVT::i32));
10512                                      DAG.getConstant(RsrcDword1, DL, MVT::i32)),
lib/Target/ARC/ARCISelLowering.cpp
  174                      DAG.getConstant(ArcCC, dl, MVT::i32), Cmp);
  191                            DAG.getConstant(32 - Width, dl, MVT::i32));
  193                            DAG.getConstant(32 - Width, dl, MVT::i32));
  207                      DAG.getConstant(arcCC, dl, MVT::i32));
  357   Chain = DAG.getCALLSEQ_END(Chain, DAG.getConstant(NumBytes, dl, PtrVT, true),
  358                              DAG.getConstant(0, dl, PtrVT, true), Glue, dl);
  402                                 DAG.getConstant(Offset, dl, MVT::i32));
  543                                     DAG.getConstant(Offset, dl, MVT::i32));
  572           Chain, dl, FIN, ArgDI.SDV, DAG.getConstant(Size, dl, MVT::i32), Align,
lib/Target/ARM/ARMISelDAGToDAG.cpp
  418                           CurDAG->getConstant(Srl_imm + TZ, SDLoc(Srl),
  422                          CurDAG->getConstant(And_imm, SDLoc(Srl), MVT::i32));
  424                          N1, CurDAG->getConstant(TZ, SDLoc(Srl), MVT::i32));
  514   NewMulConst = CurDAG->getConstant(NewMulConstVal, SDLoc(N), MVT::i32);
 3133           CurDAG->getConstant(~N1C->getZExtValue(), dl, MVT::i32);
 3428         SDValue Ops2[] = {SDValue(Add, 0), CurDAG->getConstant(0, dl, MVT::i32)};
 3457         SDValue NewARMcc = CurDAG->getConstant((unsigned)CC, dl, MVT::i32);
lib/Target/ARM/ARMISelLowering.cpp
 1968                           DAG.getConstant(0, dl, MVT::i32));
 1982                           DAG.getConstant(1, dl, MVT::i32));
 2160                                   DAG.getConstant(0, dl, MVT::i32));
 2162                                   DAG.getConstant(1, dl, MVT::i32));
 2212           SDValue Const = DAG.getConstant(4*i, dl, MVT::i32);
 2235         SDValue SizeNode = DAG.getConstant(Flags.getByValSize() - 4*offset, dl,
 2237         SDValue AlignNode = DAG.getConstant(Flags.getByValAlign(), dl,
 2365       SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, dl, MVT::i32);
 2714                 DAG.getConstant(LROffset, DL, MVT::i32, false));
 2790                                    DAG.getConstant(0, dl, MVT::i32));
 2809                           DAG.getConstant(1, dl, MVT::i32));
 2966                            DAG.getConstant(0, DL, MVT::i32));
 2968                            DAG.getConstant(1, DL, MVT::i32));
 3047   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, DL, MVT::i32);
 3159                               DAG.getConstant(2, DL, MVT::i32));
 3195   SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, dl, MVT::i32);
 3246     SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, dl, MVT::i32);
 3562   SDValue Val = DAG.getConstant(0, dl, MVT::i32);
 3572                      Op.getOperand(1), DAG.getConstant(0, dl, MVT::i32));
 3639         DAG.getNode(ISD::SRA, dl, VTy, Operand, DAG.getConstant(31, dl, VTy));
 3642         DAG.getNode(ISD::SHL, dl, VTy, XOR, DAG.getConstant(1, dl, VTy));
 3644         DAG.getNode(ISD::OR, dl, VTy, SHL, DAG.getConstant(1, dl, VTy));
 3655                              DAG.getConstant(1, dl, VTy));
 3657                              DAG.getConstant(0, dl, VTy));
 3658     SDValue Constant0 = DAG.getConstant(0, dl, VTy);
 3659     SDValue Constant1 = DAG.getConstant(1, dl, VTy);
 3660     SDValue Constant31 = DAG.getConstant(31, dl, VTy);
 3696       SDValue PICLabel = DAG.getConstant(ARMPCLabelIndex, dl, MVT::i32);
 3769                        DAG.getConstant(0, dl, MVT::i32));
 3787                      DAG.getConstant(Intrinsic::arm_dmb, dl, MVT::i32),
 3788                      DAG.getConstant(Domain, dl, MVT::i32));
 3814                      Op.getOperand(1), DAG.getConstant(isRead, dl, MVT::i32),
 3815                      DAG.getConstant(isData, dl, MVT::i32));
 3922     FIN = DAG.getNode(ISD::ADD, dl, PtrVT, FIN, DAG.getConstant(4, dl, PtrVT));
 4194           RHS = DAG.getConstant(C - 1, dl, MVT::i32);
 4201           RHS = DAG.getConstant(C - 1, dl, MVT::i32);
 4208           RHS = DAG.getConstant(C + 1, dl, MVT::i32);
 4215           RHS = DAG.getConstant(C + 1, dl, MVT::i32);
 4259         SDValue ShiftAmt = DAG.getConstant(ShiftBits, dl, MVT::i32);
 4261         RHS = DAG.getConstant(RHSV << ShiftBits, dl, MVT::i32);
 4282                                 DAG.getConstant(ShiftAmt, dl, MVT::i32));
 4285     ARMcc = DAG.getConstant(ARMCC::HI, dl, MVT::i32);
 4317   ARMcc = DAG.getConstant(CondCode, dl, MVT::i32);
 4377     ARMcc = DAG.getConstant(ARMCC::VC, dl, MVT::i32);
 4382     ARMcc = DAG.getConstant(ARMCC::HS, dl, MVT::i32);
 4391     ARMcc = DAG.getConstant(ARMCC::VC, dl, MVT::i32);
 4396     ARMcc = DAG.getConstant(ARMCC::HS, dl, MVT::i32);
 4402     ARMcc = DAG.getConstant(ARMCC::EQ, dl, MVT::i32);
 4407                               DAG.getConstant(0, dl, MVT::i32));
 4413     ARMcc = DAG.getConstant(ARMCC::EQ, dl, MVT::i32);
 4420                                           DAG.getConstant(31, dl, MVT::i32)));
 4440   SDValue TVal = DAG.getConstant(1, dl, MVT::i32);
 4441   SDValue FVal = DAG.getConstant(0, dl, MVT::i32);
 4460                               BoolCarry, DAG.getConstant(1, DL, CarryVT));
 4471                      DAG.getConstant(0, DL, MVT::i32),
 4472                      DAG.getConstant(0, DL, MVT::i32), Flags);
 4504                            DAG.getConstant(1, dl, MVT::i32), Overflow);
 4603                      DAG.getConstant(1, dl, Cond.getValueType()));
 4606                          DAG.getConstant(0, dl, Cond.getValueType()),
 4891                          DAG.getConstant(countTrailingOnes(SatConstant), dl, VT));
 4894                          DAG.getConstant(countTrailingOnes(SatConstant), dl, VT));
 4907                                  DAG.getConstant(31, dl, VT));
 4981       RHS = DAG.getConstant(0, dl, LHS.getValueType());
 5013       ARMcc = DAG.getConstant(ARMCC::GE, dl, MVT::i32);
 5042   SDValue ARMcc = DAG.getConstant(CondCode, dl, MVT::i32);
 5047     SDValue ARMcc2 = DAG.getConstant(CondCode2, dl, MVT::i32);
 5080     return DAG.getConstant(0, SDLoc(Op), MVT::i32);
 5095     RetVal1 = DAG.getConstant(0, dl, MVT::i32);
 5096     RetVal2 = DAG.getConstant(0, dl, MVT::i32);
 5109                                  PtrType, Ptr, DAG.getConstant(4, dl, PtrType));
 5143     SDValue Mask = DAG.getConstant(0x7fffffff, dl, MVT::i32);
 5163     ARMcc = DAG.getConstant(CondCode, dl, MVT::i32);
 5199     ARMcc = DAG.getConstant(CondCode, SDLoc(ARMcc), MVT::i32);
 5224       RHS = DAG.getConstant(0, dl, LHS.getValueType());
 5252       ARMcc = DAG.getConstant(CondCode, SDLoc(ARMcc), MVT::i32);
 5278   SDValue ARMcc = DAG.getConstant(CondCode, dl, MVT::i32);
 5285     ARMcc = DAG.getConstant(CondCode2, dl, MVT::i32);
 5302   Index = DAG.getNode(ISD::MUL, dl, PTy, Index, DAG.getConstant(4, dl, PTy));
 5464                          DAG.getConstant(32, dl, MVT::i32));
 5472                            DAG.getConstant(32, dl, MVT::i32));
 5476                          DAG.getConstant(32, dl, MVT::i32));
 5492                         DAG.getConstant(0, dl, MVT::i32));
 5507   SDValue Mask1 = DAG.getConstant(0x80000000, dl, MVT::i32);
 5508   SDValue Mask2 = DAG.getConstant(0x7fffffff, dl, MVT::i32);
 5539     SDValue Offset = DAG.getConstant(4, dl, MVT::i32);
 5648                      DAG.getConstant(NewIndex.getZExtValue(), dl, MVT::i32));
 5747                              DAG.getConstant(0, dl, MVT::i32));
 5749                              DAG.getConstant(1, dl, MVT::i32));
 5805                                  DAG.getConstant(VTBits, dl, MVT::i32), ShAmt);
 5808                                    DAG.getConstant(VTBits, dl, MVT::i32));
 5812   SDValue CmpLo = getARMCmp(ExtraShAmt, DAG.getConstant(0, dl, MVT::i32),
 5820                                          DAG.getConstant(VTBits - 1, dl, VT))
 5821                            : DAG.getConstant(0, dl, VT);
 5822   SDValue CmpHi = getARMCmp(ExtraShAmt, DAG.getConstant(0, dl, MVT::i32),
 5847                                  DAG.getConstant(VTBits, dl, MVT::i32), ShAmt);
 5853                                    DAG.getConstant(VTBits, dl, MVT::i32));
 5855   SDValue CmpHi = getARMCmp(ExtraShAmt, DAG.getConstant(0, dl, MVT::i32),
 5860   SDValue CmpLo = getARMCmp(ExtraShAmt, DAG.getConstant(0, dl, MVT::i32),
 5864                            DAG.getConstant(0, dl, VT), ARMcc, CCR, CmpLo);
 5878                     DAG.getConstant(Intrinsic::arm_get_fpscr, dl, MVT::i32) };
 5882                                   DAG.getConstant(1U << 22, dl, MVT::i32));
 5884                               DAG.getConstant(22, dl, MVT::i32));
 5886                      DAG.getConstant(3, dl, MVT::i32));
 5965     Ops.push_back(DAG.getConstant(Intrinsic::arm_neon_vpaddlu, DL,
 6049                          DAG.getConstant(Cnt, dl, MVT::i32));
 6061                        DAG.getConstant(Cnt, dl, MVT::i32));
 6108                             DAG.getConstant(0, dl, MVT::i32), ShAmt);
 6117                              DAG.getConstant(0, dl, MVT::i32));
 6120                              DAG.getConstant(1, dl, MVT::i32));
 6140                            DAG.getConstant(0, dl, MVT::i32));
 6142                            DAG.getConstant(1, dl, MVT::i32));
 6238                                    DAG.getConstant(ARMCC::GT, dl, MVT::i32));
 6240                                    DAG.getConstant(ARMCC::GT, dl, MVT::i32));
 6250                                    DAG.getConstant(ARMCC::GT, dl, MVT::i32));
 6252                                    DAG.getConstant(ARMCC::GE, dl, MVT::i32));
 6322                          DAG.getConstant(Opc, dl, MVT::i32));
 6325                          DAG.getConstant(Opc, dl, MVT::i32));
 6348                       DAG.getConstant(1, DL, MVT::i32), Carry);
 6355   SDValue FVal = DAG.getConstant(0, DL, MVT::i32);
 6356   SDValue TVal = DAG.getConstant(1, DL, MVT::i32);
 6357   SDValue ARMcc = DAG.getConstant(
 6567                        DAG.getConstant(0, DL, MVT::i32));
 6598                        DAG.getConstant(0, DL, MVT::i32));
 6615                        DAG.getConstant(0, DL, MVT::i32));
 7023       return DAG.getConstant(Val, dl, MVT::i32);
 7026       return DAG.getConstant(Val, dl, MVT::i32);
 7079                              DAG.getConstant(Bits32, dl, MVT::i32));
 7085                        DAG.getConstant(i, dl, MVT::i32));
 7218                         Value, DAG.getConstant(index, dl, MVT::i32)),
 7219                            DAG.getConstant(index, dl, MVT::i32));
 7235           Ops.push_back(DAG.getConstant(I, dl, MVT::i32));
 7320       SDValue LaneIdx = DAG.getConstant(i, dl, MVT::i32);
 7443                       DAG.getConstant(NumSrcElts, dl, MVT::i32));
 7449                       DAG.getConstant(0, dl, MVT::i32));
 7454                       DAG.getConstant(0, dl, MVT::i32));
 7457                       DAG.getConstant(NumSrcElts, dl, MVT::i32));
 7461                                    DAG.getConstant(Src.MinElt, dl, MVT::i32));
 7650                        OpLHS, DAG.getConstant(OpNum-OP_VDUP0, dl, MVT::i32));
 7656                        DAG.getConstant(OpNum - OP_VEXT1 + 1, dl, MVT::i32));
 7683     VTBLMask.push_back(DAG.getConstant(*I, DL, MVT::i32));
 7707                      DAG.getConstant(ExtractNum, DL, MVT::i32));
 7773                               DAG.getConstant(16, dl, MVT::i32));
 7795                      DAG.getConstant(ARMCC::NE, dl, MVT::i32));
 7843                          DAG.getConstant(Lane, dl, MVT::i32));
 7852                          DAG.getConstant(Imm, dl, MVT::i32));
 7864                          DAG.getConstant(Imm, dl, MVT::i32));
 7886                            DAG.getConstant(0, dl, MVT::i32));
 7889                            DAG.getConstant(1, dl, MVT::i32));
 7978                                   DAG.getConstant(ShuffleMask[i] & (NumElts-1),
 8012                             DAG.getConstant(~Mask, dl, MVT::i32));
 8072                               DAG.getConstant(Lane * LaneWidth, dl, MVT::i32));
 8135                            DAG.getConstant(j, dl, MVT::i32));
 8146                      DAG.getConstant(ARMCC::NE, dl, MVT::i32));
 8202                          DAG.getConstant(j, dl, MVT::i32));
 8208                      DAG.getConstant(ARMCC::NE, dl, MVT::i32));
 8512                    DAG.getConstant(Intrinsic::arm_neon_vrecpe, dl, MVT::i32),
 8520   Y = DAG.getConstant(0xb000, dl, MVT::v4i32);
 8546                    DAG.getConstant(Intrinsic::arm_neon_vrecpe, dl, MVT::i32),
 8549                    DAG.getConstant(Intrinsic::arm_neon_vrecps, dl, MVT::i32),
 8558   N1 = DAG.getConstant(0x89, dl, MVT::v4i32);
 8636                      DAG.getConstant(Intrinsic::arm_neon_vqmovnsu, dl,
 8655                    DAG.getConstant(Intrinsic::arm_neon_vrecpe, dl, MVT::i32),
 8658                    DAG.getConstant(Intrinsic::arm_neon_vrecps, dl, MVT::i32),
 8662                    DAG.getConstant(Intrinsic::arm_neon_vrecps, dl, MVT::i32),
 8671   N1 = DAG.getConstant(2, dl, MVT::v4i32);
 8705                         DAG.getConstant(1, DL, MVT::i32), Carry);
 8718                         DAG.getConstant(1, DL, MVT::i32), Carry);
 8898                            DAG.getConstant(0, DL, MVT::i32));
 8900                            DAG.getConstant(1, DL, MVT::i32));
 8921                               DAG.getConstant(32, dl, TLI.getPointerTy(DL)));
 8954                        DAG.getConstant(0, dl, MVT::i32));
 8975                                 DAG.getConstant(I, dl, MVT::i32)));
 9047                                 DAG.getConstant(0, DL, MVT::i32)));
 9055       DAG.getNode(ISD::SRL, dl, MVT::i64, V, DAG.getConstant(32, dl, MVT::i32)),
 9260                            DAG.getConstant(0, dl, MVT::i32));
 9263                            DAG.getConstant(1, dl, MVT::i32));
10871       OtherOp = DAG.getConstant(0, dl, VT);
10874       OtherOp = DAG.getConstant(1, dl, VT);
10979   Ops.push_back(DAG.getConstant(Intrinsic::arm_neon_vpadd, dl,
11024   Ops.push_back(DAG.getConstant(Opcode, dl,
11113   Ops.push_back(DAG.getConstant(Intrinsic::arm_neon_vpaddls, dl,
11486         RHS = DAG.getConstant(-imm, DL, MVT::i32);
11511         RHS = DAG.getConstant(~imm, DL, MVT::i32);
11860                                     DAG.getConstant(Log2_32(MulAmt - 1), DL,
11867                                     DAG.getConstant(Log2_32(MulAmt + 1), DL,
11880                                     DAG.getConstant(Log2_32(MulAmtAbs + 1), DL,
11888                                     DAG.getConstant(Log2_32(MulAmtAbs - 1), DL,
11891                         DAG.getConstant(0, DL, MVT::i32), Res);
11898                       Res, DAG.getConstant(ShiftAmt, DL, MVT::i32));
11960                                 DAG.getConstant(C3 - C2, DL, MVT::i32));
11962                          DAG.getConstant(C3, DL, MVT::i32));
11971                                 DAG.getConstant(C3 - C2, DL, MVT::i32));
11973                          DAG.getConstant(C3, DL, MVT::i32));
11984                                 DAG.getConstant(C2 + C3, DL, MVT::i32));
11986                         DAG.getConstant(C3, DL, MVT::i32));
11997                                 DAG.getConstant(C2 + C3, DL, MVT::i32));
11999                          DAG.getConstant(C3, DL, MVT::i32));
12167                         DAG.getConstant(Val, DL, MVT::i32),
12168                         DAG.getConstant(Mask, DL, MVT::i32));
12194                         DAG.getConstant(amt, DL, MVT::i32));
12196                         DAG.getConstant(Mask, DL, MVT::i32));
12211                         DAG.getConstant(lsb, DL, MVT::i32));
12213                         DAG.getConstant(Mask2, DL, MVT::i32));
12233                       DAG.getConstant(~Mask, DL, MVT::i32));
12301   Ops0.push_back(DCI.DAG.getConstant(Opposite0, SDLoc(N0), MVT::i32));
12306   Ops1.push_back(DCI.DAG.getConstant(Opposite1, SDLoc(N1), MVT::i32));
12563         DCI.DAG.getConstant(NewFromMask.countTrailingZeros(), dl, VT));
12597                                     DAG.getConstant(4, DL, MVT::i32));
12762     SDValue LaneIdx = DAG.getConstant(Idx, dl, MVT::i32);
13054     Ops.push_back(DAG.getConstant(Alignment, dl, MVT::i32));
13226                       DAG.getConstant(LD->getAlignment(), SDLoc(N), MVT::i32) };
13316   SDValue Increment = DAG.getConstant(StoreType.getSizeInBits() / 8, DL,
13380                     DAG.getConstant(i * NumElements, DL, MVT::i32));
13425                                     DAG.getConstant(4, DL, MVT::i32));
13513       DAG.getConstant(IntrinsicOpcode, dl, MVT::i32), Op->getOperand(0),
13514       DAG.getConstant(C, dl, MVT::i32));
13577                      DAG.getConstant(IntrinsicOpcode, dl, MVT::i32),
13578                      ConvInput, DAG.getConstant(C, dl, MVT::i32));
13705                        N->getOperand(1), DAG.getConstant(Cnt, dl, MVT::i32));
13724                        DAG.getConstant(Cnt, dl, MVT::i32));
13785                                   DAG.getConstant(MaskedBits, DL, MVT::i32));
13788             DAG.getConstant(MaskedBits - ShiftAmt, DL, MVT::i32));
13809                          DAG.getConstant(Cnt, dl, MVT::i32));
13820                          DAG.getConstant(Cnt, dl, MVT::i32));
14016                     DAG.getConstant(BitInX, dl, VT));
14318                           DAG.getConstant(5, dl, MVT::i32));
14336                         DAG.getConstant(1, dl, MVT::i32), Neg.getValue(1));
14362                         DAG.getConstant(ARMCC::NE, dl, MVT::i32),
14390       TrueVal = DAG.getConstant(1, dl, VT);
14396                         DAG.getConstant(ShiftAmount, dl, MVT::i32));
15138         Offset = DAG.getConstant(-RHSC, SDLoc(Ptr), RHS->getValueType(0));
15152         Offset = DAG.getConstant(-RHSC, SDLoc(Ptr), RHS->getValueType(0));
15195       Offset = DAG.getConstant(-RHSC, SDLoc(Ptr), RHS->getValueType(0));
15199       Offset = DAG.getConstant(RHSC, SDLoc(Ptr), RHS->getValueType(0));
15223       Offset = DAG.getConstant(-RHSC, SDLoc(Ptr), RHS->getValueType(0));
15227       Offset = DAG.getConstant(RHSC, SDLoc(Ptr), RHS->getValueType(0));
15521     SDValue NewC = TLO.DAG.getConstant(NewMask, DL, VT);
16077                        DAG.getConstant(-(uint64_t)Align, DL, MVT::i32));
16084                               DAG.getConstant(2, DL, MVT::i32));
16189                    DAG.getConstant(0, dl, HalfT));
16191                    DAG.getConstant(1, dl, HalfT));
16194                     DAG.getConstant(OpTypeBits - 1, dl,
lib/Target/ARM/ARMSelectionDAGInfo.cpp
  186                       DAG.getConstant(NumRegs, dl, MVT::i32));
  214                                        DAG.getConstant(SrcOff, dl, MVT::i32)),
  231                                         DAG.getConstant(DstOff, dl, MVT::i32)),
lib/Target/AVR/AVRISelLowering.cpp
  466         AVRcc = DAG.getConstant(AVRCC::COND_PL, DL, MVT::i8);
  473         LHS = DAG.getConstant(0, DL, VT);
  480         RHS = DAG.getConstant(C->getSExtValue() + 1, DL, VT);
  499         LHS = DAG.getConstant(0, DL, VT);
  507         AVRcc = DAG.getConstant(AVRCC::COND_MI, DL, MVT::i8);
  524       RHS = DAG.getConstant(C->getSExtValue() + 1, DL, VT);
  613     AVRcc = DAG.getConstant(intCCToAVRCC(CC), DL, MVT::i8);
  660   SDValue TrueV = DAG.getConstant(1, DL, Op.getValueType());
  661   SDValue FalseV = DAG.getConstant(0, DL, Op.getValueType());
  816     Offset = DAG.getConstant(RHSC, DL, MVT::i8);
  866     Offset = DAG.getConstant(RHSC, DL, MVT::i8);
lib/Target/BPF/BPFISelDAGToDAG.cpp
  306   SDValue NVal = CurDAG->getConstant(val, DL, MVT::i64);
lib/Target/BPF/BPFISelLowering.cpp
  262       InVals.push_back(DAG.getConstant(0, DL, VA.getLocVT()));
  396       Chain, DAG.getConstant(NumBytes, CLI.DL, PtrVT, true),
  397       DAG.getConstant(0, CLI.DL, PtrVT, true), InFlag, CLI.DL);
  467       InVals.push_back(DAG.getConstant(0, DL, Ins[i].VT));
  510                      DAG.getConstant(CC, DL, LHS.getValueType()), Dest);
  524   SDValue TargetCC = DAG.getConstant(CC, DL, LHS.getValueType());
lib/Target/BPF/BPFSelectionDAGInfo.cpp
   38                     DAG.getConstant(CopyLen, dl, MVT::i64),
   39                     DAG.getConstant(Align, dl, MVT::i64));
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp
 1067     SDValue D = DAG.getConstant(DV, DL, VT);
 1144     SDValue D = DAG.getConstant(TZ+CV, dl, VT);
 1145     SDValue DC = DAG.getConstant(TZ, dl, VT);
 1183       SDValue C0 = DAG.getConstant(0, dl, BVT);
 1184       SDValue C1 = DAG.getConstant(1, dl, BVT);
 1781   return CurDAG->getConstant(MulFactor, SDLoc(N),
 1834         Ops[i] = CurDAG->getConstant(NewConst,
 1843     Ops[1] = CurDAG->getConstant(ShiftAmount - Power,
 2055     SDValue Const = CurDAG->getConstant(MaxPowerOf2, SDLoc(N),
 2178           CurDAG->getConstant(
 2208           CurDAG->getConstant(
lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp
 1412     SDValue Idx = DAG.getConstant(M, dl, MVT::i32);
 1993     Elems.push_back(DAG.getConstant(C, dl, MVT::i8));
lib/Target/Hexagon/HexagonISelLowering.cpp
  168   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), dl, MVT::i32);
  411       SDValue MemAddr = DAG.getConstant(LocMemOffset, dl,
  630   SDValue Zero = DAG.getConstant(0, DL, MVT::i32);
  654     SDValue Zero = DAG.getConstant(0, DL, MVT::i32);
  683   SDValue AC = DAG.getConstant(A, dl, MVT::i32);
  748                                 Copy, DAG.getConstant(1, dl, RegVT));
  749         Copy = DAG.getSetCC(dl, MVT::i1, T, DAG.getConstant(0, dl, RegVT),
  980     SDValue Offset = DAG.getConstant(4, dl, MVT::i32);
 1043   SDValue Off = DAG.getConstant(Offset, dl, MVT::i32);
 2147       return DAG.getBitcast(MVT::v2i16, DAG.getConstant(V, dl, MVT::i32));
 2161       return DAG.getBitcast(MVT::v4i8, DAG.getConstant(V, dl, MVT::i32));
 2189     SDValue S8 = DAG.getConstant(8, dl, MVT::i32);
 2251     SDValue V0 = DAG.getConstant(Val, dl, MVT::i64);
 2296       SDValue M0 = DAG.getConstant(8 / VecWidth, dl, MVT::i32);
 2312                              DAG.getConstant(8*VecRep, dl, MVT::i32));
 2332   SDValue WidthV = DAG.getConstant(ValWidth, dl, MVT::i32);
 2344       SDValue OffV = DAG.getConstant(Off, dl, MVT::i32);
 2354                                DAG.getConstant(ElemWidth, dl, MVT::i32));
 2388     SDValue Width = DAG.getConstant(ValBytes*8, dl, MVT::i32);
 2390                               DAG.getConstant(8, dl, MVT::i32));
 2412   SDValue WidthV = DAG.getConstant(ValWidth, dl, MVT::i32);
 2417     SDValue OffV = DAG.getConstant(W, dl, MVT::i32);
 2456       return DAG.getBitcast(Ty, DAG.getConstant(0, dl, MVT::getIntegerVT(W)));
 2461     return DAG.getConstant(0, dl, Ty);
 2507       SDValue S = DAG.getConstant(1ull << i, dl, MVT::i32);
 2560       SDValue WidthV = DAG.getConstant(64 / Scale, dl, MVT::i32);
 2710                            DAG.getConstant(BO.second % LoadLen, dl, MVT::i32));
 2715                     DAG.getConstant(NeedAlign, dl, MVT::i32))
 2769                                 DAG.getConstant(-1, dl, ty(Op)), ISD::SETEQ);
 2938         return DCI.DAG.getConstant(-1, dl, ty(Op));
lib/Target/Hexagon/HexagonISelLoweringHVX.cpp
  204   IntOps.push_back(DAG.getConstant(IntId, dl, MVT::i32));
  292                      {ElemIdx, DAG.getConstant(L, dl, MVT::i32)});
  306   SDValue Mask = DAG.getConstant(32/ElemWidth - 1, dl, MVT::i32);
  478   SDValue S = DAG.getConstant(4, dl, MVT::i32);
  489                        {HalfV0, DAG.getConstant(HwLen/2, dl, MVT::i32)});
  527                          {DAG.getConstant(BlockLen, dl, MVT::i32)}, DAG);
  574   SDValue S4 = DAG.getConstant(HwLen-4, dl, MVT::i32);
  691   SDValue ScV = DAG.getConstant(Scale, dl, MVT::i32);
  713                                 {ByteIdxV, DAG.getConstant(-4, dl, MVT::i32)});
  717                                {DAG.getConstant(HwLen, dl, MVT::i32), MaskV});
  729                                 {ByteIdx, DAG.getConstant(2, dl, MVT::i32)});
  752   SDValue ScV = DAG.getConstant(Scale, dl, MVT::i32);
  794   SDValue W0Idx = DAG.getConstant(WordIdx, dl, MVT::i32);
  799   SDValue W1Idx = DAG.getConstant(WordIdx+1, dl, MVT::i32);
  863                            {ShuffV, DAG.getConstant(4, dl, MVT::i32)});
  889     SDValue HalfV = DAG.getConstant(SingleTy.getVectorNumElements(),
  921                        DAG.getConstant(ElemWidth/8, dl, MVT::i32));
  937                           DAG.getConstant(4, dl, MVT::i32));
  944                                DAG.getConstant(RolBase, dl, MVT::i32), IdxV);
  981                           DAG.getConstant(BitBytes, dl, MVT::i32));
  990                        {DAG.getConstant(BlockLen, dl, MVT::i32)}, DAG);
  994     SDValue HwLenV = DAG.getConstant(HwLen, dl, MVT::i32);
 1013                              DAG.getConstant(1, dl, MVT::i32));
 1124   SDValue S = DAG.getConstant(InpLen*BitBytes, dl, MVT::i32);
 1251                              DAG.getConstant(uint32_t(Splat1), dl, MVT::i32));
 1253                              DAG.getConstant(uint32_t(SplatW), dl, MVT::i32));
 1255                               DAG.getConstant(-1, dl, MVT::i32));
 1307       SDValue S16 = DAG.getConstant(16, dl, MVT::i32);
 1357   SDValue S16 = DAG.getConstant(16, dl, MVT::i32);
 1399                        {DAG.getConstant(0x02020202, dl, MVT::i32)}, DAG);
lib/Target/Lanai/LanaiISelLowering.cpp
  640     SDValue SizeNode = DAG.getConstant(Size, DL, MVT::i32);
  761       DAG.getConstant(NumBytes, DL, getPointerTy(DAG.getDataLayout()), true),
  762       DAG.getConstant(0, DL, getPointerTy(DAG.getDataLayout()), true), InFlag,
  816         RHS = DAG.getConstant(0, DL, RHS.getValueType());
  834         RHS = DAG.getConstant(0, DL, RHS.getValueType());
  875   SDValue TargetCC = DAG.getConstant(CC, DL, MVT::i32);
  944     Res = DAG.getConstant(0, DL, MVT::i32);
  947                       DAG.getConstant(HighestOne, DL, MVT::i32));
  960         DAG.getNode(ISD::SHL, DL, VT, V, DAG.getConstant(I, DL, MVT::i32));
  976   SDValue TargetCC = DAG.getConstant(CC, DL, MVT::i32);
  993   SDValue TargetCC = DAG.getConstant(CC, DL, MVT::i32);
 1253                                  DAG.getConstant(VTBits, dl, MVT::i32), ShAmt);
 1258   SDValue Zero = DAG.getConstant(0, dl, MVT::i32);
 1263                                    DAG.getConstant(VTBits, dl, MVT::i32));
 1278       dl, MVT::i32, SetCC, DAG.getConstant(0, dl, MVT::i32), LoForNormalShift);
 1304   SDValue Zero = DAG.getConstant(0, dl, MVT::i32);
 1306       ISD::SUB, dl, MVT::i32, DAG.getConstant(VTBits, dl, MVT::i32), ShAmt);
 1378     OtherOp = DAG.getConstant(1, dl, VT);
 1392       OtherOp = DAG.getConstant(0, dl, VT);
lib/Target/MSP430/MSP430ISelLowering.cpp
  849         SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), dl, MVT::i16);
  907   Chain = DAG.getCALLSEQ_END(Chain, DAG.getConstant(NumBytes, dl, PtrVT, true),
  908                              DAG.getConstant(0, dl, PtrVT, true), InFlag, dl);
 1058       RHS = DAG.getConstant(C->getSExtValue() + 1, dl, C->getValueType(0));
 1072       RHS = DAG.getConstant(C->getSExtValue() + 1, dl, C->getValueType(0));
 1086       RHS = DAG.getConstant(C->getSExtValue() + 1, dl, C->getValueType(0));
 1100       RHS = DAG.getConstant(C->getSExtValue() + 1, dl, C->getValueType(0));
 1108   TargetCC = DAG.getConstant(TCC, dl, MVT::i8);
 1185   SDValue One  = DAG.getConstant(1, dl, VT);
 1197     SDValue Zero = DAG.getConstant(0, dl, VT);
 1268         DAG.getConstant(DAG.getDataLayout().getPointerSize(), dl, MVT::i16);
 1347     Offset = DAG.getConstant(RHSC, SDLoc(N), VT);
lib/Target/Mips/MipsISelDAGToDAG.cpp
  256       ISD::SUB, DL, VT, CurDAG->getConstant(0, DL, VT).getNode(), C.getNode());
lib/Target/Mips/MipsISelLowering.cpp
  662                      DAG.getConstant(condCodeToFCC(CC), DL, MVT::i32));
  860                      DAG.getConstant(Pos, DL, MVT::i32),
  861                      DAG.getConstant(SMSize, DL, MVT::i32));
  913                        DAG.getConstant(SMPos0, DL, MVT::i32),
  914                        DAG.getConstant(SMSize0, DL, MVT::i32),
  943         Const1 = DAG.getConstant(SMPos0, DL, MVT::i32);
  949               ? DAG.getConstant(CN1->getSExtValue() >> SMPos0, DL, ValTy)
  951           DAG.getConstant(SMPos0, DL, MVT::i32),
  952           DAG.getConstant(ValTy.getSizeInBits() / 8 < 8 ? SMSize0 & 31
 1149                      DAG.getConstant(Pos, DL, MVT::i32),
 1150                      DAG.getConstant(SMSize, DL, MVT::i32));
 1919   SDValue BrCode = DAG.getConstant(Opc, DL, MVT::i32);
 1947   SDValue True  = DAG.getConstant(1, DL, MVT::i32);
 1948   SDValue False = DAG.getConstant(0, DL, MVT::i32);
 2170         DAG.getConstant(Align.value() - 1, DL, VAList.getValueType()));
 2174         DAG.getConstant(-(int64_t)Align.value(), DL, VAList.getValueType()));
 2183                   DAG.getConstant(alignTo(ArgSizeInBytes, ArgSlotSizeInBytes),
 2208   SDValue Const1 = DAG.getConstant(1, DL, MVT::i32);
 2209   SDValue Const31 = DAG.getConstant(31, DL, MVT::i32);
 2246                              DAG.getConstant(0, DL, MVT::i32));
 2256   SDValue Const1 = DAG.getConstant(1, DL, MVT::i32);
 2266                             DAG.getConstant(WidthY - 1, DL, MVT::i32), Const1);
 2274                             DAG.getConstant(WidthX - 1, DL, MVT::i32), Const1,
 2287                              DAG.getConstant(WidthY - 1, DL, MVT::i32));
 2295                              DAG.getConstant(WidthX - 1, DL, MVT::i32));
 2311   SDValue Res, Const1 = DAG.getConstant(1, DL, MVT::i32);
 2324                       DAG.getConstant(31, DL, MVT::i32), Const1, X);
 2341                   DAG.getConstant(0, DL, MVT::i32));
 2348   SDValue Res, Const1 = DAG.getConstant(1, DL, MVT::i32);
 2357                       DAG.getConstant(63, DL, MVT::i32), Const1, X);
 2449                      DAG.getConstant(SType, DL, MVT::i32));
 2466                             DAG.getConstant(-1, DL, MVT::i32));
 2468                                       DAG.getConstant(1, DL, VT));
 2474                              DAG.getConstant(VT.getSizeInBits(), DL, MVT::i32));
 2476                    DAG.getConstant(0, DL, VT), ShiftLeftLo);
 2504                             DAG.getConstant(-1, DL, MVT::i32));
 2506                                      DAG.getConstant(1, DL, VT));
 2513                              DAG.getConstant(VT.getSizeInBits(), DL, MVT::i32));
 2515                             DAG.getConstant(VT.getSizeInBits() - 1, DL, VT));
 2522                        IsSRA ? Ext : DAG.getConstant(0, DL, VT), Or,
 2528                    IsSRA ? Ext : DAG.getConstant(0, DL, VT), ShiftRightHi);
 2544                       DAG.getConstant(Offset, DL, BasePtrVT));
 2609   SDValue Const32 = DAG.getConstant(32, DL, MVT::i32);
 2625                       DAG.getConstant(Offset, DL, BasePtrVT));
 3163                                    Arg, DAG.getConstant(0, DL, MVT::i32));
 3165                                    Arg, DAG.getConstant(1, DL, MVT::i32));
 3204           DAG.getConstant(LocSizeInBits - ValSizeInBits, DL, VA.getLocVT()));
 3369           DAG.getConstant(LocSizeInBits - ValSizeInBits, DL, VA.getLocVT()));
 3423         DAG.getConstant(LocSizeInBits - ValSizeInBits, DL, VA.getLocVT()));
 3708           DAG.getConstant(LocSizeInBits - ValSizeInBits, DL, VA.getLocVT()));
 4218                                    DAG.getConstant(Offset, DL, PtrTy));
 4249                                     DAG.getConstant(OffsetInBytes, DL, PtrTy));
 4274                                       DAG.getConstant(OffsetInBytes, DL,
 4290                                     DAG.getConstant(Shamt, DL, MVT::i32));
 4311                             DAG.getConstant(OffsetInBytes, DL, PtrTy));
 4315                         DAG.getConstant(MemCpySize, DL, PtrTy),
lib/Target/Mips/MipsISelLowering.h
  472       SDValue Cst = DAG.getConstant(16, DL, MVT::i32);
lib/Target/Mips/MipsSEISelLowering.cpp
  796     return DAG.getConstant(0, DL, VT);
  805                        DAG.getConstant(C.logBase2(), DL, ShiftTy));
  866                      DAG.getConstant(SplatValue.getZExtValue(), DL, MVT::i32));
 1189   Ptr = DAG.getNode(ISD::ADD, DL, PtrVT, Ptr, DAG.getConstant(4, DL, PtrVT));
 1213                            Val, DAG.getConstant(0, DL, MVT::i32));
 1215                            Val, DAG.getConstant(1, DL, MVT::i32));
 1226   Ptr = DAG.getNode(ISD::ADD, DL, PtrVT, Ptr, DAG.getConstant(4, DL, PtrVT));
 1251                     DAG.getConstant(0, DL, MVT::i32));
 1254                     DAG.getConstant(1, DL, MVT::i32));
 1288                              DAG.getConstant(0, DL, MVT::i32));
 1290                              DAG.getConstant(1, DL, MVT::i32));
 1390       LaneB = DAG.getConstant(0, DL, MVT::i32);
 1410     SDValue One = DAG.getConstant(1, DL, ViaVecTy);
 1440                               DAG.getConstant(32, DL, MVT::i32));
 1500     Exp2Imm = DAG.getNode(ISD::SHL, DL, VecTy, DAG.getConstant(1, DL, VecTy),
 1513   SDValue ConstValue = DAG.getConstant(Vec.getScalarValueSizeInBits() - 1,
 1523   SDValue One = DAG.getConstant(1, DL, ResTy);
 1656     SDValue One = DAG.getConstant(1, DL, VecTy);
 1692     SDValue One = DAG.getConstant(1, DL, VecTy);
 1982                        DAG.getConstant(0, DL, MVT::i32));
 2527                            DAG.getConstant(i, DL, MVT::i32));
lib/Target/NVPTX/NVPTXISelLowering.cpp
 1217                        DAG.getConstant(IID, DL, MVT::i32), Operand);
 1243           DAG.getConstant(Intrinsic::nvvm_rcp_approx_ftz_d, DL, MVT::i32),
 1475             Chain, DAG.getConstant(ArgAlign, dl, MVT::i32),
 1476             DAG.getConstant(paramCount, dl, MVT::i32),
 1477             DAG.getConstant(AllocSize, dl, MVT::i32), InFlag};
 1490             Chain, DAG.getConstant(paramCount, dl, MVT::i32),
 1491             DAG.getConstant(AllocSize * 8, dl, MVT::i32),
 1492             DAG.getConstant(0, dl, MVT::i32), InFlag};
 1513           StoreOperands.push_back(DAG.getConstant(paramCount, dl, MVT::i32));
 1514           StoreOperands.push_back(DAG.getConstant(Offsets[j], dl, MVT::i32));
 1597     SDValue DeclareParamOps[] = {Chain, DAG.getConstant(ArgAlign, dl, MVT::i32),
 1598                                  DAG.getConstant(paramCount, dl, MVT::i32),
 1599                                  DAG.getConstant(sz, dl, MVT::i32), InFlag};
 1609                                     DAG.getConstant(curOffset, dl, PtrVT));
 1617                                  DAG.getConstant(paramCount, dl, MVT::i32),
 1618                                  DAG.getConstant(curOffset, dl, MVT::i32),
 1652       SDValue DeclareRetOps[] = { Chain, DAG.getConstant(1, dl, MVT::i32),
 1653                                   DAG.getConstant(resultsz, dl, MVT::i32),
 1654                                   DAG.getConstant(0, dl, MVT::i32), InFlag };
 1662                                   DAG.getConstant(retAlignment, dl, MVT::i32),
 1663                                   DAG.getConstant(resultsz / 8, dl, MVT::i32),
 1664                                   DAG.getConstant(0, dl, MVT::i32), InFlag };
 1709     Chain, DAG.getConstant((Ins.size() == 0) ? 0 : 1, dl, MVT::i32), InFlag
 1739     SDValue CallArgOps[] = { Chain, DAG.getConstant(1, dl, MVT::i32),
 1740                              DAG.getConstant(i, dl, MVT::i32), InFlag };
 1746                               DAG.getConstant(isIndirectCall ? 0 : 1, dl, MVT::i32),
 1754                                DAG.getConstant(uniqueCallSite, dl, MVT::i32),
 1825             Chain, DAG.getConstant(1, dl, MVT::i32),
 1826             DAG.getConstant(Offsets[VecIdx], dl, MVT::i32), InFlag};
 1997                                    DAG.getConstant(VTBits, dl, MVT::i32),
 2001                                      DAG.getConstant(VTBits, dl, MVT::i32));
 2007                                DAG.getConstant(VTBits, dl, MVT::i32),
 2057                                    DAG.getConstant(VTBits, dl, MVT::i32),
 2061                                      DAG.getConstant(VTBits, dl, MVT::i32));
 2067                                DAG.getConstant(VTBits, dl, MVT::i32),
 2108                              DAG.getConstant(SignBitMask, SL, MVT::i32));
 2112                   DAG.getConstant(PointFiveInBits, SL, MVT::i32));
 2512       InVals.push_back(DAG.getConstant(i + 1, dl, MVT::i32));
 2588                           DAG.getConstant(Offsets[VecIdx], dl, PtrVT));
 2694       StoreOperands.push_back(DAG.getConstant(Offsets[i], dl, MVT::i32));
lib/Target/PowerPC/PPCISelDAGToDAG.cpp
 5438                           CurDAG->getConstant(Mask, dl, VT));
 5447                           CurDAG->getConstant(Mask ^ Alt, dl, VT));
 5449                           CurDAG->getConstant(Alt, dl, VT));
 5481     CurDAG->getConstant(N->getOpcode() == ISD::SIGN_EXTEND ? -1 : 1, dl, VT);
 5482   SDValue ConstFalse = CurDAG->getConstant(0, dl, VT);
lib/Target/PowerPC/PPCISelLowering.cpp
 2666   SDValue Zero = DAG.getConstant(0, DL, PtrVT);
 3024     return DAG.getSetCC(dl, VT, Sub, DAG.getConstant(0, dl, LHSVT), CC);
 3048                                  DAG.getConstant(1, dl, MVT::i32));
 3050                                 DAG.getConstant(0, dl, MVT::i32), ISD::SETNE);
 3052                                           DAG.getConstant(1, dl, MVT::i32));
 3060                                DAG.getConstant(1, dl, MVT::i32));
 3068                                        DAG.getConstant(8, dl, MVT::i32));
 3071                                         DAG.getConstant(4, dl, MVT::i32));
 3084                             DAG.getConstant(8, dl, MVT::i32), ISD::SETLT);
 3089                                     DAG.getConstant(VT.isInteger() ? 4 : 8, dl,
 3099                          DAG.getConstant(32, dl, MVT::i32));
 3104                                    DAG.getConstant(VT == MVT::i64 ? 2 : 1, dl,
 3116                                           DAG.getConstant(VT.isInteger() ? 4 : 8,
 3135                        DAG.getConstant(12, SDLoc(Op), MVT::i32), 8, false, true,
 3163   Entry.Node = DAG.getConstant(isPPC64 ? 48 : 40, dl,
 3220   SDValue ArgGPR = DAG.getConstant(FuncInfo->getVarArgsNumGPR(), dl, MVT::i32);
 3221   SDValue ArgFPR = DAG.getConstant(FuncInfo->getVarArgsNumFPR(), dl, MVT::i32);
 3228   SDValue ConstFrameOffset = DAG.getConstant(FrameOffset, dl, PtrVT);
 3231   SDValue ConstStackOffset = DAG.getConstant(StackOffset, dl, PtrVT);
 3234   SDValue ConstFPROffset = DAG.getConstant(FPROffset, dl, PtrVT);
 3643       SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, dl, PtrVT);
 3662       SDValue PtrOff = DAG.getConstant(MVT(MVT::f64).getSizeInBits()/8, dl,
 3834           SDValue ArgOff = DAG.getConstant(PtrByteSize - ObjSize, dl, PtrVT);
 3880           SDValue Off = DAG.getConstant(j, dl, PtrVT);
 3965                                  DAG.getConstant(32, dl, MVT::i32));
 4091       SDValue PtrOff = DAG.getConstant(PtrByteSize, dl, PtrVT);
 4451       SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, dl, PtrVT);
 4757       .getConstant(
 4877   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), dl, MVT::i32);
 4899                            DAG.getConstant(ArgOffset, dl, PtrVT));
 5128     Ops.push_back(DAG.getConstant(SPDiff, dl, MVT::i32));
 5893       PtrOff = DAG.getConstant(ArgOffset, dl, StackPtr.getValueType());
 5949           SDValue Const = DAG.getConstant(PtrByteSize - Size, dl,
 5989           SDValue Const = DAG.getConstant(8 - Size, dl, PtrOff.getValueType());
 6010         SDValue Const = DAG.getConstant(j, dl, PtrOff.getValueType());
 6113                                  DAG.getConstant(32, dl, MVT::i32));
 6130           SDValue ConstFour = DAG.getConstant(4, dl, PtrOff.getValueType());
 6189                                    DAG.getConstant(i, dl, PtrVT));
 6245                                    DAG.getConstant(i, dl, PtrVT));
 6465     PtrOff = DAG.getConstant(ArgOffset, dl, StackPtr.getValueType());
 6493           SDValue Const = DAG.getConstant(PtrByteSize - Size, dl,
 6514         SDValue Const = DAG.getConstant(j, dl, PtrOff.getValueType());
 6565             SDValue ConstFour = DAG.getConstant(4, dl, PtrOff.getValueType());
 6609                              DAG.getConstant(ArgOffset, dl, PtrVT));
 6624                                    DAG.getConstant(i, dl, PtrVT));
 7071                                 DAG.getConstant(0, dl, PtrVT), Size);
 7396                         DAG.getConstant(4, dl, FIPtr.getValueType()));
 7476                            DAG.getConstant(0x80000000, dl, MVT::i32));
 7681       SignedConv ? DAG.getUNDEF(WideVT) : DAG.getConstant(0, dl, WideVT);
 7784                                   SINT, DAG.getConstant(2047, dl, MVT::i64));
 7786                           Round, DAG.getConstant(2047, dl, MVT::i64));
 7789                           Round, DAG.getConstant(-2048, dl, MVT::i64));
 7800                                  SINT, DAG.getConstant(53, dl, MVT::i32));
 7802                          Cond, DAG.getConstant(1, dl, MVT::i64));
 7804                           Cond, DAG.getConstant(1, dl, MVT::i64), ISD::SETUGT);
 7994   SDValue Four = DAG.getConstant(4, dl, PtrVT);
 8001                 CWD, DAG.getConstant(3, dl, MVT::i32));
 8006                                         CWD, DAG.getConstant(3, dl, MVT::i32)),
 8007                             DAG.getConstant(3, dl, MVT::i32)),
 8008                 DAG.getConstant(1, dl, MVT::i32));
 8033                              DAG.getConstant(BitWidth, dl, AmtVT), Amt);
 8038                              DAG.getConstant(-BitWidth, dl, AmtVT));
 8062                              DAG.getConstant(BitWidth, dl, AmtVT), Amt);
 8067                              DAG.getConstant(-BitWidth, dl, AmtVT));
 8090                              DAG.getConstant(BitWidth, dl, AmtVT), Amt);
 8095                              DAG.getConstant(-BitWidth, dl, AmtVT));
 8098   SDValue OutLo = DAG.getSelectCC(dl, Tmp5, DAG.getConstant(0, dl, AmtVT),
 8127   return DAG.getBitcast(ReqVT, DAG.getConstant(Val, dl, CanonicalVT));
 8136                      DAG.getConstant(IID, dl, MVT::i32), Op);
 8146                      DAG.getConstant(IID, dl, MVT::i32), LHS, RHS);
 8156                      DAG.getConstant(IID, dl, MVT::i32), Op0, Op1, Op2);
 8322       SDValue Idx = DAG.getConstant(Offset, dl, FIdx.getValueType());
 8352                      DAG.getConstant(Intrinsic::ppc_qpx_qvlfiwz, dl, MVT::i32),
 8359       DAG.getConstant(Intrinsic::ppc_qpx_qvfcfidu, dl, MVT::i32),
 8426       SDValue Z = DAG.getConstant(0, dl, MVT::v4i32);
 8438       SmallVector<SDValue, 16> Ops(16, DAG.getConstant(SplatBits,
 8452                             DAG.getConstant(SplatBits, dl, MVT::v16i8));
 8476     SDValue Elt = DAG.getConstant(SextVal, dl, MVT::i32);
 8479     SDValue EltSize = DAG.getConstant(SplatSize, dl, MVT::i32);
 8756                               DAG.getConstant(ShiftElts, dl, MVT::i32));
 8758                        DAG.getConstant(InsertAtByte, dl, MVT::i32));
 8761                      DAG.getConstant(InsertAtByte, dl, MVT::i32));
 8864                               DAG.getConstant(2 * ShiftElts, dl, MVT::i32));
 8867                               DAG.getConstant(InsertAtByte, dl, MVT::i32));
 8872                             DAG.getConstant(InsertAtByte, dl, MVT::i32));
 8939                                 DAG.getConstant(ShiftElts, dl, MVT::i32));
 8941                                 DAG.getConstant(InsertAtByte, dl, MVT::i32));
 8945                               DAG.getConstant(InsertAtByte, dl, MVT::i32));
 8967                               DAG.getConstant(ShiftElts, dl, MVT::i32));
 8980                               DAG.getConstant(ShiftElts, dl, MVT::i32));
 9010                                   DAG.getConstant(SplatIdx, dl, MVT::i32));
 9031                          DAG.getConstant(AlignIdx, dl, MVT::i32));
 9040                          DAG.getConstant(SplatIdx, dl, MVT::i32));
 9054                              DAG.getConstant(idx, dl, MVT::i32));
 9177         ResultMask.push_back(DAG.getConstant(31 - (SrcElt*BytesPerElement + j),
 9180         ResultMask.push_back(DAG.getConstant(SrcElt*BytesPerElement + j, dl,
 9467                               DAG.getConstant(CompareOpc, dl, MVT::i32));
 9475     DAG.getConstant(CompareOpc, dl, MVT::i32)
 9507                       DAG.getConstant(8 - (3 - BitNo), dl, MVT::i32));
 9510                       DAG.getConstant(1, dl, MVT::i32));
 9515                         DAG.getConstant(1, dl, MVT::i32));
 9592                 DAG.getConstant(MaskVal, dl, MVT::i32));
 9646                        DAG.getConstant(InsertAtByte, dl, MVT::i32));
 9677     DAG.getConstant(Intrinsic::ppc_qpx_qvfctiwu, dl, MVT::i32),
 9689                    DAG.getConstant(Intrinsic::ppc_qpx_qvstfiw, dl, MVT::i32),
 9698   SDValue Idx = DAG.getConstant(Offset, dl, FIdx.getValueType());
 9757                             DAG.getConstant(Stride, dl,
 9781     SDValue Idx = DAG.getConstant(i, dl, BasePtr.getValueType());
 9824           DAG.getConstant(Idx, dl, getVectorIdxTy(DAG.getDataLayout())));
 9846                             DAG.getConstant(Stride, dl,
 9877     DAG.getConstant(Intrinsic::ppc_qpx_qvfctiwu, dl, MVT::i32),
 9888                    DAG.getConstant(Intrinsic::ppc_qpx_qvstfiw, dl, MVT::i32),
 9899     SDValue Idx = DAG.getConstant(Offset, dl, FIdx.getValueType());
 9911     SDValue Idx = DAG.getConstant(i, dl, BasePtr.getValueType());
10017   SDValue Zero = DAG.getConstant(0, dl, VT);
10073                        Op0.getOperand(0), DAG.getConstant(DWord, dl, MVT::i32));
10095                        DAG.getConstant(0, dl, MVT::i32));
10104                        DAG.getConstant(0, dl, MVT::i32));
11948                          DAG.getConstant(Size, DL, MVT::i32));
11950                          DAG.getConstant(Size, DL, MVT::i32));
11962                              DAG.getConstant(Size - 1, DL, MVT::i32));
11968                         DAG.getConstant(1, DL, MVT::i64));
12572       DAG.getConstant(N->getValueSizeInBits(0) - PromBits, dl, ShiftAmountTy);
12603       return DAG.getSetCC(DL, VT, Add, DAG.getConstant(0, DL, OpVT), CC);
13456                               DAG.getConstant(Shift, dl, MVT::i32));
13479       SDValue Const64 = DAG.getConstant(Val64, dl, MVT::i64);
13723           DAG.getConstant(IncValue, dl, getPointerTy(MF.getDataLayout()));
14052         DAG.getConstant(CompareOpc, dl, MVT::i32)
14076                          DAG.getConstant(CompOpc, dl, MVT::i32),
14110   SDValue ShiftAmt = DAG.getConstant(Lg2, DL, VT);
14116     Op = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Op);
14527         DAG.getConstant(Subtarget.getFrameLowering()->getReturnSaveOffset(), dl,
15156     ShiftBy = DCI.DAG.getConstant(CN1->getZExtValue(), DL, MVT::i32);
15236                               DAG.getConstant(NegConstant, DL, MVT::i64));
15239                                AddOrZ, DAG.getConstant(-1ULL, DL, MVT::i64));
15240     return DAG.getNode(ISD::ADDE, DL, VTs, LHS, DAG.getConstant(0, DL, MVT::i64),
15251                               DAG.getConstant(NegConstant, DL, MVT::i64));
15254                                DAG.getConstant(0, DL, MVT::i64), AddOrZ);
15255     return DAG.getNode(ISD::ADDE, DL, VTs, LHS, DAG.getConstant(0, DL, MVT::i64),
15376                     DAG.getConstant((MulAmtAbs - 1).logBase2(), DL, VT));
15382     return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Res);
15393                     DAG.getConstant((MulAmtAbs + 1).logBase2(), DL, VT));
lib/Target/RISCV/RISCVISelLowering.cpp
  485                        DAG.getConstant(Offset, DL, XLenVT));
  609                        DAG.getConstant(Offset, DL, XLenVT));
  635     SDValue TargetCC = DAG.getConstant(CCVal, DL, XLenVT);
  644   SDValue Zero = DAG.getConstant(0, DL, XLenVT);
  645   SDValue SetNE = DAG.getConstant(ISD::SETNE, DL, XLenVT);
  709     SDValue Offset = DAG.getConstant(Off, DL, VT);
  736   SDValue Zero = DAG.getConstant(0, DL, VT);
  737   SDValue One = DAG.getConstant(1, DL, VT);
  738   SDValue MinusXLen = DAG.getConstant(-(int)Subtarget.getXLen(), DL, VT);
  739   SDValue XLenMinus1 = DAG.getConstant(Subtarget.getXLen() - 1, DL, VT);
  786   SDValue Zero = DAG.getConstant(0, DL, VT);
  787   SDValue One = DAG.getConstant(1, DL, VT);
  788   SDValue MinusXLen = DAG.getConstant(-(int)Subtarget.getXLen(), DL, VT);
  789   SDValue XLenMinus1 = DAG.getConstant(Subtarget.getXLen() - 1, DL, VT);
 2139     SDValue SizeNode = DAG.getConstant(Size, DL, XLenVT);
 2324                              DAG.getConstant(NumBytes, DL, PtrVT, true),
 2325                              DAG.getConstant(0, DL, PtrVT, true),
lib/Target/Sparc/SparcISelLowering.cpp
  246                                   DAG.getConstant(0, DL, getVectorIdxTy(DAG.getDataLayout())));
  249                                   DAG.getConstant(1, DL, getVectorIdxTy(DAG.getDataLayout())));
  281   RetOps[1] = DAG.getConstant(RetAddrOffset, DL, MVT::i32);
  313   RetOps.push_back(DAG.getConstant(8, DL, MVT::i32));
  341                            DAG.getConstant(32, DL, MVT::i32));
  607                           DAG.getConstant(32, DL, MVT::i32));
  761       SDValue SizeNode = DAG.getConstant(Size, dl, MVT::i32);
  863                                   DAG.getConstant(0, dl, getVectorIdxTy(DAG.getDataLayout())));
  866                                   DAG.getConstant(1, dl, getVectorIdxTy(DAG.getDataLayout())));
  996                         DAG.getConstant(0, dl, MVT::i32));
 1002                         DAG.getConstant(1, dl, MVT::i32));
 1196                           DAG.getConstant(32, DL, MVT::i32));
 1323                        DAG.getConstant(32, DL, MVT::i32));
 1983     H44 = DAG.getNode(ISD::SHL, DL, VT, H44, DAG.getConstant(12, DL, MVT::i32));
 1992     Hi = DAG.getNode(ISD::SHL, DL, VT, Hi, DAG.getConstant(32, DL, MVT::i32));
 2247     SDValue Mask   = DAG.getConstant(1, DL, Result.getValueType());
 2280     SDValue Mask   = DAG.getConstant(3, DL, Result.getValueType());
 2287     SDValue Mask   = DAG.getConstant(3, DL, Result.getValueType());
 2461                      DAG.getConstant(SPCC, dl, MVT::i32), CompareFlag);
 2497                      DAG.getConstant(SPCC, dl, MVT::i32), CompareFlag);
 2589                        DAG.getConstant(8, dl, VT));
 2601                                DAG.getConstant(regSpillArea, dl, VT));
 2742                               DAG.getConstant(8, dl, addrVT));
 2810                               DAG.getConstant(8, dl, addrVT));
 2890                                DAG.getConstant(32, dl, MVT::i64));
 2896                                DAG.getConstant(32, dl, MVT::i64));
 2923                    DAG.getConstant(32, dl, MVT::i64));
 2947   SDValue ShiftAmt = DAG.getConstant(63, dl, VT);
 2967     TopHalf = DAG.getSetCC(dl, MVT::i32, TopHalf, DAG.getConstant(0, dl, VT),
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp
 1004       SDValue Mask = CurDAG->getConstant(RISBG.Mask, DL, VT);
 1113   SDValue Upper = CurDAG->getConstant(UpperVal, DL, VT);
 1135   SDValue Lower = CurDAG->getConstant(LowerVal, DL, VT);
 1847                              CurDAG->getConstant(IPM.XORValue, DL, MVT::i32));
 1851                              CurDAG->getConstant(IPM.AddValue, DL, MVT::i32));
 1857                              CurDAG->getConstant(IPM.Bit, DL, MVT::i32));
 1865                                CurDAG->getConstant(IPM.Bit, DL, MVT::i32));
 1867                                CurDAG->getConstant(1, DL, VT));
 1873                                CurDAG->getConstant(ShlAmt, DL, MVT::i32));
 1875                                CurDAG->getConstant(SraAmt, DL, MVT::i32));
lib/Target/SystemZ/SystemZISelLowering.cpp
 1285                        DAG.getConstant(0, DL, MVT::i32));
 1609                              DAG.getConstant(NumBytes, DL, PtrVT, true),
 1610                              DAG.getConstant(0, DL, PtrVT, true),
 1972     C.Op1 = DAG.getConstant(0, DL, C.Op1.getValueType());
 2046     C.Op1 = DAG.getConstant(Value, DL, MVT::i32);
 2152         C.Op1 = DAG.getConstant(0, DL, N->getValueType(0));
 2220         C.Op1 = DAG.getConstant(0, DL, C.Op0.getValueType());
 2422     C.Op1 = DAG.getConstant(MaskVal, DL, C.Op0.getValueType());
 2572                    DAG.getConstant(32, DL, MVT::i64));
 2595   SDValue Ops[] = {DAG.getConstant(1, DL, MVT::i32),
 2596                    DAG.getConstant(0, DL, MVT::i32),
 2730       DAG.getSplatBuildVector(VT, DL, DAG.getConstant(-1, DL, MVT::i64));
 2784                      DAG.getConstant(0, DL, Op.getValueType()), Op);
 2854                          DAG.getConstant(Offset, DL, PtrVT));
 2921                                     DAG.getConstant(32, DL, PtrVT));
 3133                          DAG.getConstant(32, DL, MVT::i64));
 3148                                 DAG.getConstant(32, DL, MVT::i64));
 3169     DAG.getConstant(FuncInfo->getVarArgsFirstGPR(), DL, PtrVT),
 3170     DAG.getConstant(FuncInfo->getVarArgsFirstFPR(), DL, PtrVT),
 3240                               DAG.getConstant(ExtraAlignSpace, DL, MVT::i64));
 3258                   DAG.getConstant(ExtraAlignSpace, DL, MVT::i64));
 3261                   DAG.getConstant(~(RequiredAlign - 1), DL, MVT::i64));
 3308     SDValue C63 = DAG.getConstant(63, DL, MVT::i64);
 3533                       DAG.getConstant(CCValid, DL, MVT::i32),
 3534                       DAG.getConstant(CCMask, DL, MVT::i32));
 3561       SDValue Shift = DAG.getConstant(8, DL, MVT::i32);
 3569                                             DAG.getConstant(0, DL, MVT::i32));
 3575                                             DAG.getConstant(0, DL, MVT::i32));
 3590     return DAG.getConstant(0, DL, VT);
 3605     SDValue Tmp = DAG.getNode(ISD::SHL, DL, VT, Op, DAG.getConstant(I, DL, VT));
 3608                         DAG.getConstant(((uint64_t)1 << BitSize) - 1, DL, VT));
 3615                      DAG.getConstant(BitSize - 8, DL, VT));
 3690       Src2 = DAG.getConstant(-Const->getSExtValue(), DL, Src2.getValueType());
 3695                                     DAG.getConstant(-4, DL, PtrVT));
 3700                                  DAG.getConstant(3, DL, PtrVT));
 3706                                     DAG.getConstant(0, DL, WideVT), BitShift);
 3715                        DAG.getConstant(32 - BitSize, DL, WideVT));
 3719                        DAG.getConstant(uint32_t(-1) >> BitSize, DL, WideVT));
 3724                     DAG.getConstant(BitSize, DL, WideVT) };
 3731                                     DAG.getConstant(BitSize, DL, WideVT));
 3757         NegSrc2 = DAG.getConstant(Value, DL, MemVT);
 3760       NegSrc2 = DAG.getNode(ISD::SUB, DL, MemVT, DAG.getConstant(0, DL, MemVT),
 3811                                     DAG.getConstant(-4, DL, PtrVT));
 3816                                  DAG.getConstant(3, DL, PtrVT));
 3822                                     DAG.getConstant(0, DL, WideVT), BitShift);
 3827                     NegBitShift, DAG.getConstant(BitSize, DL, WideVT) };
 3915                      DAG.getConstant(SystemZ::IPM_CC, DL, MVT::i32));
 4278       IndexNodes[I] = DAG.getConstant(Bytes[I], DL, MVT::i32);
 4718                            DAG.getConstant(I, DL, MVT::i32));
 4791                      Op.getOperand(0), DAG.getConstant(0, DL, MVT::i32));
 4887       SDValue Shift = DAG.getConstant(SplatBits.getZExtValue() & 0xfff,
 5365                        DAG.getConstant(Index, DL, MVT::i32));
 5418       SDValue Ops[] = { DAG.getConstant(TrueOp->getZExtValue(), DL, VT),
 5419                         DAG.getConstant(FalseOp->getZExtValue(), DL, VT),
 5448                       DAG.getConstant(-1, DL, VT), DAG.getConstant(0, DL, VT),
 5448                       DAG.getConstant(-1, DL, VT), DAG.getConstant(0, DL, VT),
 5475                                   DAG.getConstant(NewShlAmt, SDLoc(Inner),
 5478                            DAG.getConstant(NewSraAmt, SDLoc(N0), ShiftVT));
 5548                               Replicate, DAG.getConstant(0, DL, MVT::i32));
 5772                         VRound, DAG.getConstant(2, SDLoc(U), MVT::i32));
 5777                         VRound, DAG.getConstant(0, SDLoc(Op0), MVT::i32));
 5823                         VExtend, DAG.getConstant(1, SDLoc(U), MVT::i32));
 5828                         VExtend, DAG.getConstant(0, SDLoc(Op0), MVT::i32));
lib/Target/SystemZ/SystemZSelectionDAGInfo.cpp
   42                        DAG.getConstant(Size, DL, PtrVT),
   43                        DAG.getConstant(Size / 256, DL, PtrVT));
   45                      DAG.getConstant(Size, DL, PtrVT));
   71       Chain, DL, DAG.getConstant(StoreVal, DL, MVT::getIntegerVT(Size * 8)),
  104                           DAG.getConstant(Size1, DL, PtrVT));
  117                                    DAG.getConstant(1, DL, PtrVT));
  136                                    DAG.getConstant(1, DL, PtrVT));
  159                        DAG.getConstant(Size, DL, PtrVT),
  160                        DAG.getConstant(Size / 256, DL, PtrVT));
  162                      DAG.getConstant(Size, DL, PtrVT));
  173                             DAG.getConstant(30 - SystemZ::IPM_CC, DL, MVT::i32));
  175                             DAG.getConstant(30, DL, MVT::i32));
  203                      DAG.getConstant(255, DL, MVT::i32));
  213       End, DAG.getConstant(0, DL, PtrVT),
  226                                 DAG.getConstant(0, DL, MVT::i32));
  237                                DAG.getConstant(0, DL, MVT::i32));
  255                             Limit, Src, DAG.getConstant(0, DL, MVT::i32));
  265   return getBoundedStrlen(DAG, DL, Chain, Src, DAG.getConstant(0, DL, PtrVT));
lib/Target/WebAssembly/WebAssemblyISelLowering.cpp
  722           DAG.getConstant(Out.Flags.getByValSize(), DL, MVT::i32);
  778                                 DAG.getConstant(Offset, DL, PtrVT));
 1070                      {DAG.getConstant(Depth, DL, MVT::i32)}, CallOptions, DL)
 1279         DAG.getConstant(IndexVal * Scale, DL, Index.getValueType());
 1413           ConstLanes.push_back(DAG.getConstant(0, DL, LaneT));
 1442                            DAG.getConstant(I, DL, MVT::i32));
 1468       Ops[OpIdx++] = DAG.getConstant(ByteIndex, DL, MVT::i32);
 1500       DAG.getConstant(MaskVal, DL, ShiftVal.getValueType()) // mask operand
lib/Target/WebAssembly/WebAssemblySelectionDAGInfo.cpp
   30   SDValue MemIdx = DAG.getConstant(0, DL, MVT::i32);
   54   SDValue MemIdx = DAG.getConstant(0, DL, MVT::i32);
lib/Target/X86/X86ISelDAGToDAG.cpp
 1582   SDValue Eight = DAG.getConstant(8, DL, MVT::i8);
 1583   SDValue NewMask = DAG.getConstant(0xff, DL, VT);
 1586   SDValue ShlCount = DAG.getConstant(ScaleLog, DL, MVT::i8);
 1655   SDValue NewMask = DAG.getConstant(Mask >> ShiftAmt, DL, VT);
 1764   SDValue NewSRLAmt = DAG.getConstant(ShiftAmt + AMShiftAmt, DL, MVT::i8);
 1766   SDValue NewSHLAmt = DAG.getConstant(AMShiftAmt, DL, MVT::i8);
 1819   SDValue NewSRLAmt = DAG.getConstant(ShiftAmt + AMShiftAmt, DL, MVT::i8);
 1821   SDValue NewMask = DAG.getConstant(Mask >> AMShiftAmt, DL, VT);
 1823   SDValue NewSHLAmt = DAG.getConstant(AMShiftAmt, DL, MVT::i8);
 3405   SDValue C8 = CurDAG->getConstant(8, DL, MVT::i8);
 3675       SDValue Zero = CurDAG->getConstant(0, DL, SubVT);
 3698                                 CurDAG->getConstant(Size - 1, DL, MVT::i8));
 3824   SDValue NewCst = CurDAG->getConstant(ShiftedVal, dl, NVT);
lib/Target/X86/X86ISelLowering.cpp
 2455                    DAG.getConstant(0, Dl, MVT::i32));
 2457                    DAG.getConstant(1, Dl, MVT::i32));
 2954   SDValue SizeNode = DAG.getConstant(Flags.getByValSize(), dl, MVT::i32);
 3900                                         DAG.getConstant(NumXMMRegs, dl,
 4027     Ops.push_back(DAG.getConstant(FPDiff, dl, MVT::i32));
 4692         RHS = DAG.getConstant(0, DL, RHS.getValueType());
 4705         RHS = DAG.getConstant(0, DL, RHS.getValueType());
 5379       DAG.getConstant(Values[i], dl, EltVT);
 5383                     DAG.getConstant(0, dl, EltVT));
 5450     Vec = DAG.getConstant(0, dl, VT);
 5453     Vec = DAG.getConstant(0, dl, MVT::getVectorVT(MVT::i32, Num32BitElts));
 5684                      DAG.getConstant(0, dl, WideOpVT),
 5707                          DAG.getConstant(0, dl, WideOpVT),
 5745                         DAG.getConstant(0, dl, WideOpVT),
 7356       return ShufSVT.isInteger() ? DAG.getConstant(0, SDLoc(N), ShufSVT)
 7490                             DAG.getConstant(8, dl, MVT::i8));
 7724                         DAG.getConstant(StartOffset, DL, Ptr.getValueType()));
 7847     return VT.isInteger() ? DAG.getConstant(0, DL, VT)
 7953         SDValue Z = VT.isInteger() ? DAG.getConstant(0, DL, VT)
 8493   return DAG.getConstant(Immediate, dl, VT);
 8539                          DAG.getConstant(1, dl, MVT::i8));
 8541                          DAG.getConstant(1, dl, VT),
 8542                          DAG.getConstant(0, dl, VT));
 8549       SDValue ImmL = DAG.getConstant(Lo_32(Immediate), dl, MVT::i32);
 8550       SDValue ImmH = DAG.getConstant(Hi_32(Immediate), dl, MVT::i32);
 8556       SDValue Imm = DAG.getConstant(Immediate, dl, ImmVT);
 9334                       DAG.getConstant(IndexScale, SDLoc(Idx), SrcVT));
 9336                       DAG.getConstant(IndexOffset, SDLoc(Idx), SrcVT));
 9407         return DAG.getSelectCC(DL, Idx, DAG.getConstant(15, DL, VT),
 9446           DL, IndicesVec, DAG.getConstant(3, DL, MVT::v8i32),
 9482           DL, IndicesVec, DAG.getConstant(2, DL, MVT::v4i64),
 9664         InsIndex = DAG.getConstant(i, dl, getVectorIdxTy(DAG.getDataLayout()));
10056     SDValue Vec = Zeros ? DAG.getConstant(0, dl, ResVT) : DAG.getUNDEF(ResVT);
10554   SDValue ZeroMask = DAG.getConstant(0x80, DL, MVT::i8);
10581     PSHUFBMask[i] = DAG.getConstant(M, DL, MVT::i8);
10608   SDValue MaskNode = DAG.getConstant(VEXPANDMask, DL, IntegerType);
10917     Zero = DAG.getConstant(0, DL, EltVT);
10955   SDValue Zero = DAG.getConstant(0, DL, EltVT);
11111       SDValue MaskNode = DAG.getConstant(BlendMask, DL, IntegerType);
11147                         : DAG.getConstant(Mask[i] < Size ? -1 : 0, DL,
11175     SDValue MaskNode = DAG.getConstant(BlendMask, DL, IntegerType);
12051         PSHUFBMask[i] = DAG.getConstant(Idx, DL, MVT::i8);
12055           AnyExt ? DAG.getUNDEF(MVT::i8) : DAG.getConstant(0x80, DL, MVT::i8);
12403                          DAG.getConstant(OffsetIdx * EltSize, DL, MVT::i8));
13923     V1Mask[i] = DAG.getConstant(V1Idx, DL, MVT::i8);
13924     V2Mask[i] = DAG.getConstant(V2Idx, DL, MVT::i8);
14405     SmallVector<SDValue, 16> ByteClearOps(16, DAG.getConstant(0, DL, MVT::i8));
14407       ByteClearOps[i] = DAG.getConstant(0xFF, DL, MVT::i8);
14450                           DAG.getConstant(0x00FF, DL, MVT::v8i16));
15566                      DAG.getConstant(0, DL, MVT::v32i8), Unpack,
16885                        DAG.getConstant(0, DL, VT),
16965     return DAG.getSetCC(DL, VT, DAG.getConstant(0, DL, ExtVT),
17235                                 DAG.getConstant(0, dl, CondVT),
17471                           DAG.getConstant(ShiftVal, dl, MVT::i8));
17482                         DAG.getConstant(ShiftVal, dl, MVT::i8));
17924                          DAG.getConstant(Offset, dl, PtrVT));
18204           DAG.getConstant(Log2_64_Ceil(DL.getPointerSize()), dl, MVT::i8);
18242                                   DAG.getConstant(VTBits - 1, dl, MVT::i8));
18244                                      DAG.getConstant(VTBits - 1, dl, MVT::i8))
18245                        : DAG.getConstant(0, dl, VT);
18260                                 DAG.getConstant(VTBits, dl, MVT::i8));
18262                              DAG.getConstant(0, dl, MVT::i8), ISD::SETNE);
18320                       DAG.getConstant(15, DL, Amt.getValueType()));
18661   SDValue HalfWord = DAG.getConstant(16, DL, MVT::v4i32);
18662   SDValue HalfWordMask = DAG.getConstant(0x0000FFFF, DL, MVT::v4i32);
18723   SDValue VecCstLow = DAG.getConstant(0x4b000000, DL, VecIntVT);
18725   SDValue VecCstHigh = DAG.getConstant(0x53000000, DL, VecIntVT);
18728   SDValue VecCstShift = DAG.getConstant(16, DL, VecIntVT);
18750     SDValue VecCstMask = DAG.getConstant(0xffff, DL, VecIntVT);
18837     SDValue Store2 = DAG.getStore(Store1, dl, DAG.getConstant(0, dl, MVT::i32),
18872       Op.getOperand(0), DAG.getConstant(0, dl, MVT::i64), ISD::SETLT);
18983                            DAG.getConstant(0, DL, MVT::i64),
19086   SDValue ZeroVec = DAG.getConstant(0, dl, InVT);
19124                        DAG.getConstant(VT.getScalarSizeInBits() - 1, DL, VT));
19148   SDValue One = DAG.getConstant(1, DL, WideVT);
19149   SDValue Zero = DAG.getConstant(0, DL, WideVT);
19310                          DAG.getConstant(ShiftInx, DL, ExtVT));
19313       return DAG.getSetCC(DL, VT, DAG.getConstant(0, DL, InVT),
19357                      DAG.getConstant(ShiftInx, DL, InVT));
19361     return DAG.getSetCC(DL, VT, DAG.getConstant(0, DL, InVT), In, ISD::SETGT);
19362   return DAG.getSetCC(DL, VT, In, DAG.getConstant(0, DL, InVT), ISD::SETNE);
19502     In = DAG.getNode(ISD::AND, DL, InVT, In, DAG.getConstant(255, DL, InVT));
19881   Res = DAG.getNode(ISD::AND, dl, VT, Res, DAG.getConstant(1, dl, VT));
20057                        DAG.getConstant(0, dl, Op.getValueType()));
20122                        DAG.getConstant(0, dl, Op.getValueType()));
20206                             DAG.getConstant(8, dl, MVT::i8));
20335   SDValue Zero = DAG.getConstant(0, DL, VT);
20350       DAG.getNode(ISD::SRA, DL, VT, CMov, DAG.getConstant(Lg2, DL, MVT::i64));
20406         BitNo = DAG.getConstant(Log2_64_Ceil(AndRHSVal), dl,
20623                      DAG.getConstant(0, dl, VT));
20768                            DAG.getConstant(ShiftAmt, dl, VT));
20770                            DAG.getConstant(BitWidth - 1, dl, VT));
20868         SB = DAG.getConstant(0x8000000080000000ULL, dl, MVT::v2i64);
20870         SB = DAG.getConstant(0x0000000080000000ULL, dl, MVT::v2i64);
21341         SDValue Zero = DAG.getConstant(0, DL, CmpOp0.getValueType());
21344         Zero = DAG.getConstant(0, DL, Op.getValueType());
21349                         CmpOp0, DAG.getConstant(1, DL, CmpOp0.getValueType()));
21353       SDValue Zero = DAG.getConstant(0, DL, Op.getValueType());
21392               DAG.getConstant(1, DL, VT));
21395         SDValue Mask = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
21457     Cond = EmitCmp(Cond, DAG.getConstant(0, DL, Cond.getValueType()),
21556     SDValue NegOne = DAG.getConstant(-1, dl, WideVT);
21557     SDValue Zero = DAG.getConstant(0, dl, WideVT);
21694     SDValue Zero = DAG.getConstant(0, dl, MVT::v4i32);
22177     Cond = EmitCmp(Cond, DAG.getConstant(0, dl, Cond.getValueType()),
22228                          DAG.getConstant(-(uint64_t)Align, dl, VT));
22261                        DAG.getConstant(-(uint64_t)Align, dl, VT));
22302       DAG.getConstant(FuncInfo->getVarArgsGPOffset(), DL, MVT::i32), FIN,
22310       DAG.getConstant(FuncInfo->getVarArgsFPOffset(), DL, MVT::i32), FIN,
22375   SDValue InstOps[] = {Chain, SrcPtr, DAG.getConstant(ArgSize, dl, MVT::i32),
22376                        DAG.getConstant(ArgMode, dl, MVT::i8),
22377                        DAG.getConstant(Align, dl, MVT::i32)};
22454       return DAG.getConstant(0, dl, VT);
22569     SDValue ShOps[4] = {ShAmt, DAG.getConstant(0, dl, SVT), DAG.getUNDEF(SVT),
22590     return DAG.getConstant(1, dl, MaskVT);
22592     return DAG.getConstant(0, dl, MaskVT);
22602                         DAG.getConstant(0, dl, MVT::i32));
22604                         DAG.getConstant(1, dl, MVT::i32));
22733                                     DAG.getConstant(RegNodeSize, dl, PtrVT));
23097                                 DAG.getConstant(0, dl, MVT::v8i1),
23143                                 DAG.getConstant(0, dl, MVT::v8i1),
23203                                 DAG.getConstant(0, dl, MVT::v16i1),
23221         PassThru = DAG.getConstant(0, dl, VT);
23279       SDValue Control = DAG.getConstant(Imm, dl, Op.getValueType());
23296                                     DAG.getConstant(-1, dl, MVT::i8));
23347         PassThru = DAG.getConstant(0, dl, PassThru.getValueType());
23664                        DAG.getConstant(NewIntrinsic, DL, MVT::i32),
23834                               DAG.getConstant(32, DL, MVT::i8));
23959                          DAG.getConstant(0, dl, MVT::i32));
23967                          DAG.getConstant(0, dl, MVT::i32),
23968                          DAG.getConstant(0, dl, MVT::i32));
24049                      DAG.getConstant(1, dl, Op->getValueType(1)),
24194     SDValue Offset = DAG.getConstant(RegInfo->getSlotSize(), dl, PtrVT);
24396     OutChains[0] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, dl, MVT::i16),
24400                        DAG.getConstant(2, dl, MVT::i64));
24409                        DAG.getConstant(10, dl, MVT::i64));
24410     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, dl, MVT::i16),
24414                        DAG.getConstant(12, dl, MVT::i64));
24422                        DAG.getConstant(20, dl, MVT::i64));
24423     OutChains[4] = DAG.getStore(Root, dl, DAG.getConstant(OpCode, dl, MVT::i16),
24428                        DAG.getConstant(22, dl, MVT::i64));
24429     OutChains[5] = DAG.getStore(Root, dl, DAG.getConstant(ModRM, dl, MVT::i8),
24485                        DAG.getConstant(10, dl, MVT::i32));
24492         DAG.getStore(Root, dl, DAG.getConstant(MOV32ri | N86Reg, dl, MVT::i8),
24496                        DAG.getConstant(1, dl, MVT::i32));
24503                        DAG.getConstant(5, dl, MVT::i32));
24504     OutChains[2] = DAG.getStore(Root, dl, DAG.getConstant(JMP, dl, MVT::i8),
24509                        DAG.getConstant(6, dl, MVT::i32));
24567                             CWD, DAG.getConstant(0x800, DL, MVT::i16)),
24568                 DAG.getConstant(11, DL, MVT::i8));
24572                             CWD, DAG.getConstant(0x400, DL, MVT::i16)),
24573                 DAG.getConstant(9, DL, MVT::i8));
24579                             DAG.getConstant(1, DL, MVT::i16)),
24580                 DAG.getConstant(3, DL, MVT::i16));
24653   SDValue Delta = DAG.getConstant(32 - EltVT.getSizeInBits(), dl, VT);
24675     LUTVec.push_back(DAG.getConstant(LUT[i % 16], DL, MVT::i8));
24684   SDValue Zero = DAG.getConstant(0, DL, CurrVT);
24686   SDValue NibbleShift = DAG.getConstant(0x4, DL, CurrVT);
24713     SDValue Shift = DAG.getConstant(CurrScalarSizeInBits, DL, NextVT);
24787     SDValue Ops[] = {Op, DAG.getConstant(NumBits + NumBits - 1, dl, OpVT),
24795                    DAG.getConstant(NumBits - 1, dl, OpVT));
24817   SDValue Ops[] = {Op, DAG.getConstant(NumBits, dl, VT),
24933       return DAG.getSelect(DL, VT, Cmp, Sub, DAG.getConstant(0, DL, VT));
24954                               DAG.getConstant(0, DL, VT), N0);
24965         DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Src);
25081     RLo = DAG.getNode(ISD::AND, dl, ExVT, RLo, DAG.getConstant(255, dl, ExVT));
25082     RHi = DAG.getNode(ISD::AND, dl, ExVT, RHi, DAG.getConstant(255, dl, ExVT));
25138   SDValue Zero = DAG.getConstant(0, dl, VT);
25228       SDValue Zero = DAG.getConstant(0, dl, VT);
25325                                           DAG.getConstant(0, dl, VT)));
25327                                           DAG.getConstant(0, dl, VT)));
25367                                           DAG.getConstant(0, dl, VT)));
25369                                           DAG.getConstant(0, dl, VT)));
25503       return DAG.getNode(X86ISD::PCMPGT, dl, VT, DAG.getConstant(0, dl, VT), R);
25564       SDValue Zeros = DAG.getConstant(0, dl, VT);
25593                          DAG.getConstant(uint8_t(-1U) >> ShiftAmt, dl, VT));
25599       SDValue Mask = DAG.getConstant(128 >> ShiftAmt, dl, VT);
25646         SDValue BitMask = DAG.getConstant(-1, dl, ExtVT);
25665           SDValue SignMask = DAG.getConstant(0x8080, dl, ExtVT);
25736     Amt = DAG.getNode(ISD::SHL, dl, VT, Amt, DAG.getConstant(23, dl, VT));
25738                       DAG.getConstant(0x3f800000U, dl, VT));
25745     SDValue Z = DAG.getConstant(0, dl, VT);
25791       SDValue Zero = DAG.getConstant(0, dl, VT);
25887     SDValue EltBits = DAG.getConstant(EltSizeInBits, dl, VT);
25890       SDValue Zero = DAG.getConstant(0, dl, VT);
25906     SDValue EltBits = DAG.getConstant(EltSizeInBits, dl, VT);
25910           DAG.getSetCC(dl, VT, Amt, DAG.getConstant(0, dl, VT), ISD::SETEQ);
25912           DAG.getSetCC(dl, VT, Amt, DAG.getConstant(1, dl, VT), ISD::SETEQ);
25939         SDValue Z = DAG.getConstant(0, dl, VT);
26010     Amt = DAG.getNode(ISD::SUB, dl, ExVT, DAG.getConstant(8, dl, ExVT), Amt);
26011     Amt = DAG.getNode(ISD::SHL, dl, ExVT, DAG.getConstant(1, dl, ExVT), Amt);
26060         Sel = DAG.getSetCC(dl, MaskVT, DAG.getConstant(0, dl, VT), Sel,
26074       SDValue Z = DAG.getConstant(0, dl, SelVT);
26088       SDValue M = DAG.getNode(Opc, dl, VT, R, DAG.getConstant(4, dl, VT));
26095       M = DAG.getNode(Opc, dl, VT, R, DAG.getConstant(2, dl, VT));
26102       M = DAG.getNode(Opc, dl, VT, R, DAG.getConstant(1, dl, VT));
26156     SDValue Z = DAG.getConstant(0, dl, VT);
26340       SDValue Z = DAG.getConstant(0, DL, SelVT);
26349     Amt = DAG.getNode(ISD::SHL, DL, ExtVT, Amt, DAG.getConstant(5, DL, ExtVT));
26356         DAG.getNode(ISD::SHL, DL, VT, R, DAG.getConstant(4, DL, VT)),
26357         DAG.getNode(ISD::SRL, DL, VT, R, DAG.getConstant(4, DL, VT)));
26366         DAG.getNode(ISD::SHL, DL, VT, R, DAG.getConstant(2, DL, VT)),
26367         DAG.getNode(ISD::SRL, DL, VT, R, DAG.getConstant(6, DL, VT)));
26376         DAG.getNode(ISD::SHL, DL, VT, R, DAG.getConstant(1, DL, VT)),
26377         DAG.getNode(ISD::SRL, DL, VT, R, DAG.getConstant(7, DL, VT)));
26383                     DAG.getConstant(EltSizeInBits - 1, DL, VT));
26392     SDValue AmtR = DAG.getConstant(EltSizeInBits, DL, VT);
26740                      DAG.getConstant(32, DL, MVT::i8));
26749                      DAG.getConstant(16, DL, MVT::i8));
26854     SDValue Zeros = DAG.getConstant(0, DL, ByteVecVT);
26866     SDValue Zeros = DAG.getConstant(0, DL, VT);
26872     Zeros = DAG.getConstant(0, DL, ByteVecVT);
26895   SDValue ShifterV = DAG.getConstant(8, DL, VT);
26928     LUTVec.push_back(DAG.getConstant(LUT[i % 16], DL, MVT::i8));
26930   SDValue M0F = DAG.getConstant(0x0F, DL, VT);
26933   SDValue FourV = DAG.getConstant(4, DL, VT);
27034       MaskElts.push_back(DAG.getConstant(PermuteByte, DL, MVT::i8));
27075   SDValue NibbleMask = DAG.getConstant(0xF, DL, VT);
27077   SDValue Hi = DAG.getNode(ISD::SRL, DL, VT, In, DAG.getConstant(4, DL, VT));
27092     LoMaskElts.push_back(DAG.getConstant(LoLUT[i % 16], DL, MVT::i8));
27093     HiMaskElts.push_back(DAG.getConstant(HiLUT[i % 16], DL, MVT::i8));
27152       RHS = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), RHS);
27372     SDValue FillVal = FillWithZeroes ? DAG.getConstant(0, dl, EltVT) :
27378   SDValue FillVal = FillWithZeroes ? DAG.getConstant(0, dl, NVT) :
27906                      DAG.getConstant(0, dl, HalfT));
27908                      DAG.getConstant(1, dl, HalfT));
27911         DAG.getConstant(HalfT.getSizeInBits() - 1, dl,
28061       SDValue Zero = DAG.getConstant(0, dl, MVT::v4i32);
28286                         DAG.getConstant(0, dl, HalfT));
28288                         DAG.getConstant(1, dl, HalfT));
28297                           DAG.getConstant(0, dl, HalfT));
28299                           DAG.getConstant(1, dl, HalfT));
32663           M < 0 ? DAG.getUNDEF(MVT::i32) : DAG.getConstant(M % 4, DL, MVT::i32);
32726         PSHUFBMask.push_back(DAG.getConstant(255, DL, MVT::i8));
32731       PSHUFBMask.push_back(DAG.getConstant(M, DL, MVT::i8));
32757         VPPERMMask.push_back(DAG.getConstant(128, DL, MVT::i8));
32761       VPPERMMask.push_back(DAG.getConstant(M, DL, MVT::i8));
34873         return TLO.CombineTo(Op, TLO.DAG.getConstant(0, SDLoc(Op), VT));
34962       return TLO.CombineTo(Op, TLO.DAG.getConstant(0, SDLoc(Op), VT));
35117     return EltVT.isInteger() ? DAG.getConstant(0, SDLoc(N), EltVT)
35425             DAG.getConstant(Intrinsic::x86_mmx_punpcklbw, DL, MVT::i32), Splat,
35448     SDValue Intrin = DAG.getConstant(IntrinOp, DL, MVT::i32);
35521           Ops.resize(NumConcats, DAG.getConstant(0, dl, SrcVT));
35643       return DAG.getConstant(1, SDLoc(N0), VT);
35645       return DAG.getConstant(0, SDLoc(N0), VT);
35725   SmallVector<SDValue, 16> Ops(NumConcat, DAG.getConstant(0, DL, InVT));
35804         SrcVT, DL, MinPos, DAG.getConstant(0, DL, MVT::v16i8),
35923     SDValue Mask = DAG.getConstant(1, DL, CmpVT);
35933     CmpC = DAG.getConstant(0, DL, CmpVT);
35948   SDValue Zero = DAG.getConstant(0, DL, ExtractVT);
36134                                 : DAG.getConstant(0, dl, VT);
36297                           DAG.getConstant(0, DL, MVT::v4i32), Rdx,
36302                           DAG.getConstant(0, DL, VecVT));
36311                       DAG.getConstant(0, DL, MVT::v16i8));
36394     return IsPextr ? DAG.getConstant(0, dl, VT) : DAG.getUNDEF(VT);
36405         return IsPextr ? DAG.getConstant(0, dl, VT) : DAG.getUNDEF(VT);
36546     return DAG.getConstant(0, DL, VT);
37133             OpRHS = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
37625                            DAG.getConstant(ShAmt, DL, MVT::i8));
37935                                  DAG.getConstant(Mult, DL, VT));
37937                          DAG.getConstant(Shift, DL, MVT::i8));
37945                                  DAG.getConstant(Mul1, DL, VT));
37947                          DAG.getConstant(Mul2, DL, VT));
38006                                    DAG.getConstant(ShiftAmt, DL, MVT::i8));
38008                                    DAG.getConstant(ScaleShift, DL, MVT::i8));
38149                                  DAG.getConstant(AbsMulAmt, DL, VT));
38151       NewMul = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
38187                            DAG.getConstant(Log2_64(MulAmt1), DL, MVT::i8));
38190                            DAG.getConstant(MulAmt1, DL, VT));
38194                            DAG.getConstant(Log2_64(MulAmt2), DL, MVT::i8));
38197                            DAG.getConstant(MulAmt2, DL, VT));
38201       NewMul = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
38216                       DAG.getConstant(Log2_64(AbsMulAmt - 1), DL,
38221                              DAG.getConstant(0, DL, VT), NewMul);
38225                            DAG.getConstant(Log2_64(AbsMulAmt + 1),
38235                            DAG.getConstant(Log2_64(AbsMulAmt - 2),
38242                            DAG.getConstant(Log2_64(AbsMulAmt + 2),
38525     return DAG.getConstant(0, SDLoc(N), VT);
38567       return DAG.getConstant(0, SDLoc(N), VT);
38578     return DAG.getConstant(0, SDLoc(N), VT);
38712                                       DAG.getConstant(0, DL, MVT::v16i1),
38740                                       DAG.getConstant(1, DL, IntVT));
39015           SDValue SizeC = DAG.getConstant(VT.getSizeInBits(), dl, MVT::i32);
39071                                          DAG.getConstant(32, DL, MVT::i8)));
39078                                  DAG.getConstant(1, DL, MVT::i32));
39085                              DAG.getConstant(16, DL, MVT::i8));
39093                                        DAG.getConstant(8, DL, MVT::i8)));
39162                               DAG.getConstant(0, dl, SubVecVT));
39500                             DAG.getConstant(Log2b, dl, MVT::i8));
39813                               DAG.getConstant(-1, DL, ShiftOpTy), ISD::SETGT);
40143     SDValue VecOnes = DAG.getConstant(1, DL, InVT);
42066     return DAG.getConstant(0, SDLoc(N), VT);
42251   SDValue NewConstant = DAG.getConstant(AddConstant, SDLoc(Add), VT);
42404                      DAG.getConstant(EltSizeInBits - 1, DL, VT));
42474     return DAG.getNode(ISD::SUB, DL, VT, Zext, DAG.getConstant(1, DL, VT));
42595                          DAG.getConstant(1, dl, VT));
42607                          DAG.getConstant(1, dl, VT));
42748                          DAG.getConstant(0, DL, VecVT), X,
42749                          DAG.getConstant(0, DL, VecIdxVT));
42791                           DAG.getConstant(0, DL, KRegVT), CC);
42807     SDValue FFFFs = DAG.getConstant(OpSize == 128 ? 0xFFFF : 0xFFFFFFFF, DL,
42830       return DAG.getSetCC(DL, VT, Add, DAG.getConstant(0, DL, OpVT), CC);
42837       return DAG.getSetCC(DL, VT, Add, DAG.getConstant(0, DL, OpVT), CC);
42861         return DAG.getConstant(0, DL, VT);
42863         return DAG.getConstant(1, DL, VT);
43385                            DAG.getConstant(0, dl, VT));
43437                        DAG.getConstant(0, dl, VT));
43457     return DAG.getMergeValues({Res, DAG.getConstant(0, DL, MVT::i32)}, DL);
43467         Op = DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), Op);
43511     SDValue CarryOut = DAG.getConstant(0, DL, N->getValueType(1));
43517                     DAG.getConstant(1, DL, VT));
43606                        DAG.getConstant(0, DL, VT), Y.getOperand(1));
43626                          DAG.getConstant(0, DL, VT), NewEFLAGS);
43651       SDValue Zero = DAG.getConstant(0, DL, ZVT);
43665       SDValue One = DAG.getConstant(1, DL, ZVT);
43673   SDValue One = DAG.getConstant(1, DL, ZVT);
43683                        DAG.getConstant(-1ULL, DL, VT), Cmp1);
43688                      DAG.getConstant(0, DL, VT), Cmp1);
43744   SDValue Zero = DAG.getConstant(0, DL, Madd.getSimpleValueType());
43814     SmallVector<SDValue, 4> Ops(NumConcats, DAG.getConstant(0, DL, ResVT));
44257       return DAG.getConstant(-1, DL, VT);
44259       return DAG.getConstant(0, DL, VT);
44633       return DAG.getConstant(1, SDLoc(N), VT);
44800     return DAG.getConstant(0, SDLoc(N), N->getValueType(0));
lib/Target/X86/X86SelectionDAGInfo.cpp
  144     Chain = DAG.getCopyToReg(Chain, dl, ValReg, DAG.getConstant(Val, dl, AVT),
  174                                       DAG.getConstant(Offset, dl, AddrVT)),
  176                           DAG.getConstant(BytesLeft, dl, SizeVT),
  284       DAG.getNode(ISD::ADD, dl, DstVT, Dst, DAG.getConstant(Offset, dl, DstVT)),
  285       DAG.getNode(ISD::ADD, dl, SrcVT, Src, DAG.getConstant(Offset, dl, SrcVT)),
  286       DAG.getConstant(BytesLeft, dl, SizeVT), Align, isVolatile,
lib/Target/XCore/XCoreISelLowering.cpp
  291       SDValue Remaining = DAG.getConstant(Offset - FoldedOffset, DL, MVT::i32);
  361                                     DAG.getConstant(1, dl, MVT::i32));
  385                           DAG.getConstant(LowOffset, DL, MVT::i32));
  387                            DAG.getConstant(HighOffset, DL, MVT::i32));
  389   SDValue LowShift = DAG.getConstant((Offset - LowOffset) * 8, DL, MVT::i32);
  390   SDValue HighShift = DAG.getConstant((HighOffset - Offset) * 8, DL, MVT::i32);
  450                                    DAG.getConstant(2, DL, MVT::i32));
  456                                       DAG.getConstant(16, DL, MVT::i32));
  503                                DAG.getConstant(16, dl, MVT::i32));
  508                                    DAG.getConstant(2, dl, MVT::i32));
  546   SDValue Zero = DAG.getConstant(0, dl, MVT::i32);
  563   SDValue Zero = DAG.getConstant(0, dl, MVT::i32);
  648                    Mul.getOperand(0), DAG.getConstant(0, dl, MVT::i32));
  650                    Mul.getOperand(1), DAG.getConstant(0, dl, MVT::i32));
  652                         Other, DAG.getConstant(0, dl, MVT::i32));
  654                         Other, DAG.getConstant(1, dl, MVT::i32));
  677                    Mul.getOperand(0), DAG.getConstant(1, dl, MVT::i32));
  679                    Mul.getOperand(1), DAG.getConstant(1, dl, MVT::i32));
  707                              DAG.getConstant(0, dl, MVT::i32));
  710                              DAG.getConstant(1, dl, MVT::i32));
  713                              DAG.getConstant(0, dl, MVT::i32));
  716                              DAG.getConstant(1, dl, MVT::i32));
  721   SDValue Zero = DAG.getConstant(0, dl, MVT::i32);
  885       DAG.getStore(Chain, dl, DAG.getConstant(0x0a3cd805, dl, MVT::i32), Addr,
  889                      DAG.getConstant(4, dl, MVT::i32));
  891       DAG.getStore(Chain, dl, DAG.getConstant(0xd80456c0, dl, MVT::i32), Addr,
  895                      DAG.getConstant(8, dl, MVT::i32));
  897       DAG.getStore(Chain, dl, DAG.getConstant(0x27fb0a3c, dl, MVT::i32), Addr,
  901                      DAG.getConstant(12, dl, MVT::i32));
  906                      DAG.getConstant(16, dl, MVT::i32));
 1088     SDValue Ops[] = { Chain, DAG.getConstant(offset / 4, dl, MVT::i32) };
 1171                                         DAG.getConstant(Offset/4, dl,
 1222   Chain = DAG.getCALLSEQ_END(Chain, DAG.getConstant(NumBytes, dl, PtrVT, true),
 1223                              DAG.getConstant(0, dl, PtrVT, true), InFlag, dl);
 1399                                      DAG.getConstant(Size, dl, MVT::i32),
 1464   RetOps.push_back(DAG.getConstant(0, dl, MVT::i32));
 1647       SDValue Carry = DAG.getConstant(0, dl, VT);
 1649                                    DAG.getConstant(1, dl, VT));
 1661         SDValue Carry = DAG.getConstant(0, dl, VT);
 1685                                      DAG.getConstant(0, dl, VT), N2);
 1698         SDValue Borrow = DAG.getConstant(0, dl, VT);
 1764                                   Mul0, DAG.getConstant(0, dl, MVT::i32));
 1766                                   Mul1, DAG.getConstant(0, dl, MVT::i32));
 1768                                      Addend0, DAG.getConstant(0, dl, MVT::i32));
 1770                                      Addend1, DAG.getConstant(0, dl, MVT::i32));
 1804                               DAG.getConstant(StoreBits/8, dl, MVT::i32),
unittests/CodeGen/AArch64SelectionDAGTest.cpp
   88   auto InVec = DAG->getConstant(0, Loc, InVecVT);
  102   auto Vec = DAG->getConstant(0, Loc, VecVT);
  103   auto ZeroIdx = DAG->getConstant(0, Loc, IdxVT);
  118   auto InVec = DAG->getConstant(1, Loc, InVecVT);
  131   auto Vec = DAG->getConstant(1, Loc, VecVT);
  132   auto ZeroIdx = DAG->getConstant(0, Loc, IdxVT);
  148   auto Vec = DAG->getConstant(1, Loc, VecVT);
  149   auto ZeroIdx = DAG->getConstant(0, Loc, IdxVT);
  167   auto Mask = DAG->getConstant(0x8A, Loc, IntVT);
  169   auto N1 = DAG->getConstant(0x55, Loc, IntVT);
  187   auto N0 = DAG->getConstant(0x55, Loc, IntVT);
  189   auto Mask = DAG->getConstant(0x2e, Loc, IntVT);