Lines Matching refs:KnownZero
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,
239 unsigned BitWidth = KnownZero.getBitWidth();
251 KnownZero = APInt::getHighBitsSet(BitWidth, NLZ2);
257 unsigned BitWidth = KnownZero.getBitWidth();
290 KnownZero = ~PossibleSumOne & Known;
299 KnownZero |= APInt::getSignBit(BitWidth);
309 APInt &KnownZero, APInt &KnownOne,
313 unsigned BitWidth = KnownZero.getBitWidth();
314 computeKnownBits(Op1, KnownZero, KnownOne, DL, Depth + 1, Q);
325 bool isKnownNonNegativeOp1 = KnownZero.isNegative();
347 unsigned TrailZ = KnownZero.countTrailingOnes() +
349 unsigned LeadZ = std::max(KnownZero.countLeadingOnes() +
355 KnownZero = APInt::getLowBitsSet(BitWidth, TrailZ) |
364 KnownZero.setBit(BitWidth - 1);
365 else if (isKnownNegative && !KnownZero.isNegative())
370 APInt &KnownZero,
372 KnownZero.getBitWidth();
376 KnownZero.setAllBits();
392 KnownZero &= ~Range.getUnsignedMax() & Mask;
546 APInt &KnownZero,
558 const unsigned BitWidth = KnownZero.getBitWidth();
573 KnownZero |= APInt::getSignBit(BitWidth);
586 KnownZero |= KnownZeroTemp;
596 KnownZero |= APInt::getHighBitsSet(BitWidth, SignBits);
608 KnownZero |= APInt::getHighBitsSet(BitWidth, SignBits);
619 static void computeKnownBitsFromDominatingCondition(Value *V, APInt &KnownZero,
687 computeKnownBitsFromTrueCondition(V, Cmp, KnownZero, KnownOne, DL, Depth,
721 computeKnownBitsFromTrueCondition(V, Cmp, KnownZero, KnownOne, DL, Depth,
727 static void computeKnownBitsFromAssume(Value *V, APInt &KnownZero,
735 unsigned BitWidth = KnownZero.getBitWidth();
757 KnownZero.clearAllBits();
778 KnownZero |= RHSKnownZero;
791 KnownZero |= RHSKnownZero & MaskKnownOne;
804 KnownZero |= RHSKnownOne & MaskKnownOne;
817 KnownZero |= RHSKnownZero & BKnownZero;
830 KnownZero |= RHSKnownOne & BKnownZero;
844 KnownZero |= RHSKnownZero & BKnownZero;
846 KnownZero |= RHSKnownOne & BKnownOne;
860 KnownZero |= RHSKnownOne & BKnownZero;
862 KnownZero |= RHSKnownZero & BKnownOne;
872 KnownZero |= RHSKnownZero.lshr(C->getZExtValue());
882 KnownZero |= RHSKnownOne.lshr(C->getZExtValue());
894 KnownZero |= RHSKnownZero << C->getZExtValue();
906 KnownZero |= RHSKnownOne << C->getZExtValue();
916 KnownZero |= APInt::getSignBit(BitWidth);
926 KnownZero |= APInt::getSignBit(BitWidth);
955 KnownZero |=
966 KnownZero |=
969 KnownZero |=
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,
989 unsigned BitWidth = KnownZero.getBitWidth();
994 computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1, Q);
995 KnownZero = KZF(KnownZero, ShiftAmt);
1000 computeKnownBits(I->getOperand(1), KnownZero, KnownOne, DL, Depth + 1, Q);
1002 // Note: We cannot use KnownZero.getLimitedValue() here, because if
1005 uint64_t ShiftAmtKZ = KnownZero.zextOrTrunc(64).getZExtValue();
1010 KnownZero.clearAllBits(), KnownOne.clearAllBits();
1027 KnownZero = KnownOne = APInt::getAllOnesValue(BitWidth);
1046 KnownZero &= KZF(KnownZero2, ShiftAmt);
1055 if ((KnownZero & KnownOne) != 0)
1056 KnownZero.clearAllBits(), KnownOne.clearAllBits();
1059 static void computeKnownBitsFromOperator(Operator *I, APInt &KnownZero,
1062 unsigned BitWidth = KnownZero.getBitWidth();
1064 APInt KnownZero2(KnownZero), KnownOne2(KnownOne);
1069 computeKnownBitsFromRangeMetadata(*MD, KnownZero, KnownOne);
1073 computeKnownBits(I->getOperand(1), KnownZero, KnownOne, DL, Depth + 1, Q);
1079 KnownZero |= KnownZero2;
1094 KnownZero |= APInt::getLowBitsSet(BitWidth, 1);
1099 computeKnownBits(I->getOperand(1), KnownZero, KnownOne, DL, Depth + 1, Q);
1103 KnownZero &= KnownZero2;
1109 computeKnownBits(I->getOperand(1), KnownZero, KnownOne, DL, Depth + 1, Q);
1113 APInt KnownZeroOut = (KnownZero & KnownZero2) | (KnownOne & KnownOne2);
1115 KnownOne = (KnownZero & KnownOne2) | (KnownOne & KnownZero2);
1116 KnownZero = KnownZeroOut;
1121 computeKnownBitsMul(I->getOperand(0), I->getOperand(1), NSW, KnownZero,
1140 KnownZero = APInt::getHighBitsSet(BitWidth, LeadZ);
1144 computeKnownBits(I->getOperand(2), KnownZero, KnownOne, DL, Depth + 1, Q);
1149 KnownZero &= KnownZero2;
1172 KnownZero = KnownZero.zextOrTrunc(SrcBitWidth);
1174 computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1, Q);
1175 KnownZero = KnownZero.zextOrTrunc(BitWidth);
1179 KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - SrcBitWidth);
1189 computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1, Q);
1198 KnownZero = KnownZero.trunc(SrcBitWidth);
1200 computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1, Q);
1201 KnownZero = KnownZero.zext(BitWidth);
1206 if (KnownZero[SrcBitWidth-1]) // Input sign bit known zero
1207 KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - SrcBitWidth);
1214 auto KZF = [BitWidth](const APInt &KnownZero, unsigned ShiftAmt) {
1215 return (KnownZero << ShiftAmt) |
1223 computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
1230 auto KZF = [BitWidth](const APInt &KnownZero, unsigned ShiftAmt) {
1231 return APIntOps::lshr(KnownZero, ShiftAmt) |
1240 computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
1247 auto KZF = [BitWidth](const APInt &KnownZero, unsigned ShiftAmt) {
1248 return APIntOps::ashr(KnownZero, ShiftAmt);
1255 computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
1263 KnownZero, KnownOne, KnownZero2, KnownOne2, DL,
1270 KnownZero, KnownOne, KnownZero2, KnownOne2, DL,
1283 KnownZero = KnownZero2 & LowBits;
1289 KnownZero |= ~LowBits;
1296 assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1302 if (KnownZero.isNonNegative()) {
1308 KnownZero.setBit(BitWidth - 1);
1317 computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1,
1319 KnownZero |= ~LowBits;
1327 computeKnownBits(I->getOperand(0), KnownZero, KnownOne, DL, Depth + 1, Q);
1330 unsigned Leaders = std::max(KnownZero.countLeadingOnes(),
1333 KnownZero = APInt::getHighBitsSet(BitWidth, Leaders);
1344 KnownZero = APInt::getLowBitsSet(BitWidth, countTrailingZeros(Align));
1392 KnownZero = APInt::getLowBitsSet(BitWidth, TrailZ);
1430 APInt KnownZero3(KnownZero), KnownOne3(KnownOne);
1433 KnownZero = APInt::getLowBitsSet(BitWidth,
1447 if (Depth < MaxDepth - 1 && !KnownZero && !KnownOne) {
1452 KnownZero = APInt::getAllOnesValue(BitWidth);
1464 KnownZero &= KnownZero2;
1468 if (!KnownZero && !KnownOne)
1477 computeKnownBitsFromRangeMetadata(*MD, KnownZero, KnownOne);
1487 KnownZero |= KnownZero2.byteSwap();
1496 KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - LowBits);
1508 KnownZero |= APInt::getHighBitsSet(BitWidth, LeadingZeros);
1509 KnownOne &= ~KnownZero;
1517 KnownZero
1521 KnownZero |= APInt::getHighBitsSet(64, 32);
1536 II->getArgOperand(1), false, KnownZero,
1542 II->getArgOperand(1), false, KnownZero,
1548 KnownZero, KnownOne, KnownZero2, KnownOne2, DL,
1598 /// them in the KnownZero/KnownOne bit sets.
1612 void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
1616 unsigned BitWidth = KnownZero.getBitWidth();
1625 KnownZero.getBitWidth() == BitWidth &&
1627 "V, KnownOne and KnownZero should have same BitWidth");
1632 KnownZero = ~KnownOne;
1639 KnownZero = APInt::getAllOnesValue(BitWidth);
1648 KnownZero.setAllBits(); KnownOne.setAllBits();
1649 APInt Elt(KnownZero.getBitWidth(), 0);
1652 KnownZero &= ~Elt;
1659 KnownZero.clearAllBits(); KnownOne.clearAllBits();
1670 computeKnownBits(GA->getAliasee(), KnownZero, KnownOne, DL, Depth + 1, Q);
1675 computeKnownBitsFromOperator(I, KnownZero, KnownOne, DL, Depth, Q);
1677 // Aligned pointers have trailing zeros - refine KnownZero set
1681 KnownZero |= APInt::getLowBitsSet(BitWidth, countTrailingZeros(Align));
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,
1706 KnownZero = false;
1714 KnownZero = ZeroBits[BitWidth - 1];
1953 APInt KnownZero(BitWidth, 0);
1955 computeKnownBits(X, KnownZero, KnownOne, DL, Depth, Q);
1976 APInt KnownZero(BitWidth, 0);
1978 computeKnownBits(X, KnownZero, KnownOne, DL, Depth, Q);
1985 if (KnownZero.countTrailingOnes() >= ShiftVal)
2009 APInt KnownZero(BitWidth, 0);
2014 computeKnownBits(X, KnownZero, KnownOne, DL, Depth, Q);
2019 computeKnownBits(Y, KnownZero, KnownOne, DL, Depth, Q);
2069 APInt KnownZero(BitWidth, 0);
2071 computeKnownBits(V, KnownZero, KnownOne, DL, Depth, Q);
2131 APInt KnownZero(Mask.getBitWidth(), 0), KnownOne(Mask.getBitWidth(), 0);
2132 computeKnownBits(V, KnownZero, KnownOne, DL, Depth, Q);
2133 return (KnownZero & Mask) == Mask;
2269 APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
2270 computeKnownBits(U->getOperand(0), KnownZero, KnownOne, DL, Depth + 1,
2275 if ((KnownZero | APInt(TyBits, 1)).isAllOnesValue())
2280 if (KnownZero.isNegative())
2295 APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
2296 computeKnownBits(U->getOperand(1), KnownZero, KnownOne, DL, Depth + 1,
2300 if ((KnownZero | APInt(TyBits, 1)).isAllOnesValue())
2305 if (KnownZero.isNegative())
2344 APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
2346 computeKnownBits(V, KnownZero, KnownOne, DL, Depth, Q);
2348 if (KnownZero.isNegative()) { // sign bit is 0
2349 Mask = KnownZero;
4143 APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
4144 computeKnownBits(X, KnownZero, KnownOne, DL, Depth + 1, AC, CxtI, DT);
4146 if ((KnownZero & *CA) == *CA && (KnownZero & *CB) == *CB)
