lib/Analysis/ValueTracking.cpp

130 static void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
134 void llvm::computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
138   ::computeKnownBits(V, KnownZero, KnownOne, DL, Depth,
157 static void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
161 void llvm::ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
165   ::ComputeSignBit(V, KnownZero, KnownOne, DL, Depth,
229                                    APInt &KnownZero, APInt &KnownOne,
291   KnownOne = PossibleSumOne & Known;
303         KnownOne |= APInt::getSignBit(BitWidth);
309                                 APInt &KnownZero, APInt &KnownOne,
314   computeKnownBits(Op1, KnownZero, KnownOne, DL, Depth + 1, Q);
327       bool isKnownNegativeOp1 = KnownOne.isNegative();
346   KnownOne.clearAllBits();
363   if (isKnownNonNegative && !KnownOne.isNegative())
366     KnownOne.setBit(BitWidth - 1);
371                                              APInt &KnownOne) {
377   KnownOne.setAllBits();
391     KnownOne &= Range.getUnsignedMax() & Mask;
547                                               APInt &KnownOne,
587       KnownOne |= KnownOneTemp;
620                                                     APInt &KnownOne,
687     computeKnownBitsFromTrueCondition(V, Cmp, KnownZero, KnownOne, DL, Depth,
721       computeKnownBitsFromTrueCondition(V, Cmp, KnownZero, KnownOne, DL, Depth,
728                                        APInt &KnownOne, const DataLayout &DL,
758       KnownOne.setAllBits();
779       KnownOne  |= RHSKnownOne;
792       KnownOne  |= RHSKnownOne  & MaskKnownOne;
805       KnownOne  |= RHSKnownZero & MaskKnownOne;
818       KnownOne  |= RHSKnownOne  & BKnownZero;
831       KnownOne  |= RHSKnownZero & BKnownZero;
845       KnownOne  |= RHSKnownOne  & BKnownZero;
847       KnownOne  |= RHSKnownZero & BKnownOne;
861       KnownOne  |= RHSKnownZero & BKnownZero;
863       KnownOne  |= RHSKnownOne  & BKnownOne;
873       KnownOne  |= RHSKnownOne.lshr(C->getZExtValue());
883       KnownOne  |= RHSKnownZero.lshr(C->getZExtValue());
895       KnownOne  |= RHSKnownOne  << C->getZExtValue();
907       KnownOne  |= RHSKnownZero << C->getZExtValue();
936         KnownOne |= APInt::getSignBit(BitWidth);
946         KnownOne |= APInt::getSignBit(BitWidth);
976 // non-constant shift amount. KnownZero and KnownOne are the outputs of this
978 // same bit width as KnownZero and KnownOne. KZF and KOF are operator-specific
985               APInt &KnownZero, APInt &KnownOne,
994     computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1, Q);
996     KnownOne  = KOF(KnownOne, ShiftAmt);
1000   computeKnownBits(I->getOperand(1), KnownZero, KnownOne, DL, Depth + 1, Q);
1006   uint64_t ShiftAmtKO = KnownOne.zextOrTrunc(64).getZExtValue();
1010   KnownZero.clearAllBits(), KnownOne.clearAllBits();
1027   KnownZero = KnownOne = APInt::getAllOnesValue(BitWidth);
1047     KnownOne  &= KOF(KnownOne2, ShiftAmt);
1055   if ((KnownZero & KnownOne) != 0)
1056     KnownZero.clearAllBits(), KnownOne.clearAllBits();
1060                                          APInt &KnownOne, const DataLayout &DL,
1064   APInt KnownZero2(KnownZero), KnownOne2(KnownOne);
1069       computeKnownBitsFromRangeMetadata(*MD, KnownZero, KnownOne);
1073     computeKnownBits(I->getOperand(1), KnownZero, KnownOne, DL, Depth + 1, Q);
1077     KnownOne &= KnownOne2;
1099     computeKnownBits(I->getOperand(1), KnownZero, KnownOne, DL, Depth + 1, Q);
1105     KnownOne |= KnownOne2;
1109     computeKnownBits(I->getOperand(1), KnownZero, KnownOne, DL, Depth + 1, Q);
1113     APInt KnownZeroOut = (KnownZero & KnownZero2) | (KnownOne & KnownOne2);
1115     KnownOne = (KnownZero & KnownOne2) | (KnownOne & KnownZero2);
1122                         KnownOne, KnownZero2, KnownOne2, DL, Depth, Q);
1144     computeKnownBits(I->getOperand(2), KnownZero, KnownOne, DL, Depth + 1, Q);
1148     KnownOne &= KnownOne2;
1173     KnownOne = KnownOne.zextOrTrunc(SrcBitWidth);
1174     computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1, Q);
1176     KnownOne = KnownOne.zextOrTrunc(BitWidth);
1189       computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1, Q);
1199     KnownOne = KnownOne.trunc(SrcBitWidth);
1200     computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1, Q);
1202     KnownOne = KnownOne.zext(BitWidth);
1208     else if (KnownOne[SrcBitWidth-1])           // Input sign bit known set
1209       KnownOne |= APInt::getHighBitsSet(BitWidth, BitWidth - SrcBitWidth);
1219     auto KOF = [BitWidth](const APInt &KnownOne, unsigned ShiftAmt) {
1220       return KnownOne << ShiftAmt;
1223     computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
1236     auto KOF = [BitWidth](const APInt &KnownOne, unsigned ShiftAmt) {
1237       return APIntOps::lshr(KnownOne, ShiftAmt);
1240     computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
1251     auto KOF = [BitWidth](const APInt &KnownOne, unsigned ShiftAmt) {
1252       return APIntOps::ashr(KnownOne, ShiftAmt);
1255     computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
1263                            KnownZero, KnownOne, KnownZero2, KnownOne2, DL,
1270                            KnownZero, KnownOne, KnownZero2, KnownOne2, DL,
1284         KnownOne = KnownOne2 & LowBits;
1294           KnownOne |= ~LowBits;
1296         assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1317         computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1,
1320         KnownOne &= LowBits;
1327     computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1, Q);
1332     KnownOne.clearAllBits();
1430           APInt KnownZero3(KnownZero), KnownOne3(KnownOne);
1447     if (Depth < MaxDepth - 1 && !KnownZero && !KnownOne) {
1453       KnownOne = APInt::getAllOnesValue(BitWidth);
1465         KnownOne &= KnownOne2;
1468         if (!KnownZero && !KnownOne)
1477       computeKnownBitsFromRangeMetadata(*MD, KnownZero, KnownOne);
1488         KnownOne |= KnownOne2.byteSwap();
1509         KnownOne &= ~KnownZero;
1510         // TODO: we could bound KnownOne using the lower bound on the number
1537                                  KnownOne, KnownZero2, KnownOne2, DL, Depth, Q);
1543                                  KnownOne, KnownZero2, KnownOne2, DL, Depth, Q);
1548                               KnownZero, KnownOne, KnownZero2, KnownOne2, DL,
1598 /// them in the KnownZero/KnownOne bit sets.
1612 void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
1626          KnownOne.getBitWidth() == BitWidth &&
1627          "V, KnownOne and KnownZero should have same BitWidth");
1631     KnownOne = CI->getValue();
1632     KnownZero = ~KnownOne;
1638     KnownOne.clearAllBits();
1648     KnownZero.setAllBits(); KnownOne.setAllBits();
1653       KnownOne &= Elt;
1659   KnownZero.clearAllBits(); KnownOne.clearAllBits();
1670       computeKnownBits(GA->getAliasee(), KnownZero, KnownOne, DL, Depth + 1, Q);
1675     computeKnownBitsFromOperator(I, KnownZero, KnownOne, DL, Depth, Q);
1685   // strictly refines KnownZero and KnownOne. Therefore, we run them after
1689   computeKnownBitsFromAssume(V, KnownZero, KnownOne, DL, Depth, Q);
1694     computeKnownBitsFromDominatingCondition(V, KnownZero, KnownOne, DL, Depth,
1697   assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1702 void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
1707     KnownOne = false;
1713   KnownOne = OneBits[BitWidth - 1];
1955     APInt KnownOne(BitWidth, 0);
1956     computeKnownBits(X, KnownZero, KnownOne, DL, Depth, Q);
1957     if (KnownOne[0])
1978       APInt KnownOne(BitWidth, 0);
1979       computeKnownBits(X, KnownZero, KnownOne, DL, Depth, Q);
1983       if (KnownOne.countLeadingZeros() < BitWidth - ShiftVal)
2011       APInt KnownOne(BitWidth, 0);
2015       computeKnownBits(X, KnownZero, KnownOne, DL, Depth, Q);
2016       if ((KnownOne & Mask) != 0)
2020       computeKnownBits(Y, KnownZero, KnownOne, DL, Depth, Q);
2021       if ((KnownOne & Mask) != 0)
2071   APInt KnownOne(BitWidth, 0);
2072   computeKnownBits(V, KnownZero, KnownOne, DL, Depth, Q);
2073   return KnownOne != 0;
2132   APInt KnownZero(Mask.getBitWidth(), 0), KnownOne(Mask.getBitWidth(), 0);
2133   computeKnownBits(V, KnownZero, KnownOne, DL, Depth, Q);
2270         APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
2271         computeKnownBits(U->getOperand(0), KnownZero, KnownOne, DL, Depth + 1,
2296         APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
2297         computeKnownBits(U->getOperand(1), KnownZero, KnownOne, DL, Depth + 1,
2345   APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
2347   computeKnownBits(V, KnownZero, KnownOne, DL, Depth, Q);
2351   } else if (KnownOne.isNegative()) {  // sign bit is 1;
2352     Mask = KnownOne;
4154         APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
4155         computeKnownBits(X, KnownZero, KnownOne, DL, Depth + 1, AC, CxtI, DT);