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

References

gen/lib/Target/AMDGPU/AMDGPUGenDAGISel.inc
78717   assert(N->getOperand(0).getValueType().getSizeInBits() == 16);
gen/lib/Target/Mips/MipsGenDAGISel.inc
30283   return selectVSplat(N, Imm, EltTy.getSizeInBits()) &&
30284          Imm.getBitWidth() == EltTy.getSizeInBits() && Imm == 1;
30311   return selectVSplat(BV, Imm, EltTy.getSizeInBits()) &&
30312          Imm.getBitWidth() == EltTy.getSizeInBits() && Imm == 1;
30324   return selectVSplat(BV, Imm, EltTy.getSizeInBits()) &&
30325          Imm.getBitWidth() == EltTy.getSizeInBits() && Imm == 63;
include/llvm/CodeGen/SelectionDAGNodes.h
  174     return getValueType().getSizeInBits();
  178     return getValueType().getScalarType().getSizeInBits();
 1026     return getValueType(ResNo).getSizeInBits();
include/llvm/CodeGen/TargetLowering.h
 1335       unsigned BitWidth = VT.getSizeInBits();
include/llvm/CodeGen/ValueTypes.h
  119         return MVT::getIntegerVT(getSizeInBits());
  212       return (getSizeInBits() & 7) == 0;
  217       unsigned BitSize = getSizeInBits();
  224       return getSizeInBits() == VT.getSizeInBits();
  224       return getSizeInBits() == VT.getSizeInBits();
  230       return getSizeInBits() > VT.getSizeInBits();
  230       return getSizeInBits() > VT.getSizeInBits();
  236       return getSizeInBits() >= VT.getSizeInBits();
  236       return getSizeInBits() >= VT.getSizeInBits();
  242       return getSizeInBits() < VT.getSizeInBits();
  242       return getSizeInBits() < VT.getSizeInBits();
  248       return getSizeInBits() <= VT.getSizeInBits();
  248       return getSizeInBits() <= VT.getSizeInBits();
  298       return getScalarType().getSizeInBits();
  304       return (getSizeInBits() + 7) / 8;
  318       unsigned BitWidth = getSizeInBits();
  329       unsigned EVTSize = getSizeInBits();
  333         if (HalfVT.getSizeInBits() * 2 >= EVTSize)
  343       EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
lib/CodeGen/AtomicExpandPass.cpp
  365   assert(BitWidth == VT.getSizeInBits() && "must be a power of two");
lib/CodeGen/CodeGenPrepare.cpp
 5719   unsigned BitWidth = LoadResultVT.getSizeInBits();
 5764       unsigned TruncBitWidth = TruncVT.getSizeInBits();
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
 4574       VT.getSizeInBits() <= 64) {
 4584             SRLC.ult(VT.getSizeInBits()) &&
 4586           APInt Mask = APInt::getHighBitsSet(VT.getSizeInBits(),
 4611         unsigned Size = VT.getSizeInBits();
 4713   if (LDST->getMemoryVT().getSizeInBits() < MemVT.getSizeInBits())
 4713   if (LDST->getMemoryVT().getSizeInBits() < MemVT.getSizeInBits())
 4751         Load->getMemoryVT().getSizeInBits() < MemVT.getSizeInBits() + ShAmt)
 4751         Load->getMemoryVT().getSizeInBits() < MemVT.getSizeInBits() + ShAmt)
 4760     if (Store->getMemoryVT().getSizeInBits() < MemVT.getSizeInBits() + ShAmt)
 4760     if (Store->getMemoryVT().getSizeInBits() < MemVT.getSizeInBits() + ShAmt)
 5017   unsigned VTBitWidth = VT.getSizeInBits();
 5411   unsigned OpSizeInBits = VT.getSizeInBits();
 6394     unsigned NarrowBitWidth = L->getMemoryVT().getSizeInBits();
 6490     *DAG.getContext(), Width * N->getMemoryVT().getSizeInBits());
 6546       if (CombinedValue.getValueSizeInBits() < VT.getSizeInBits())
 6600     assert(CombinedValue.getValueType().getSizeInBits() > VT.getSizeInBits() &&
 6600     assert(CombinedValue.getValueType().getSizeInBits() > VT.getSizeInBits() &&
 6656   unsigned ByteWidth = VT.getSizeInBits() / 8;
 6668     unsigned LoadBitWidth = P.Load->getMemoryVT().getSizeInBits();
 8939   unsigned VTBits = SVT.getSizeInBits();
 9211   Mask = Mask.zext(VT.getSizeInBits());
 9258   if (SetCCVT.getSizeInBits() != VT.getSizeInBits())
 9258   if (SetCCVT.getSizeInBits() != VT.getSizeInBits())
 9403     SDValue ShiftAmount = DAG.getConstant(VT.getSizeInBits() - 1, DL, VT);
 9514         Mask = Mask.sext(VT.getSizeInBits());
 9565         if (VT.getSizeInBits() == SVT.getSizeInBits())
 9565         if (VT.getSizeInBits() == SVT.getSizeInBits())
 9783     Mask = Mask.zext(VT.getSizeInBits());
 9838         Mask = Mask.zext(VT.getSizeInBits());
 9892       if (VT.getSizeInBits() == N00VT.getSizeInBits()) {
 9892       if (VT.getSizeInBits() == N00VT.getSizeInBits()) {
 9938     if (VT.getSizeInBits() >= 256)
 9999     Mask = Mask.zext(VT.getSizeInBits());
10073       if (VT.getSizeInBits() == N00VT.getSizeInBits())
10073       if (VT.getSizeInBits() == N00VT.getSizeInBits())
10197     uint64_t MemoryWidth = LN0->getMemoryVT().getSizeInBits();
10202                                 VT.getSizeInBits() - ShiftAmt);
10229       unsigned EVTBits = ExtVT.getSizeInBits();
10252       if (ShAmt >= LN0->getMemoryVT().getSizeInBits())
10266           if ((ExtVT.getSizeInBits() > MaskedVT.getSizeInBits()) &&
10266           if ((ExtVT.getSizeInBits() > MaskedVT.getSizeInBits()) &&
10339     if (!isUIntN(ShImmTy.getSizeInBits(), ShLeftAmt))
10345     if (ShLeftAmt >= VT.getSizeInBits())
10594     unsigned SizeRatio = ExTy.getSizeInBits()/TrTy.getSizeInBits();
10594     unsigned SizeRatio = ExTy.getSizeInBits()/TrTy.getSizeInBits();
10597     assert(NVT.getSizeInBits() == VecTy.getSizeInBits() && "Invalid Size");
10597     assert(NVT.getSizeInBits() == VecTy.getSizeInBits() && "Invalid Size");
10694         APInt::getLowBitsSet(N0.getValueSizeInBits(), VT.getSizeInBits());
10710           LN0->getMemoryVT().getStoreSizeInBits() < VT.getSizeInBits()) {
11042       assert(VT.getSizeInBits() == 128);
11044           APInt::getSignMask(VT.getSizeInBits() / 2), SDLoc(N0), MVT::i64);
11064     APInt SignBit = APInt::getSignMask(VT.getSizeInBits());
11094       unsigned VTWidth = VT.getSizeInBits();
11112         APInt SignBit = APInt::getSignMask(VT.getSizeInBits() / 2);
11133       APInt SignBit = APInt::getSignMask(VT.getSizeInBits());
11212   unsigned SrcBitSize = SrcEltVT.getSizeInBits();
11213   unsigned DstBitSize = DstEltVT.getSizeInBits();
11238     EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), SrcEltVT.getSizeInBits());
11246     EVT TmpVT = EVT::getIntegerVT(*DAG.getContext(), DstEltVT.getSizeInBits());
13182         SignMask = APInt::getSplat(IntVT.getSizeInBits(), SignMask);
13185         SignMask = APInt::getSignMask(IntVT.getSizeInBits());
13280         SignMask = APInt::getSplat(IntVT.getSizeInBits(), SignMask);
13283         SignMask = ~APInt::getSignMask(IntVT.getSizeInBits());
13899   if (STType.getSizeInBits() == STMemType.getSizeInBits()) {
13899   if (STType.getSizeInBits() == STMemType.getSizeInBits()) {
13963       (Offset * 8 + LDMemType.getSizeInBits() <= STMemType.getSizeInBits());
13963       (Offset * 8 + LDMemType.getSizeInBits() <= STMemType.getSizeInBits());
13984     if (LDType.getSizeInBits() == LDMemType.getSizeInBits())
13984     if (LDType.getSizeInBits() == LDMemType.getSizeInBits())
13991           DAG.getConstant(APInt::getLowBitsSet(STType.getSizeInBits(),
13992                                                STMemType.getSizeInBits()),
14978     EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
15140                 EVT::getIntegerVT(*DAG.getContext(), MemVT.getSizeInBits());
15219         if (MemVT.getSizeInBits() != ElementSizeBits)
15242     unsigned LegalizedStoreSize = LegalizedStoredValTy.getSizeInBits();
15493   if (MemVT.getSizeInBits() * 2 > MaximumLegalStoreInBits)
15500   if (ElementSizeBytes * 8 != MemVT.getSizeInBits())
15613           if (StoreTy.getSizeInBits() > MaximumLegalStoreInBits)
15717           if (Ty.getSizeInBits() > MaximumLegalStoreInBits)
15847         if (StoreTy.getSizeInBits() > MaximumLegalStoreInBits)
16248         unsigned STBitSize = ST->getMemoryVT().getSizeInBits();
16249         unsigned ChainBitSize = ST1->getMemoryVT().getSizeInBits();
16552   unsigned ExtendRatio = VT.getSizeInBits() / SubVecVT.getSizeInBits();
16552   unsigned ExtendRatio = VT.getSizeInBits() / SubVecVT.getSizeInBits();
16701     unsigned PtrOff = VecEltVT.getSizeInBits() * Elt / 8;
17112                  isPowerOf2_32(OutScalarTy.getSizeInBits()) &&
17113                  isPowerOf2_32(SourceType.getSizeInBits());
17121   unsigned ElemRatio = OutScalarTy.getSizeInBits()/SourceType.getSizeInBits();
17121   unsigned ElemRatio = OutScalarTy.getSizeInBits()/SourceType.getSizeInBits();
17149   assert(VecVT.getSizeInBits() == VT.getSizeInBits() &&
17149   assert(VecVT.getSizeInBits() == VT.getSizeInBits() &&
17187     if ((VT.getSizeInBits() % InVT1.getSizeInBits() == 0) && InVT1 == InVT2) {
17187     if ((VT.getSizeInBits() % InVT1.getSizeInBits() == 0) && InVT1 == InVT2) {
17190       unsigned NumConcats = VT.getSizeInBits() / InVT1.getSizeInBits();
17190       unsigned NumConcats = VT.getSizeInBits() / InVT1.getSizeInBits();
17197     } else if (InVT1.getSizeInBits() == VT.getSizeInBits() * 2) {
17197     } else if (InVT1.getSizeInBits() == VT.getSizeInBits() * 2) {
17210       } else if (InVT2.getSizeInBits() <= InVT1.getSizeInBits()) {
17210       } else if (InVT2.getSizeInBits() <= InVT1.getSizeInBits()) {
17235     } else if (InVT2.getSizeInBits() * 2 == VT.getSizeInBits() &&
17235     } else if (InVT2.getSizeInBits() * 2 == VT.getSizeInBits() &&
17236                InVT1.getSizeInBits() == VT.getSizeInBits()) {
17236                InVT1.getSizeInBits() == VT.getSizeInBits()) {
17322       Extract.getOperand(0).getValueSizeInBits() != VT.getSizeInBits())
17717   EVT SVT = EVT::getIntegerVT(*DAG.getContext(), OpVT.getSizeInBits());
17747     SVT = EVT::getFloatingPointVT(OpVT.getSizeInBits());
17762                                VT.getSizeInBits() / SVT.getSizeInBits());
17762                                VT.getSizeInBits() / SVT.getSizeInBits());
17811     if (ExtVT.getSizeInBits() != VT.getSizeInBits())
17811     if (ExtVT.getSizeInBits() != VT.getSizeInBits())
17895       if (VT.getSizeInBits() % SclTy.getSizeInBits())
17895       if (VT.getSizeInBits() % SclTy.getSizeInBits())
17898       unsigned VNTNumElms = VT.getSizeInBits() / SclTy.getSizeInBits();
17898       unsigned VNTNumElms = VT.getSizeInBits() / SclTy.getSizeInBits();
18101   unsigned WideWidth = WideBVT.getSizeInBits();
18102   unsigned NarrowWidth = VT.getSizeInBits();
18293       unsigned ExtractSize = NVT.getSizeInBits();
19026           0 == (InnerSVT.getSizeInBits() % ScaleSVT.getSizeInBits()) &&
19026           0 == (InnerSVT.getSizeInBits() % ScaleSVT.getSizeInBits()) &&
19027           0 == (SVT.getSizeInBits() % ScaleSVT.getSizeInBits())) {
19027           0 == (SVT.getSizeInBits() % ScaleSVT.getSizeInBits())) {
19028         int InnerScale = InnerSVT.getSizeInBits() / ScaleSVT.getSizeInBits();
19028         int InnerScale = InnerSVT.getSizeInBits() / ScaleSVT.getSizeInBits();
19029         int OuterScale = SVT.getSizeInBits() / ScaleSVT.getSizeInBits();
19029         int OuterScale = SVT.getSizeInBits() / ScaleSVT.getSizeInBits();
19267       N1.getOperand(0).getOperand(0).getValueType().getSizeInBits() ==
19268           VT.getSizeInBits()) {
19330       if ((EltSizeInBits % N1SrcSVT.getSizeInBits()) == 0) {
19331         unsigned Scale = EltSizeInBits / N1SrcSVT.getSizeInBits();
19334       } else if ((N1SrcSVT.getSizeInBits() % EltSizeInBits) == 0) {
19335         unsigned Scale = N1SrcSVT.getSizeInBits() / EltSizeInBits;
19939     unsigned ShCt = XType.getSizeInBits() - N2C->getAPIntValue().logBase2() - 1;
19955   SDValue ShiftAmt = DAG.getConstant(XType.getSizeInBits() - 1, DL, ShiftAmtTy);
20154       if (ValueOnZeroC->getAPIntValue() == VT.getSizeInBits()) {
20778   Intervals.insert(0, (St->getMemoryVT().getSizeInBits() + 7) / 8, Unit);
20794     int64_t Length = (Chain->getMemoryVT().getSizeInBits() + 7) / 8;
lib/CodeGen/SelectionDAG/FastISel.cpp
  426       uint32_t IntBitWidth = IntVT.getSizeInBits();
 1725   if (VT.getSizeInBits() > 64)
 1727   EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits());
 1738       UINT64_C(1) << (VT.getSizeInBits() - 1), IntVT.getSimpleVT());
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
  425   unsigned BitWidth = IntVT.getSizeInBits();
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
  542   unsigned StWidth = StVT.getSizeInBits();
  723   unsigned SrcWidth = SrcVT.getSizeInBits();
 1401   unsigned TypeByteSize = EltVT.getSizeInBits() / 8;
 1441   unsigned NumBits = FloatVT.getSizeInBits();
 1473     unsigned ByteOffset = (FloatVT.getSizeInBits() / 8) - 1;
 1757   unsigned SlotSize = SlotVT.getSizeInBits();
 1758   unsigned DestSize = DestVT.getSizeInBits();
 2864     if (ExtraVT.getSizeInBits() == 1) {
 2976                              VT.getSizeInBits() / NewEltVT.getSizeInBits());
 2976                              VT.getSizeInBits() / NewEltVT.getSizeInBits());
 3035                          DAG.getConstant(OpTy.getSizeInBits() / 2, dl,
 3190                DAG.getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), dl,
 3314           DAG.getConstant(HalfType.getSizeInBits(), dl,
 3416         DAG.getConstant(PairTy.getSizeInBits() / 2, dl,
 4281         Node->getValueType(0).getSizeInBits() == NVT.getSizeInBits()) {
 4563     assert(AM->getMemoryVT().getSizeInBits() == NVT.getSizeInBits() &&
lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
  167   unsigned Size = NVT.getSizeInBits();
  266   unsigned LSize = LVT.getSizeInBits();
  267   unsigned RSize = RVT.getSizeInBits();
  277   int SizeDiff = RVT.getSizeInBits() - LVT.getSizeInBits();
  277   int SizeDiff = RVT.getSizeInBits() - LVT.getSizeInBits();
  486     APInt SignMask = APInt::getSignMask(NVT.getSizeInBits());
 1182   assert(NVT.getSizeInBits() == 64 &&
 1410                                  APInt(NVT.getSizeInBits(), 0)), dl, NVT);
 1535                                  APInt(NVT.getSizeInBits(), 0)), dl, NVT);
 1560                                    APInt(NVT.getSizeInBits(), 0)), dl, NVT);
 1940   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), OpVT.getSizeInBits());
 2010   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2116                               N->getOperand(0).getValueType().getSizeInBits());
 2127   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2265   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2278   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp
  330                                            NOutVT.getSizeInBits()),
  346       unsigned WidenInSize = NInVT.getSizeInBits();
  347       unsigned OutSize = OutVT.getSizeInBits();
  376       ShiftVT.getSizeInBits() < Log2_32_Ceil(VT.getSizeInBits()))
  376       ShiftVT.getSizeInBits() < Log2_32_Ceil(VT.getSizeInBits()))
 1342                    DAG.getConstant(OVT.getSizeInBits(), dl,
 1840   unsigned VTBits = N->getValueType(0).getSizeInBits();
 1841   unsigned NVTBits = NVT.getSizeInBits();
 2005   unsigned NVTBits = NVT.getSizeInBits();
 2405   unsigned NVTBits = NVT.getSizeInBits();
 2406   unsigned EVTBits = EVT.getSizeInBits();
 2427   unsigned NVTBits = NVT.getSizeInBits();
 2428   unsigned EVTBits = EVT.getSizeInBits();
 2460   unsigned NBitWidth = NVT.getSizeInBits();
 2505                                  DAG.getConstant(NVT.getSizeInBits(), dl,
 2536                                  DAG.getConstant(NVT.getSizeInBits(), dl,
 2545   unsigned NBitWidth = NVT.getSizeInBits();
 2694       N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
 2694       N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
 2698     unsigned IncrementSize = NVT.getSizeInBits()/8;
 2714     unsigned IncrementSize = NVT.getSizeInBits()/8;
 2720                                           MemVT.getSizeInBits() - ExcessBits),
 2737     if (ExcessBits < NVT.getSizeInBits()) {
 2747                        DAG.getConstant(NVT.getSizeInBits() - ExcessBits, dl,
 2798     unsigned Bits = NVT.getSizeInBits();
 2809     if (APInt::getMaxValue(ShiftAmtTy.getSizeInBits()).ult(HalfBits)) {
 3268     unsigned LoSize = NVT.getSizeInBits();
 3283     unsigned ExcessBits = Op.getValueSizeInBits() - NVT.getSizeInBits();
 3309     unsigned ExcessBits = EVT.getSizeInBits() - Lo.getValueSizeInBits();
 3351                    DAG.getConstant(NVT.getSizeInBits(), dl,
 3548     unsigned ExcessBits = Op.getValueSizeInBits() - NVT.getSizeInBits();
 3923       N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
 3923       N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
 3927     unsigned IncrementSize = NVT.getSizeInBits()/8;
 3941   unsigned IncrementSize = NVT.getSizeInBits()/8;
 3944                                ExtVT.getSizeInBits() - ExcessBits);
 3946   if (ExcessBits < NVT.getSizeInBits()) {
 3949                      DAG.getConstant(NVT.getSizeInBits() - ExcessBits, dl,
 3989   if (APFloat::semanticsPrecision(sem) >= SrcVT.getSizeInBits()-1 &&
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp
  967                               LVT.getSizeInBits() + HVT.getSizeInBits());
  967                               LVT.getSizeInBits() + HVT.getSizeInBits());
  973                    DAG.getConstant(LVT.getSizeInBits(), dlHi, ShiftAmtVT));
 1057   assert(LoVT.getSizeInBits() + HiVT.getSizeInBits() ==
 1057   assert(LoVT.getSizeInBits() + HiVT.getSizeInBits() ==
 1061       Log2_32_Ceil(Op.getValueType().getSizeInBits());
 1067                    DAG.getConstant(LoVT.getSizeInBits(), dl, ShiftAmountTy));
lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp
  108       unsigned NewSizeInBits = ElemVT.getSizeInBits() / 2;
  171   unsigned IncrementSize = NOutVT.getSizeInBits() / 8;
  264   unsigned IncrementSize = NVT.getSizeInBits() / 8;
  470   unsigned IncrementSize = NVT.getSizeInBits() / 8;
lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp
  693     unsigned WideBits = WideVT.getSizeInBits();
  696     unsigned SrcEltBits = SrcEltVT.getSizeInBits();
  919           DAG.getConstant(APInt::getAllOnesValue(BitTy.getSizeInBits()), DL,
  933             APInt::getAllOnesValue(BitTy.getSizeInBits()), DL, MaskTy);
  975     assert((VT.getSizeInBits() % SrcVT.getScalarSizeInBits()) == 0 &&
  977     NumSrcElements = VT.getSizeInBits() / SrcVT.getScalarSizeInBits();
 1035     assert((VT.getSizeInBits() % SrcVT.getScalarSizeInBits()) == 0 &&
 1037     NumSrcElements = VT.getSizeInBits() / SrcVT.getScalarSizeInBits();
 1160   if (VT.getSizeInBits() != Op1.getValueSizeInBits())
 1436                                            (EltVT.getSizeInBits()), dl, EltVT),
lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
 1101   EVT LoIntVT = EVT::getIntegerVT(*DAG.getContext(), LoVT.getSizeInBits());
 1102   EVT HiIntVT = EVT::getIntegerVT(*DAG.getContext(), HiVT.getSizeInBits());
 1508   unsigned IncrementSize = LoVT.getSizeInBits() / 8;
 1557   unsigned IncrementSize = LoMemVT.getSizeInBits()/8;
 1797       SrcVT.getSizeInBits() * 2 < DestVT.getSizeInBits()) {
 1797       SrcVT.getSizeInBits() * 2 < DestVT.getSizeInBits()) {
 2501   unsigned IncrementSize = LoMemVT.getSizeInBits()/8;
 3280     if (WidenVT.getSizeInBits() == InVT.getSizeInBits()) {
 3280     if (WidenVT.getSizeInBits() == InVT.getSizeInBits()) {
 3393     if (InVT.getSizeInBits() == WidenVT.getSizeInBits()) {
 3393     if (InVT.getSizeInBits() == WidenVT.getSizeInBits()) {
 3532   unsigned WidenSize = WidenVT.getSizeInBits();
 3533   unsigned InSize = InVT.getSizeInBits();
 3544                                  WidenSize / InEltVT.getSizeInBits());
 3916   if (!isPowerOf2_64(VSelVT.getSizeInBits()))
 4227   if (InVT.getSizeInBits() != VT.getSizeInBits()) {
 4227   if (InVT.getSizeInBits() != VT.getSizeInBits()) {
 4233           FixedVT.getSizeInBits() == VT.getSizeInBits() &&
 4233           FixedVT.getSizeInBits() == VT.getSizeInBits() &&
 4251     if (InVT.getSizeInBits() != VT.getSizeInBits())
 4251     if (InVT.getSizeInBits() != VT.getSizeInBits())
 4347   unsigned InWidenSize = InWidenVT.getSizeInBits();
 4348   unsigned Size = VT.getSizeInBits();
 4367     unsigned EltSize = EltVT.getSizeInBits();
 4607         APInt::getSignedMinValue(ElemVT.getSizeInBits()), dl, ElemVT);
 4611         APInt::getSignedMaxValue(ElemVT.getSizeInBits()), dl, ElemVT);
 4673   unsigned WidenWidth = WidenVT.getSizeInBits();
 4674   unsigned WidenEltWidth = WidenEltVT.getSizeInBits();
 4687     unsigned MemVTWidth = MemVT.getSizeInBits();
 4688     if (MemVT.getSizeInBits() <= WidenEltWidth)
 4709     unsigned MemVTWidth = MemVT.getSizeInBits();
 4718       if (RetVT.getSizeInBits() < MemVTWidth || MemVT == WidenVT)
 4736   unsigned Width = VecTy.getSizeInBits();
 4737   unsigned NumElts = Width / LdTy.getSizeInBits();
 4746       NumElts = Width / NewLdTy.getSizeInBits();
 4750       Idx = Idx * LdTy.getSizeInBits() / NewLdTy.getSizeInBits();
 4750       Idx = Idx * LdTy.getSizeInBits() / NewLdTy.getSizeInBits();
 4767   unsigned WidenWidth = WidenVT.getSizeInBits();
 4780   int LdWidth = LdVT.getSizeInBits();
 4786   int NewVTWidth = NewVT.getSizeInBits();
 4828       NewVTWidth = NewVT.getSizeInBits();
 4894   if (WidenWidth == LdTy.getSizeInBits() * (End - Idx))
 4899   unsigned NumOps = WidenWidth / LdTy.getSizeInBits();
 4937   unsigned Increment = LdEltVT.getSizeInBits() / 8;
 4973   unsigned StWidth = StVT.getSizeInBits();
 4975   unsigned ValWidth = ValVT.getSizeInBits();
 4977   unsigned ValEltWidth = ValEltVT.getSizeInBits();
 4985     unsigned NewVTWidth = NewVT.getSizeInBits();
 5052   unsigned Increment = ValEltVT.getSizeInBits() / 8;
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
  143   unsigned EltSize = N->getValueType(0).getVectorElementType().getSizeInBits();
  805     assert(VT.getSizeInBits() == 2 * N->getOperand(0).getValueSizeInBits() &&
 1138                                    VT.getSizeInBits());
 1159     getConstant(APInt::getAllOnesValue(EltVT.getSizeInBits()), DL, VT);
 1186   assert((EltVT.getSizeInBits() >= 64 ||
 1187          (uint64_t)((int64_t)Val >> EltVT.getSizeInBits()) + 1 < 2) &&
 1189   return getConstant(APInt(EltVT.getSizeInBits(), Val), DL, VT, isT, isO);
 1211    APInt NewVal = Elt->getValue().zextOrTrunc(EltVT.getSizeInBits());
 1225     unsigned ViaEltSizeInBits = ViaEltVT.getSizeInBits();
 1226     unsigned ViaVecNumElts = VT.getSizeInBits() / ViaEltSizeInBits;
 1232     assert(ViaVecVT.getSizeInBits() == VT.getSizeInBits());
 1232     assert(ViaVecVT.getSizeInBits() == VT.getSizeInBits());
 1261   assert(Elt->getBitWidth() == EltVT.getSizeInBits() &&
 3023     APInt InMask = APInt::getLowBitsSet(BitWidth, VT.getSizeInBits());
 3434     Tmp = cast<VTSDNode>(Op.getOperand(1))->getVT().getSizeInBits();
 3437     Tmp = cast<VTSDNode>(Op.getOperand(1))->getVT().getSizeInBits();
 4291       return getConstant(Val.sextOrTrunc(VT.getSizeInBits()), DL, VT,
 4299       return getConstant(Val.zextOrTrunc(VT.getSizeInBits()), DL, VT,
 4304                   APInt::getNullValue(VT.getSizeInBits()));
 4393       APSInt IntVal(VT.getSizeInBits(), Opcode == ISD::FP_TO_UINT);
 4624     assert(VT.getSizeInBits() == Operand.getValueSizeInBits() &&
 5229     assert(VT.getSizeInBits() >= N1.getValueType().getScalarSizeInBits() &&
 5313       unsigned ElementSize = VT.getSizeInBits();
 5636       bool IsOpaque = VT.getSizeInBits() > 64 ||
 5647     IntVT = EVT::getIntegerVT(*DAG.getContext(), IntVT.getSizeInBits());
 5690   unsigned NumVTBits = VT.getSizeInBits();
 5840     unsigned VTSize = VT.getSizeInBits() / 8;
 6013     unsigned VTSize = VT.getSizeInBits() / 8;
 6033     unsigned VTSize = VT.getSizeInBits() / 8;
 6118     unsigned VTSize = VT.getSizeInBits() / 8;
 6142     DstOff += VT.getSizeInBits() / 8;
 9243   if (VT.getSizeInBits() / 8 != Bytes)
 9367   unsigned VecWidth = VT.getSizeInBits();
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
  217       unsigned ValueBits = ValueVT.getSizeInBits();
  278       EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), ValueVT.getSizeInBits());
  295     PartEVT = EVT::getIntegerVT(*DAG.getContext(),  ValueVT.getSizeInBits());
  300   if (PartEVT.getSizeInBits() == ValueVT.getSizeInBits())
  300   if (PartEVT.getSizeInBits() == ValueVT.getSizeInBits())
  443     if (ValueVT.getSizeInBits() == PartEVT.getSizeInBits())
  443     if (ValueVT.getSizeInBits() == PartEVT.getSizeInBits())
  455   if (PartEVT.getSizeInBits() == ValueVT.getSizeInBits() &&
  455   if (PartEVT.getSizeInBits() == ValueVT.getSizeInBits() &&
  462      if (ValueVT.getSizeInBits() == PartEVT.getSizeInBits()) {
  462      if (ValueVT.getSizeInBits() == PartEVT.getSizeInBits()) {
  464      } else if (ValueVT.getSizeInBits() < PartEVT.getSizeInBits()) {
  464      } else if (ValueVT.getSizeInBits() < PartEVT.getSizeInBits()) {
  467        unsigned Elts = PartEVT.getSizeInBits() / ValueVT.getScalarSizeInBits();
  526   if (NumParts * PartBits > ValueVT.getSizeInBits()) {
  535         ValueVT = EVT::getIntegerVT(*DAG.getContext(),  ValueVT.getSizeInBits());
  546   } else if (PartBits == ValueVT.getSizeInBits()) {
  550   } else if (NumParts * PartBits < ValueVT.getSizeInBits()) {
  563   assert(NumParts * PartBits == ValueVT.getSizeInBits() &&
  604                                            ValueVT.getSizeInBits()),
  671     } else if (PartVT.getSizeInBits() == ValueVT.getSizeInBits()) {
  689         assert(PartVT.getSizeInBits() > ValueVT.getSizeInBits() &&
  692             EVT::getIntegerVT(*DAG.getContext(), ValueVT.getSizeInBits());
 2488         MPInfo, Flags, PtrTy.getSizeInBits() / 8, DAG.getEVTAlignment(PtrTy));
 2635       if (!isUIntN(VT.getSizeInBits(), B.Cases[i].Mask)) {
 3141     unsigned ShiftSize = ShiftTy.getSizeInBits();
 4660       I.getAlignment() < MemVT.getSizeInBits() / 8)
 4725   if (I.getAlignment() < MemVT.getSizeInBits() / 8)
 5398                       Op.getValueType().getSizeInBits());
 6357     if (PtrTy.getSizeInBits() < ResTy.getSizeInBits())
 6357     if (PtrTy.getSizeInBits() < ResTy.getSizeInBits())
 8439         ResultVT.getSizeInBits() == V.getValueSizeInBits())
 9227         if ((NumParts * PartVT.getSizeInBits() == VT.getSizeInBits()) ||
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
 3543                 NodeToMatch->getValueType(i).getSizeInBits() ==
lib/CodeGen/SelectionDAG/StatepointLowering.cpp
   99   assert((SpillSize * 8) == ValueType.getSizeInBits() && "Size not in bytes?");
lib/CodeGen/SelectionDAG/TargetLowering.cpp
  200     while (DstAlign && DstAlign < VT.getSizeInBits() / 8 &&
  219     unsigned VTSize = VT.getSizeInBits() / 8;
  227         NewVT = (VT.getSizeInBits() > 64) ? MVT::i64 : MVT::i32;
  247       NewVTSize = NewVT.getSizeInBits() / 8;
 1330           if (!APInt(BitWidth, ShAmt).isIntN(ShTy.getSizeInBits()))
 1633           VT.getSizeInBits() == SrcVT.getSizeInBits() &&
 1633           VT.getSizeInBits() == SrcVT.getSizeInBits() &&
 1666           VT.getSizeInBits() == SrcVT.getSizeInBits() &&
 1666           VT.getSizeInBits() == SrcVT.getSizeInBits() &&
 1712         VT.getSizeInBits() == SrcVT.getSizeInBits() &&
 1712         VT.getSizeInBits() == SrcVT.getSizeInBits() &&
 1790     APInt InMask = APInt::getLowBitsSet(BitWidth, ZVT.getSizeInBits());
 2913   assert(KeptBits > 0 && KeptBits < XVT.getSizeInBits() && "unreachable");
 2921   const unsigned MaskedBits = XVT.getSizeInBits() - KeptBits;
 2922   assert(MaskedBits > 0 && MaskedBits < XVT.getSizeInBits() && "unreachable");
 3171           MinBits = LN0->getMemoryVT().getSizeInBits();
 3175           MinBits = LN0->getMemoryVT().getSizeInBits();
 3253           origWidth = Lod->getMemoryVT().getSizeInBits();
 3351       unsigned ExtSrcTyBits = ExtSrcTy.getSizeInBits();
 3353       unsigned ExtDstTyBits = ExtDstTy.getSizeInBits();
 3837         if (RHSC->getValueType(0).getSizeInBits() <= 64)
 4990     assert(APInt::getAllOnesValue(ShSVT.getSizeInBits()).ugt(K) &&
 5004         DAG.getConstant(APInt(ShSVT.getSizeInBits(), K), DL, ShSVT));
 5187     assert(APInt::getAllOnesValue(SVT.getSizeInBits()).ugt(A) &&
 5189     assert(APInt::getAllOnesValue(ShSVT.getSizeInBits()).ugt(K) &&
 5207         DAG.getConstant(APInt(ShSVT.getSizeInBits(), K), DL, ShSVT));
 5672   if (APInt::getMaxValue(ShiftAmountTy.getSizeInBits()).ult(ShiftAmount)) {
 6361   unsigned Stride = SrcEltVT.getSizeInBits() / 8;
 6412     unsigned NumBits = StVT.getSizeInBits();
 6425           DAG.getConstant(ShiftIntoIdx * MemSclVT.getSizeInBits(), SL, IntVT);
 6437   unsigned Stride = MemSclVT.getSizeInBits() / 8;
 6472     EVT intVT = EVT::getIntegerVT(*DAG.getContext(), LoadedVT.getSizeInBits());
 6565   unsigned NumBits = LoadedVT.getSizeInBits();
 6629     EVT intVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 6649         EVT::getIntegerVT(*DAG.getContext(), StoreMemVT.getSizeInBits()));
 6713   int NumBits = NewStoredVT.getSizeInBits();
 6753     EVT MaskIntVT = EVT::getIntegerVT(*DAG.getContext(), MaskVT.getSizeInBits());
 6755     if (MaskIntVT.getSizeInBits() < 32) {
 6783     APInt Imm = APInt::getLowBitsSet(IdxVT.getSizeInBits(),
 6803   unsigned EltSize = EltVT.getSizeInBits() / 8; // FIXME: should be ABI size.
 6804   assert(EltSize * 8 == EltVT.getSizeInBits() &&
 6872       unsigned Log2b = Log2_32(VT.getSizeInBits());
 7248       unsigned LoSize = VT.getSizeInBits();
 7307   if (RType.getSizeInBits() < Overflow.getValueSizeInBits())
 7310   assert(RType.getSizeInBits() == Overflow.getValueSizeInBits() &&
lib/CodeGen/SwitchLoweringUtils.cpp
  284   int BitWidth = PTy.getSizeInBits();
lib/CodeGen/TargetLoweringBase.cpp
  851     unsigned BitSize = VT.getSizeInBits();
  865                         EVT::getIntegerVT(Context, VT.getSizeInBits() / 2));
  905       EltVT = EVT::getIntegerVT(Context, 1 + EltVT.getSizeInBits())
 1445   unsigned NewVTSize = NewVT.getSizeInBits();
lib/CodeGen/ValueTypes.cpp
   18   return getIntegerVT(Context, getSizeInBits());
  121       return "i" + utostr(getSizeInBits());
lib/Target/AArch64/AArch64ISelDAGToDAG.cpp
  676         Reg->getValueType(0).getSizeInBits() == 32 && isDef32(*Reg.getNode()))
 1307   bool Is128Bit = VT.getSizeInBits() == 128;
 1329   bool Is128Bit = VT.getSizeInBits() == 128;
 1381   bool Narrow = VT.getSizeInBits() == 64;
 1420   bool Narrow = VT.getSizeInBits() == 64;
 1475   bool Narrow = VT.getSizeInBits() == 64;
 1504   bool Narrow = VT.getSizeInBits() == 64;
 1604   if (!BiggerPattern && (SrlImm <= 0 || SrlImm >= VT.getSizeInBits())) {
 1632   unsigned BitWidth = VT.getSizeInBits();
 1640     BitWidth = VT.getSizeInBits();
 1648   unsigned Width = cast<VTSDNode>(N->getOperand(1))->getVT().getSizeInBits();
 1735     TruncBits = Opd0->getValueType(0).getSizeInBits() - VT.getSizeInBits();
 1735     TruncBits = Opd0->getValueType(0).getSizeInBits() - VT.getSizeInBits();
 1748   if (ShlImm >= VT.getSizeInBits()) {
 1759   assert(SrlImm > 0 && SrlImm < VT.getSizeInBits() &&
 1762   Immr = immr < 0 ? immr + VT.getSizeInBits() : immr;
 1763   Imms = VT.getSizeInBits() - ShlImm - TruncBits - 1;
 1789   unsigned Imms = NarrowVT.getSizeInBits() - 1;
 1873   unsigned BitWidth = VT.getSizeInBits() - NumberOfIgnoredHighBits;
 2109   unsigned BitWidth = VT.getSizeInBits();
 2138   unsigned BitWidth = VT.getSizeInBits();
 2200   unsigned BitWidth = VT.getSizeInBits();
 2289   unsigned BitWidth = VT.getSizeInBits();
 2478   unsigned ImmR = (VT.getSizeInBits() - DstLSB) % VT.getSizeInBits();
 2478   unsigned ImmR = (VT.getSizeInBits() - DstLSB) % VT.getSizeInBits();
lib/Target/AArch64/AArch64ISelLowering.cpp
 1021   unsigned Size = VT.getSizeInBits();
 2453   if (VT.getSizeInBits() < InVT.getSizeInBits()) {
 2453   if (VT.getSizeInBits() < InVT.getSizeInBits()) {
 2461   if (VT.getSizeInBits() > InVT.getSizeInBits()) {
 2461   if (VT.getSizeInBits() > InVT.getSizeInBits()) {
 2513   if (VT.getSizeInBits() < InVT.getSizeInBits()) {
 2513   if (VT.getSizeInBits() < InVT.getSizeInBits()) {
 2521   if (VT.getSizeInBits() > InVT.getSizeInBits()) {
 2521   if (VT.getSizeInBits() > InVT.getSizeInBits()) {
 2615   if (OrigVT.getSizeInBits() >= 64)
 2639   if (OrigTy.getSizeInBits() >= 64)
 5599   unsigned VTBits = VT.getSizeInBits();
 5656   unsigned VTBits = VT.getSizeInBits();
 5734     AArch64_IMM::expandMOVImm(ImmInt.getZExtValue(), VT.getSizeInBits(),
 5882      (ConstraintVT.getSizeInBits() == 64 ||
 5883       ConstraintVT.getSizeInBits() == 128))
 6236   return EltType.getSizeInBits() / 8;
 6329       VT.getScalarSizeInBits() / SmallestEltTy.getSizeInBits();
 6330   NumElts = VT.getSizeInBits() / SmallestEltTy.getSizeInBits();
 6330   NumElts = VT.getSizeInBits() / SmallestEltTy.getSizeInBits();
 6339     if (SrcVT.getSizeInBits() == VT.getSizeInBits())
 6339     if (SrcVT.getSizeInBits() == VT.getSizeInBits())
 6345     unsigned NumSrcElts = VT.getSizeInBits() / EltVT.getSizeInBits();
 6345     unsigned NumSrcElts = VT.getSizeInBits() / EltVT.getSizeInBits();
 6348     if (SrcVT.getSizeInBits() < VT.getSizeInBits()) {
 6348     if (SrcVT.getSizeInBits() < VT.getSizeInBits()) {
 6349       assert(2 * SrcVT.getSizeInBits() == VT.getSizeInBits());
 6349       assert(2 * SrcVT.getSizeInBits() == VT.getSizeInBits());
 6358     assert(SrcVT.getSizeInBits() == 2 * VT.getSizeInBits());
 6358     assert(SrcVT.getSizeInBits() == 2 * VT.getSizeInBits());
 6403     Src.WindowScale = SrcEltTy.getSizeInBits() / SmallestEltTy.getSizeInBits();
 6403     Src.WindowScale = SrcEltTy.getSizeInBits() / SmallestEltTy.getSizeInBits();
 6428         std::min(OrigEltTy.getSizeInBits(), VT.getScalarSizeInBits());
 6698   if (VT.getSizeInBits() != 128)
 6816     if (VT.getSizeInBits() == 64)
 6857   unsigned BytesPerElt = EltVT.getSizeInBits() / 8;
 6968     } else if (VT.getSizeInBits() == 64)
 7042     if (ScalarVT.getSizeInBits() < 32 && ScalarVT.isInteger())
 7118     unsigned NumSplats = VT.getSizeInBits() / SplatBitSize;
 7123       CnstBits |= SplatBits.zextOrTrunc(VT.getSizeInBits());
 7124       UndefBits |= (SplatBits ^ SplatUndef).zextOrTrunc(VT.getSizeInBits());
 7139     MVT MovTy = (VT.getSizeInBits() == 128) ? MVT::v2i64 : MVT::f64;
 7161     MVT MovTy = (VT.getSizeInBits() == 128) ? MVT::v4i32 : MVT::v2i32;
 7209     MVT MovTy = (VT.getSizeInBits() == 128) ? MVT::v8i16 : MVT::v4i16;
 7248     MVT MovTy = (VT.getSizeInBits() == 128) ? MVT::v4i32 : MVT::v2i32;
 7279     MVT MovTy = (VT.getSizeInBits() == 128) ? MVT::v16i8 : MVT::v8i8;
 7300     bool isWide = (VT.getSizeInBits() == 128);
 7445   APInt DefBits(VT.getSizeInBits(), 0);
 7446   APInt UndefBits(VT.getSizeInBits(), 0);
 7476   if (EltTy.isFloatingPoint() || EltTy.getSizeInBits() > 16)
 7486       APInt LowBits(EltTy.getSizeInBits(),
 7503   APInt DefBits(VT.getSizeInBits(), 0);
 7504   APInt UndefBits(VT.getSizeInBits(), 0);
 7555         unsigned BitSize = VT.getVectorElementType().getSizeInBits();
 7723       MVT NewType = MVT::getIntegerVT(EltTy.getSizeInBits());
 7956           isConcatMask(M, VT, VT.getSizeInBits() == 128));
 8054   assert(VT.getSizeInBits() == SrcVT.getSizeInBits() &&
 8054   assert(VT.getSizeInBits() == SrcVT.getSizeInBits() &&
 8058   APInt CnstBits(VT.getSizeInBits(), 0);
 8059   APInt UndefBits(VT.getSizeInBits(), 0);
 8485     uint64_t LoadBytes = Mem->getMemoryVT().getSizeInBits()/8;
 8504   unsigned NumBits1 = VT1.getSizeInBits();
 8505   unsigned NumBits2 = VT2.getSizeInBits();
 8548   unsigned NumBits1 = VT1.getSizeInBits();
 8549   unsigned NumBits2 = VT2.getSizeInBits();
 8565           VT1.getSizeInBits() <= 32);
 8733   unsigned NumBits = LoadedType.getSizeInBits();
 9286   if (!ShiftAmt || ShiftAmt->getZExtValue() != ShiftEltTy.getSizeInBits() - 1)
 9306       if (Y1C->getAPIntValue() == VT.getSizeInBits() - 1) {
 9491       VT.getSizeInBits() != N->getOperand(0)->getValueType(0).getSizeInBits())
 9491       VT.getSizeInBits() != N->getOperand(0)->getValueType(0).getSizeInBits())
 9533   if (VT.getSizeInBits() != N->getOperand(0).getValueSizeInBits())
 9756   if (ShiftLHS + ShiftRHS != VT.getSizeInBits())
 9850   APInt DefBits(VT.getSizeInBits(), 0);
 9851   APInt UndefBits(VT.getSizeInBits(), 0);
10592   if (SrcVT.getSizeInBits() != 64)
10628   unsigned EltOffset = SplatVal.getValueType().getSizeInBits() / 8;
10687          VT.getVectorElementType().getSizeInBits() == 64) ||
10689          VT.getVectorElementType().getSizeInBits() == 32)))
10725   if (VT.getVectorElementType().getSizeInBits() == 32) {
10835   if (VT.getSizeInBits() != 128 || S->getAlignment() >= 16 ||
11094       unsigned NumBytes = NumVecs * VecTy.getSizeInBits() / 8;
11474       Bit < Op->getValueType(0).getSizeInBits()) {
11504         (Bit - C->getZExtValue()) < Op->getValueType(0).getSizeInBits()) {
11513     if (Bit >= Op->getValueType(0).getSizeInBits())
11514       Bit = Op->getValueType(0).getSizeInBits() - 1;
11519     if ((Bit + C->getZExtValue()) < Op->getValueType(0).getSizeInBits()) {
11577   if (ResVT.getSizeInBits() != CmpVT.getSizeInBits())
11577   if (ResVT.getSizeInBits() != CmpVT.getSizeInBits())
11619   int NumMaskElts = ResVT.getSizeInBits() / SrcVT.getSizeInBits();
11619   int NumMaskElts = ResVT.getSizeInBits() / SrcVT.getSizeInBits();
11629   if (CCVT.getSizeInBits() != ResVT.getSizeInBits())
11629   if (CCVT.getSizeInBits() != ResVT.getSizeInBits())
lib/Target/AArch64/AArch64ISelLowering.h
  476       return (MemVT.getSizeInBits() <= 64);
  501     return VT.getSizeInBits() >= 64; // vector 'bic'
lib/Target/AArch64/AArch64TargetTransformInfo.cpp
  430   if (DstVT.getSizeInBits() < SrcVT.getSizeInBits())
  430   if (DstVT.getSizeInBits() < SrcVT.getSizeInBits())
  445     if (DstVT.getSizeInBits() != 64u || SrcVT.getSizeInBits() == 32u)
  445     if (DstVT.getSizeInBits() != 64u || SrcVT.getSizeInBits() == 32u)
lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp
  351     if (Src.getValueType().getSizeInBits() == 32)
  813     if (N->getValueType(0).getSizeInBits() != 64 || isInlineImmediate(N))
 2001     unsigned Width = cast<VTSDNode>(N->getOperand(1))->getVT().getSizeInBits();
lib/Target/AMDGPU/AMDGPUISelLowering.cpp
   54   return VT.getSizeInBits() - Known.countMinLeadingZeros();
   62   return VT.getSizeInBits() - DAG.ComputeNumSignBits(Op);
  680   assert(LoadTy.getSizeInBits() == CastTy.getSizeInBits());
  680   assert(LoadTy.getSizeInBits() == CastTy.getSizeInBits());
  779   unsigned SrcSize = Source.getSizeInBits();
  780   unsigned DestSize = Dest.getSizeInBits();
  830   return SrcVT.getSizeInBits() > 32 && DestVT.getSizeInBits() == 32;
  830   return SrcVT.getSizeInBits() > 32 && DestVT.getSizeInBits() == 32;
 1543   unsigned BitSize = VT.getSizeInBits();
 1811   const unsigned halfBitWidth = HalfVT.getSizeInBits();
 2758   return VT.getSizeInBits() >= 24 && // Types less than 24-bit should be treated
 3178       if (VT.getSizeInBits() <= EltVT.getSizeInBits()) {
 3178       if (VT.getSizeInBits() <= EltVT.getSizeInBits()) {
 3278   unsigned Size = VT.getSizeInBits();
 3349   if (!Subtarget->hasMulU24() || VT.isVector() || VT.getSizeInBits() > 32)
 3907     if (DestVT.getSizeInBits() != 64 && !DestVT.isVector())
 4524       unsigned Size = Op.getValueType().getSizeInBits();
lib/Target/AMDGPU/R600ISelLowering.cpp
  799   SDValue Width  = DAG.getConstant(VT.getSizeInBits(), DL, VT);
  800   SDValue Width1 = DAG.getConstant(VT.getSizeInBits() - 1, DL, VT);
  837   SDValue Width  = DAG.getConstant(VT.getSizeInBits(), DL, VT);
  838   SDValue Width1 = DAG.getConstant(VT.getSizeInBits() - 1, DL, VT);
 1663     return (MemVT.getSizeInBits() <= 32);
lib/Target/AMDGPU/SIISelLowering.cpp
  786     unsigned Size = ScalarVT.getSizeInBits();
  795   } else if (VT.getSizeInBits() > 32)
  810     unsigned Size = ScalarVT.getSizeInBits();
  820   } else if (VT.getSizeInBits() > 32)
  821     return (VT.getSizeInBits() + 31) / 32;
  833     unsigned Size = ScalarVT.getSizeInBits();
 1225     return (MemVT.getSizeInBits() <= 4 * 32);
 1228     return (MemVT.getSizeInBits() <= MaxPrivateBits);
 1230     return (MemVT.getSizeInBits() <= 2 * 32);
 1301   if (VT == MVT::Other || (VT != MVT::Other && VT.getSizeInBits() > 1024 &&
 1306   return allowsMisalignedMemoryAccessesImpl(VT.getSizeInBits(), AddrSpace,
 3012     if (VT.getSizeInBits() == 32)
 3017     if (VT.getSizeInBits() == 64)
 4154   bool IsD16 = IsFormat && (EltType.getSizeInBits() == 16);
 4164   if (!IsD16 && !LoadVT.isVector() && EltType.getSizeInBits() < 32)
 4792   unsigned VecSize = VecVT.getSizeInBits();
 4793   unsigned EltSize = EltVT.getSizeInBits();
 4869   unsigned VecSize = VecVT.getSizeInBits();
 4882   unsigned EltSize = EltVT.getSizeInBits();
 5381       NumVDataDwords = (VData.getValueType().getSizeInBits() + 31) / 32;
 5599       UseNSA ? VAddrs.size() : VAddr.getValueType().getSizeInBits() / 32;
 6961     bool IsD16 = IsFormat && (EltType.getSizeInBits() == 16);
 6990     if (!IsD16 && !VDataVT.isVector() && EltType.getSizeInBits() < 32)
 7005     bool IsD16 = IsFormat && (EltType.getSizeInBits() == 16);
 7037     if (!IsD16 && !VDataVT.isVector() && EltType.getSizeInBits() < 32)
 7267       MemVT.getSizeInBits() >= 32)
 7286   EVT TruncVT = EVT::getIntegerVT(*DAG.getContext(), MemVT.getSizeInBits());
 7305   EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 7326   if (ExtType == ISD::NON_EXTLOAD && MemVT.getSizeInBits() < 32) {
 7384       Alignment < MemVT.getStoreSize() && MemVT.getSizeInBits() > 32) {
 7489   assert(VT.getSizeInBits() == 64);
 7883       Store->getAlignment() < VT.getStoreSize() && VT.getSizeInBits() > 32) {
 9307   unsigned VecSize = VecVT.getSizeInBits();
 9308   unsigned EltSize = EltVT.getSizeInBits();
 9377   unsigned VecSize = VecVT.getSizeInBits();
 9378   unsigned EltSize = EltVT.getSizeInBits();
lib/Target/ARC/ARCISelLowering.cpp
  184   unsigned Width = cast<VTSDNode>(Op.getOperand(1))->getVT().getSizeInBits();
lib/Target/ARM/ARMISelDAGToDAG.cpp
 1002     unsigned MemSize = MemN->getMemoryVT().getSizeInBits() / 8;
 1024     if (NC->getZExtValue() * 8 == LdSt->getMemoryVT().getSizeInBits())
 1918   return C && C->getZExtValue() == VecTy.getSizeInBits() / 8 * NumVecs;
 2375   switch (N->getValueType(1).getVectorElementType().getSizeInBits()) {
 2466   switch (VT.getVectorElementType().getSizeInBits()) {
 2667         if ((LSB + Width + 1) == N->getValueType(0).getSizeInBits()) {
 2747     unsigned Width = cast<VTSDNode>(N->getOperand(1))->getVT().getSizeInBits();
 2796   unsigned Size = XType.getSizeInBits() - 1;
lib/Target/ARM/ARMISelLowering.cpp
 5793   unsigned VTBits = VT.getSizeInBits();
 5837   unsigned VTBits = VT.getSizeInBits();
 5913       unsigned NumBits = ElemTy.getSizeInBits();
 6095     if (ShAmt->getValueType(0).getSizeInBits() > 64 ||
 7401       VT.getScalarSizeInBits() / SmallestEltTy.getSizeInBits();
 7402   NumElts = VT.getSizeInBits() / SmallestEltTy.getSizeInBits();
 7402   NumElts = VT.getSizeInBits() / SmallestEltTy.getSizeInBits();
 7411     if (SrcVT.getSizeInBits() == VT.getSizeInBits())
 7411     if (SrcVT.getSizeInBits() == VT.getSizeInBits())
 7417     unsigned NumSrcElts = VT.getSizeInBits() / EltVT.getSizeInBits();
 7417     unsigned NumSrcElts = VT.getSizeInBits() / EltVT.getSizeInBits();
 7420     if (SrcVT.getSizeInBits() < VT.getSizeInBits()) {
 7420     if (SrcVT.getSizeInBits() < VT.getSizeInBits()) {
 7421       if (2 * SrcVT.getSizeInBits() != VT.getSizeInBits())
 7421       if (2 * SrcVT.getSizeInBits() != VT.getSizeInBits())
 7431     if (SrcVT.getSizeInBits() != 2 * VT.getSizeInBits())
 7431     if (SrcVT.getSizeInBits() != 2 * VT.getSizeInBits())
 7475     Src.WindowScale = SrcEltTy.getSizeInBits() / SmallestEltTy.getSizeInBits();
 7475     Src.WindowScale = SrcEltTy.getSizeInBits() / SmallestEltTy.getSizeInBits();
 7499     int BitsDefined = std::min(OrigEltTy.getSizeInBits(),
 8286   if (OrigVT.getSizeInBits() >= 64)
 8313   if (OrigTy.getSizeInBits() >= 64)
 8949       EVT::getIntegerVT(*DAG.getContext(), MemVT.getSizeInBits()),
 8983       EVT::getIntegerVT(*DAG.getContext(), MemVT.getSizeInBits()),
10876       OtherOp = DAG.getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), dl,
12698   if (EltVT.getSizeInBits() != 32 || !N->hasOneUse())
12973     unsigned NumBytes = NumVecs * VecTy.getSizeInBits() / 8;
13276   assert(SizeRatio * NumElems * ToEltSz == VT.getSizeInBits());
13281   assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
13281   assert(WideVecVT.getSizeInBits() == VT.getSizeInBits());
13312                        VT.getSizeInBits() / EVT(StoreType).getSizeInBits());
13312                        VT.getSizeInBits() / EVT(StoreType).getSizeInBits());
13313   assert(StoreVecVT.getSizeInBits() == VT.getSizeInBits());
13313   assert(StoreVecVT.getSizeInBits() == VT.getSizeInBits());
13375     unsigned NewOffset = i * NumElements * ToEltVT.getSizeInBits() / 8;
13869   unsigned NewOffset = NewFromVT.getSizeInBits() / 8;
14023     APInt Mask(VT.getSizeInBits(), 0);
14469     unsigned BitWidth = N->getValueType(0).getSizeInBits();
14476     unsigned BitWidth = N->getValueType(0).getSizeInBits();
14485     unsigned BitWidth = N->getValueType(0).getSizeInBits();
14493     unsigned LowWidth = N->getOperand(0).getValueType().getSizeInBits();
14495     unsigned HighWidth = N->getOperand(1).getValueType().getSizeInBits();
14503     unsigned HighWidth = N->getOperand(0).getValueType().getSizeInBits();
14505     unsigned LowWidth = N->getOperand(1).getValueType().getSizeInBits();
14513     unsigned BitWidth = N->getValueType(0).getSizeInBits();
14522     unsigned BitWidth = N->getValueType(0).getSizeInBits();
14687   unsigned SrcBits = SrcVT.getSizeInBits();
14688   unsigned DestBits = DstVT.getSizeInBits();
14903   unsigned NumBytes = std::max(VT.getSizeInBits() / 8, 1U);
15456     const unsigned SrcSz = VecVT.getVectorElementType().getSizeInBits();
15603      (ConstraintVT.getSizeInBits() == 64 ||
15604       ConstraintVT.getSizeInBits() == 128))
16102   const unsigned DstSz = Op.getValueType().getSizeInBits();
16103   const unsigned SrcSz = SrcVal.getValueType().getSizeInBits();
16151   const unsigned DstSz = Op.getValueType().getSizeInBits();
16152   const unsigned SrcSz = SrcVT.getSizeInBits();
lib/Target/ARM/ARMISelLowering.h
  581       return (MemVT.getSizeInBits() <= 32);
lib/Target/ARM/ARMTargetTransformInfo.cpp
  911     if (VT.isInteger() && VT.getSizeInBits() >= 64) {
lib/Target/AVR/AVRISelLowering.cpp
  892     unsigned Bytes = ((Arg.ArgVT.getSizeInBits()) + 7) / 8;
 1117       int FI = MFI.CreateFixedObject(LocVT.getSizeInBits() / 8,
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp
  152     assert(LoadedVT.getSizeInBits() <= 32);
  518   if (ST->isTruncatingStore() && ValueVT.getSizeInBits() == 64) {
  519     assert(StoredVT.getSizeInBits() < 64 && "Not a truncating store");
 1318   if (!T.isInteger() || T.getSizeInBits() != 32 || !isa<ConstantSDNode>(N))
 1447       unsigned SW = T.getSizeInBits();
 1462       if (L->getMemoryVT().getSizeInBits() > 32)
 1504     if (T.isInteger() && T.getSizeInBits() == NumBits) {
 1515       if (T->getVT().getSizeInBits() == NumBits) {
 1588     return VN->getVT().getSizeInBits() <= 16;
lib/Target/Hexagon/HexagonISelLowering.cpp
  844         unsigned OrigBW = OrigTy.getSizeInBits();
lib/Target/Hexagon/HexagonInstrInfo.cpp
 2638   int Size = VT.getSizeInBits() / 8;
lib/Target/Hexagon/HexagonTargetTransformInfo.cpp
   54   if (!VecVT.isSimple() || VecVT.getSizeInBits() <= 64)
lib/Target/Lanai/LanaiISelLowering.cpp
 1238   unsigned VTBits = VT.getSizeInBits();
 1395           DAG.getConstant(APInt::getAllOnesValue(VT.getSizeInBits()), dl, VT);
lib/Target/MSP430/MSP430ISelLowering.cpp
 1388   return (VT1.getSizeInBits() > VT2.getSizeInBits());
 1388   return (VT1.getSizeInBits() > VT2.getSizeInBits());
lib/Target/Mips/MipsCallLowering.cpp
  387   if (VT.getSizeInBits() >= RegisterVT.getSizeInBits())
lib/Target/Mips/MipsISelDAGToDAG.cpp
  299             cast<MemSDNode>(Node)->getMemoryVT().getSizeInBits() / 8 <=
lib/Target/Mips/MipsISelLowering.cpp
  118         return (VT.getSizeInBits() == 32) ? MVT::i32 : MVT::i64;
  128     return std::max((VT.getSizeInBits() / (Subtarget.isABI_O32() ? 32 : 64)),
  139   NumIntermediates = VT.getSizeInBits() < RegisterVT.getSizeInBits()
  141                          : VT.getSizeInBits() / RegisterVT.getSizeInBits();
  817     if (SMPos != 0 || Pos + SMSize > ValTy.getSizeInBits())
  835     if (SMPos != Pos || Pos >= ValTy.getSizeInBits() || SMSize >= 32 ||
  836         Pos + SMSize > ValTy.getSizeInBits())
  908     if ((Shamt != SMPos0) || (SMPos0 + SMSize0 > ValTy.getSizeInBits()))
  952           DAG.getConstant(ValTy.getSizeInBits() / 8 < 8 ? SMSize0 & 31
 1128   if (Pos >= ValTy.getSizeInBits())
 1141   if (SMPos != 0 || SMSize > 32 || Pos + SMSize > ValTy.getSizeInBits())
 2037     unsigned PtrSize = PtrVT.getSizeInBits();
 2560   if ((LD->getAlignment() >= MemVT.getSizeInBits() / 8) ||
 2684       (SD->getAlignment() < MemVT.getSizeInBits() / 8) &&
 3200       unsigned ValSizeInBits = Outs[i].ArgVT.getSizeInBits();
 3363       unsigned ValSizeInBits = Ins[i].ArgVT.getSizeInBits();
 3417     unsigned ValSizeInBits = ArgVT.getSizeInBits();
 3704       unsigned ValSizeInBits = Outs[i].ArgVT.getSizeInBits();
 3870   bool Cond = !Subtarget.isABI_O32() && VT.getSizeInBits() == 32;
lib/Target/Mips/MipsSEISelDAGToDAG.cpp
  557   if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
  558       ImmValue.getBitWidth() == EltTy.getSizeInBits()) {
  633   if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
  634       ImmValue.getBitWidth() == EltTy.getSizeInBits()) {
  664   if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
  665       ImmValue.getBitWidth() == EltTy.getSizeInBits()) {
  698   if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
  699       ImmValue.getBitWidth() == EltTy.getSizeInBits()) {
  720   if (selectVSplat(N.getNode(), ImmValue, EltTy.getSizeInBits()) &&
  721       ImmValue.getBitWidth() == EltTy.getSizeInBits()) {
lib/Target/Mips/MipsSEISelLowering.cpp
  509     unsigned ExtendTySize = ExtendTy.getSizeInBits();
  785   Steps *= (VT.getSizeInBits() != RegisterSize) * 3;
  917       unsigned TotalBits = ShAmount->getZExtValue() + ExtendTy.getSizeInBits();
 1422       APInt(Op->getValueType(0).getScalarType().getSizeInBits(),
 1614     if (Op->getConstantOperandVal(3) >= EltTy.getSizeInBits())
 1616     APInt Mask = APInt::getHighBitsSet(EltTy.getSizeInBits(),
 1629     if (Op->getConstantOperandVal(3) >= EltTy.getSizeInBits())
 1631     APInt Mask = APInt::getLowBitsSet(EltTy.getSizeInBits(),
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
  386         unsigned sz = elemtype.getSizeInBits();
 1597           unsigned sz = elemtype.getSizeInBits();
lib/Target/NVPTX/NVPTXISelLowering.cpp
 1525         } else if (EltVT.getSizeInBits() < 16) {
 1612       if (elemtype.getSizeInBits() < 16) {
 1791       } else if (TheLoadType.getSizeInBits() < 16) {
 1967   unsigned VTBits = VT.getSizeInBits();
 2028   unsigned VTBits = VT.getSizeInBits();
 2342     if (EltVT.getSizeInBits() < 16)
 2610                 Ins[InsIdx].VT.getSizeInBits() > LoadVT.getSizeInBits()) {
 4587     if (OrigVT.getSizeInBits() <= OptSize) {
 4593     if (OrigVT.getSizeInBits() <= OptSize) {
 4650   unsigned OptSize = MulType.getSizeInBits() >> 1;
 4669     unsigned BitWidth = MulType.getSizeInBits();
 4832   if (EltVT.getSizeInBits() < 16) {
 4939       if (EltVT.getSizeInBits() < 16) {
lib/Target/PowerPC/PPCISelDAGToDAG.cpp
 1047         std::max(MaxTruncation, Use->getValueType(0).getSizeInBits());
 1053       unsigned MemVTSize = STN->getMemoryVT().getSizeInBits();
 1368       const unsigned NumAllBits = FromType.getSizeInBits();
 1372       const unsigned NumValidBits = ToType.getSizeInBits();
 1398       const unsigned NumValidBits = FromType.getSizeInBits();
 1414         const unsigned NumValidBits = VT.getSizeInBits();
 2408         getValueBits(SDValue(N, 0), N->getValueType(0).getSizeInBits());
lib/Target/PowerPC/PPCISelLowering.cpp
 3227   uint64_t FrameOffset = PtrVT.getSizeInBits()/8;
 3230   uint64_t StackOffset = PtrVT.getSizeInBits()/8 - 1;
 3619     int Depth = NumGPArgRegs * PtrVT.getSizeInBits()/8 +
 3623       MFI.CreateFixedObject(PtrVT.getSizeInBits()/8,
 3643       SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, dl, PtrVT);
 4206     unsigned ObjSize = ObjectVT.getSizeInBits()/8;
 4431       MFI.CreateFixedObject(PtrVT.getSizeInBits()/8,
 4451       SDValue PtrOff = DAG.getConstant(PtrVT.getSizeInBits()/8, dl, PtrVT);
 7189   unsigned SrcSize = N1.getValueType().getSizeInBits();
 7196   unsigned WideNumElts = 128 / EltVT.getSizeInBits();
 7200   unsigned SizeMult = SrcSize / TrgVT.getSizeInBits();
 7634   assert(VecVT.getSizeInBits() < 128 && "Vector is already full width.");
 7637   unsigned WideNumElts = 128 / EltVT.getSizeInBits();
 8013   return DAG.getNode((VT.getSizeInBits() < 16 ?
 8019   unsigned BitWidth = VT.getSizeInBits();
 8049   unsigned BitWidth = VT.getSizeInBits();
 8078   unsigned BitWidth = VT.getSizeInBits();
 9169   unsigned BytesPerElement = EltVT.getSizeInBits()/8;
 9579   if (MemVT.getSizeInBits() >= 32)
 9584   auto HighBits = APInt::getHighBitsSet(32, 32 - MemVT.getSizeInBits());
 9589   unsigned MaskVal = (1 << MemVT.getSizeInBits()) - 1;
 9639     unsigned BytesInEachElement = VT.getVectorElementType().getSizeInBits() / 8;
10245         OpVT.getSizeInBits() <= 128 &&
10246         isPowerOf2_32(OpVT.getVectorElementType().getSizeInBits()))
11724   if (VT.getSizeInBits() / 8 != Bytes)
13443       if (mVT.isExtended() || mVT.getSizeInBits() < 16)
13454         int Shift = Op1VT.getSizeInBits() - mVT.getSizeInBits();
13454         int Shift = Op1VT.getSizeInBits() - mVT.getSizeInBits();
13478                                     MemVT.getSizeInBits());
13711       int IncOffset = VT.getSizeInBits() / 8;
14868   unsigned NumBits1 = VT1.getSizeInBits();
14869   unsigned NumBits2 = VT2.getSizeInBits();
lib/Target/RISCV/RISCVISelLowering.cpp
  301   unsigned SrcBits = SrcVT.getSizeInBits();
  302   unsigned DestBits = DstVT.getSizeInBits();
  548   IntegerType *CallTy = Type::getIntNTy(*DAG.getContext(), Ty.getSizeInBits());
 1054       int C1Cost = RISCVMatInt::getIntMatCost(C1Int, Ty.getSizeInBits(),
 1057           ShiftedC1Int, Ty.getSizeInBits(), Subtarget.is64Bit());
 1749   int FI = MFI.CreateFixedObject(ValVT.getSizeInBits() / 8,
lib/Target/Sparc/SparcISelLowering.cpp
 2532                                 DAG.getIntPtrConstant(VT.getSizeInBits()/8,
 2540                      std::min(PtrVT.getSizeInBits(), VT.getSizeInBits()) / 8);
 2540                      std::min(PtrVT.getSizeInBits(), VT.getSizeInBits()) / 8);
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp
  954   if (!VT.isInteger() || VT.getSizeInBits() > 64)
 1054   if (!VT.isInteger() || VT.getSizeInBits() > 64)
 1159   else if (VT.getSizeInBits() == 128) {
 1165         (VT.getSizeInBits() == 32 ? SystemZ::subreg_h32 : SystemZ::subreg_h64);
 1186   if (Load->getMemoryVT().getSizeInBits() !=
 1187       Load->getValueType(0).getSizeInBits())
 1210   if (Store->getMemoryVT().getSizeInBits() != Value.getValueSizeInBits())
 1870       int ShlAmt = VT.getSizeInBits() - 1 - IPM.Bit;
 1871       int SraAmt = VT.getSizeInBits() - 1;
lib/Target/SystemZ/SystemZISelLowering.cpp
  942   unsigned FromBits = FromVT.getSizeInBits();
  943   unsigned ToBits = ToVT.getSizeInBits();
 1361       int FI = MFI.CreateFixedObject(LocVT.getSizeInBits() / 8,
 3593   int64_t OrigBitSize = VT.getSizeInBits();
 3678   int64_t BitSize = NarrowVT.getSizeInBits();
 3806   int64_t BitSize = NarrowVT.getSizeInBits();
 4844   MVT IntVT = MVT::getIntegerVT(VT.getSizeInBits());
 5324       EVT VT = MVT::getIntegerVT(ResVT.getSizeInBits());
 5378       TruncVT.getSizeInBits() % 8 == 0) {
 5468         unsigned Extra = (VT.getSizeInBits() - N0.getValueSizeInBits());
 5570       VT.getSizeInBits() != 128 ||
lib/Target/WebAssembly/WebAssemblyISelLowering.cpp
  310   unsigned BitWidth = NextPowerOf2(VT.getSizeInBits() - 1);
  318     assert(BitWidth >= Log2_32_Ceil(VT.getSizeInBits()) &&
 1495   uint64_t MaskVal = LaneT.getSizeInBits() - 1;
lib/Target/X86/X86FastISel.cpp
 3583       unsigned MemSize = ResVT.getSizeInBits()/8;
lib/Target/X86/X86ISelDAGToDAG.cpp
 2576   if (!CR || CR->getUnsignedMax().uge(1ull << VT.getSizeInBits()))
 3859   assert(VT.getSizeInBits() % 32 == 0 &&
 3864   unsigned NumElts = VT.getSizeInBits() / 32;
 4186       if (MemIntr->getMemoryVT().getSizeInBits() == CmpSVT.getSizeInBits())
lib/Target/X86/X86ISelLowering.cpp
 2145     switch (VT.getSizeInBits()) {
 3075       int64_t PartEnd = PartBegin + ValVT.getSizeInBits() / 8;
 3095   int FI = MFI.CreateFixedObject(ValVT.getSizeInBits() / 8,
 4966     return Index == 0 || ((ResVT.getSizeInBits() == SrcVT.getSizeInBits()*2) &&
 4966     return Index == 0 || ((ResVT.getSizeInBits() == SrcVT.getSizeInBits()*2) &&
 5035     return (MemVT.getSizeInBits() <= MaxIntSize);
 5039   if (MemVT.getSizeInBits() > Subtarget.getPreferVectorWidth())
 5077   if (!Subtarget.hasSSE1() || VT.getSizeInBits() < 128)
 5462   unsigned Factor = VT.getSizeInBits()/vectorWidth;
 5467   unsigned ElemsPerChunk = vectorWidth / ElVT.getSizeInBits();
 5516   unsigned ElemsPerChunk = vectorWidth/ElVT.getSizeInBits();
 5587     if (VT.getSizeInBits() == (SubVT.getSizeInBits() * 2) &&
 5587     if (VT.getSizeInBits() == (SubVT.getSizeInBits() * 2) &&
 5616     if (VT.getSizeInBits() > 512) {
 5617       NumSubs = VT.getSizeInBits() / 512;
 5618       assert((VT.getSizeInBits() % 512) == 0 && "Illegal vector size");
 5621     if (VT.getSizeInBits() > 256) {
 5622       NumSubs = VT.getSizeInBits() / 256;
 5623       assert((VT.getSizeInBits() % 256) == 0 && "Illegal vector size");
 5626     if (VT.getSizeInBits() > 128) {
 5627       NumSubs = VT.getSizeInBits() / 128;
 5628       assert((VT.getSizeInBits() % 128) == 0 && "Illegal vector size");
 5641       unsigned SizeSub = OpVT.getSizeInBits() / NumSubs;
 5803   unsigned SubVectorWidth = SubVT.getSizeInBits();
 5817   unsigned NumElts = VT.getSizeInBits() / 32;
 5848   if (InVT.getSizeInBits() > 128) {
 5849     assert(VT.getSizeInBits() == InVT.getSizeInBits() &&
 5849     assert(VT.getSizeInBits() == InVT.getSizeInBits() &&
 5853                           std::max(128U, VT.getSizeInBits() / Scale));
 5964   unsigned SizeInBits = VT.getSizeInBits();
 6357   int NumLanes = VT.getSizeInBits() / 128;
 6382   int NumLanes = VT.getSizeInBits() / 128;
 7022                                    NumSizeInBits / SubSVT.getSizeInBits());
 7207     if (!SrcVT.isSimple() || (SrcVT.getSizeInBits() % 128) != 0 ||
 7217     if (NumSizeInBits != SrcVT.getSizeInBits()) {
 7218       assert((NumSizeInBits % SrcVT.getSizeInBits()) == 0 &&
 7825     if ((NumElems * EltSizeInBits) != VT.getSizeInBits())
 7854   assert(EltBaseVT.getSizeInBits() == EltBaseVT.getStoreSizeInBits() &&
 7913       VT.getSizeInBits() / 8, *DAG.getContext(), DAG.getDataLayout());
 7981     MVT VecVT = MVT::getVectorVT(VecSVT, VT.getSizeInBits() / LoadSizeInBits);
 8034                            VT.getSizeInBits() / ScalarSize);
12377   const unsigned EltSize = EltVT.getSizeInBits();
12378   const unsigned V0EltSize = V0EltVT.getSizeInBits();
18484   unsigned ByteSize = SrcVT.getSizeInBits() / 8;
19203   unsigned DstSizeInBits = DstVT.getSizeInBits();
19204   unsigned SrcSizeInBits = SrcVT.getSizeInBits();
19229     InVT = EVT::getVectorVT(Ctx, InVT, 128 / InVT.getSizeInBits());
19230     OutVT = EVT::getVectorVT(Ctx, OutVT, 128 / OutVT.getSizeInBits());
19243   InVT = EVT::getVectorVT(Ctx, InVT, SubSizeInBits / InVT.getSizeInBits());
19244   OutVT = EVT::getVectorVT(Ctx, OutVT, SubSizeInBits / OutVT.getSizeInBits());
19700   unsigned BitWidth = VecVT.getSizeInBits();
20336   APInt Lg2Mask = APInt::getLowBitsSet(VT.getSizeInBits(), Lg2);
25386   assert(VT.isInteger() && VT.getSizeInBits() == 128 &&
25408     assert(ArgVT.isInteger() && ArgVT.getSizeInBits() == 128 &&
27874     assert(VT.getSizeInBits() < 128 && 128 % VT.getSizeInBits() == 0 &&
27874     assert(VT.getSizeInBits() < 128 && 128 % VT.getSizeInBits() == 0 &&
27878     unsigned NumConcat = 128 / InVT.getSizeInBits();
27950         unsigned NumConcats = 128 / VT.getSizeInBits();
27982     unsigned InBits = InVT.getSizeInBits();
28145       unsigned NumConcats = 128 / VT.getSizeInBits();
29050   unsigned NumBits1 = VT1.getSizeInBits();
29051   unsigned NumBits2 = VT2.getSizeInBits();
31437   unsigned Size = VT.getSizeInBits();
32850   unsigned RootSizeInBits = RootVT.getSizeInBits();
33496     if (SrcVT.getSizeInBits() > 128)
34543     unsigned SizeInBits = VT.getSizeInBits();
34655         return VT.getSizeInBits() != V.getValueSizeInBits() ||
35023           return VT.getSizeInBits() == V.getValueSizeInBits();
35720   unsigned RegSize = std::max(128u, InVT.getSizeInBits());
35724   unsigned NumConcat = RegSize / InVT.getSizeInBits();
35764   if (SrcSVT != ExtractVT || (SrcVT.getSizeInBits() % 128) != 0)
35771   while (SrcVT.getSizeInBits() > 128) {
35775     unsigned SubSizeInBits = SrcVT.getSizeInBits();
35787   unsigned MaskEltsBits = ExtractVT.getSizeInBits();
35830   unsigned BitWidth = ExtractVT.getSizeInBits();
35960   if (!VT.isSimple() || !(VT.getVectorElementType().getSizeInBits() > 16))
36059     if (SrcOp.getValueSizeInBits() == VT.getSizeInBits())
36068     if (MemIntr->getMemoryVT().getSizeInBits() == SrcBCWidth &&
36069         VT.getSizeInBits() == SrcBCWidth) {
36153     assert(VT.getSizeInBits() >= SrcSVT.getSizeInBits() &&
36153     assert(VT.getSizeInBits() >= SrcSVT.getSizeInBits() &&
36317   if ((VecVT.getSizeInBits() % 128) != 0 ||
36324       unsigned HalfSize = VecVT.getSizeInBits() / 2;
36414             SDValue(N, 0), APInt::getAllOnesValue(VT.getSizeInBits()), DCI))
36616     MVT AndNVT = MVT::getVectorVT(MVT::i64, CondVT.getSizeInBits() / 64);
37043                             VT.getSizeInBits());
37045                             VT.getSizeInBits());
37050       return extractSubVector(Res, 0, DAG, DL, VT.getSizeInBits());
37646         assert(Diff.getBitWidth() == N->getValueType(0).getSizeInBits() &&
38315   unsigned Size = VT.getSizeInBits();
38438     unsigned NumLanes = VT.getSizeInBits() / 128;
39493   unsigned Log2b = Log2_32(VT.getSizeInBits());
39800       Shift.getConstantOperandAPInt(1) != (ShiftTy.getSizeInBits() - 1))
39994                       (InVT.getSizeInBits() > 128) &&
39995                       (Subtarget.hasVLX() || InVT.getSizeInBits() > 256) &&
39996                       !(!Subtarget.useAVX512Regs() && VT.getSizeInBits() >= 256);
39999       VT.getSizeInBits() >= 64 &&
40042         unsigned NumConcats = 512 / InVT.getSizeInBits();
40051       if (ResElts * SVT.getSizeInBits() < 128)
40052         ResElts = 128 / SVT.getSizeInBits();
40082   if (InScalarVT.getSizeInBits() <= ScalarVT.getSizeInBits())
40082   if (InScalarVT.getSizeInBits() <= ScalarVT.getSizeInBits())
40659   if (VT.getSizeInBits() != 64)
41766   unsigned NumBits = VT.getSizeInBits();
42187     if (N00.getValueType() == MVT::v4i32 && ExtraVT.getSizeInBits() < 128) {
42337   unsigned EltSizeInBits = SVT.getSizeInBits();
42357   assert(NumElts == SclVT.getSizeInBits() && "Unexpected bool vector size");
42426   unsigned Size = VT.getSizeInBits();
42439   if (Size != MatchingVecType.getSizeInBits())
42658   unsigned OpSize = OpVT.getSizeInBits();
43117       VT.getSizeInBits() != N->getOperand(0).getValueSizeInBits())
43164   unsigned DestWidth = TruncVT.getSizeInBits();
43165   unsigned SrcWidth = SrcVT.getSizeInBits();
43171   unsigned VecWidth = SrcVecVT.getSizeInBits();
43374     unsigned BitWidth = VT.getSizeInBits();
43777   if (VT.getSizeInBits() / 4 > RegSize)
43810   if (VT.getSizeInBits() > ResVT.getSizeInBits()) {
43812     assert(VT.getSizeInBits() % ResVT.getSizeInBits() == 0 && "Unexpected VTs");
43813     unsigned NumConcats = VT.getSizeInBits() / ResVT.getSizeInBits();
43817   } else if (VT.getSizeInBits() < ResVT.getSizeInBits()) {
44603       InVecVT.getSizeInBits() == 256 && InVecBC.getOpcode() == ISD::AND) {
44690     if (MemIntr->getMemoryVT().getSizeInBits() <= VT.getSizeInBits()) {
lib/Target/X86/X86SelectionDAGInfo.cpp
  139       unsigned UBytes = AVT.getSizeInBits() / 8;
lib/Target/XCore/XCoreISelLowering.cpp
  749                                 DAG.getIntPtrConstant(VT.getSizeInBits() / 8,
 1657       APInt Mask = APInt::getHighBitsSet(VT.getSizeInBits(),
 1658                                          VT.getSizeInBits() - 1);
 1679       APInt Mask = APInt::getHighBitsSet(VT.getSizeInBits(),
 1680                                          VT.getSizeInBits() - 1);
 1694       APInt Mask = APInt::getHighBitsSet(VT.getSizeInBits(),
 1695                                          VT.getSizeInBits() - 1);