Lines Matching refs:Depth
151 KnownBits &Known, unsigned Depth,
154 void llvm::computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth,
162 ::computeKnownBits(V, DemandedElts, Known, Depth, Q);
166 const DataLayout &DL, unsigned Depth,
170 V, Known, Depth,
175 unsigned Depth, AssumptionCache *AC,
179 V, Depth, SimplifyQuery(DL, DT, AC, safeCxtI(V, CxtI), UseInstrInfo));
183 const DataLayout &DL, unsigned Depth,
187 V, DemandedElts, Depth,
269 static bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero, unsigned Depth,
273 bool OrZero, unsigned Depth,
277 V, OrZero, Depth,
282 const SimplifyQuery &Q, unsigned Depth);
285 unsigned Depth) {
286 return computeKnownBits(V, Depth, SQ).isNonNegative();
290 unsigned Depth) {
296 KnownBits Known = computeKnownBits(V, Depth, SQ);
298 (Known.isNonZero() || isKnownNonZero(V, SQ, Depth));
302 unsigned Depth) {
303 return computeKnownBits(V, Depth, SQ).isNegative();
307 const APInt &DemandedElts, unsigned Depth,
325 const SimplifyQuery &SQ, unsigned Depth) {
327 computeKnownBits(V, Known, Depth, SQ);
332 unsigned Depth, const SimplifyQuery &Q);
334 static unsigned ComputeNumSignBits(const Value *V, unsigned Depth,
339 return ComputeNumSignBits(V, DemandedElts, Depth, Q);
343 unsigned Depth, AssumptionCache *AC,
347 V, Depth, SimplifyQuery(DL, DT, AC, safeCxtI(V, CxtI), UseInstrInfo));
351 unsigned Depth, AssumptionCache *AC,
354 unsigned SignBits = ComputeNumSignBits(V, DL, Depth, AC, CxtI, DT);
362 unsigned Depth, const SimplifyQuery &Q) {
363 computeKnownBits(Op1, DemandedElts, KnownOut, Depth + 1, Q);
370 computeKnownBits(Op0, DemandedElts, Known2, Depth + 1, Q);
376 KnownBits &Known2, unsigned Depth,
378 computeKnownBits(Op1, DemandedElts, Known, Depth + 1, Q);
379 computeKnownBits(Op0, DemandedElts, Known2, Depth + 1, Q);
409 isGuaranteedNotToBeUndef(Op0, Q.AC, Q.CxtI, Q.DT, Depth + 1);
757 KnownBits &Known, unsigned Depth,
760 if (Depth < MaxAnalysisRecursionDepth &&
764 computeKnownBitsFromCond(V, A, Known2, Depth + 1, SQ, Invert);
765 computeKnownBitsFromCond(V, B, Known3, Depth + 1, SQ, Invert);
779 unsigned Depth, const SimplifyQuery &Q) {
782 computeKnownBitsFromCond(V, Q.CC->Cond, Known, Depth, Q, Q.CC->Invert);
792 computeKnownBitsFromCond(V, BI->getCondition(), Known, Depth, Q,
797 computeKnownBitsFromCond(V, BI->getCondition(), Known, Depth, Q,
855 if (Depth == MaxAnalysisRecursionDepth)
884 KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q,
886 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
887 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
893 isKnownNonZero(I->getOperand(1), DemandedElts, Q, Depth + 1));
900 unsigned Depth, const SimplifyQuery &Q) {
957 computeKnownBits(Y, DemandedElts, KnownY, Depth + 1, Q);
969 const Operator *I, const APInt &DemandedElts, unsigned Depth,
979 [Depth, &Q, KnownBitsFunc](const Value *Op, APInt &DemandedEltsOp) {
981 computeKnownBits(Op, DemandedEltsOp, Depth + 1, Q),
982 computeKnownBits(Op, DemandedEltsOp << 1, Depth + 1, Q));
998 unsigned Depth,
1004 return getKnownBitsFromAndXorOr(I, DemandedElts, KnownLHS, KnownRHS, Depth,
1028 Value *Arm, bool Invert, unsigned Depth,
1036 computeKnownBitsFromCond(Arm, Cond, CondRes, Depth + 1, Q, Invert);
1053 if (!isGuaranteedNotToBeUndef(Arm, Q.AC, Q.CxtI, Q.DT, Depth + 1))
1063 KnownBits &Known, unsigned Depth,
1076 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1077 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1079 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1082 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1083 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1085 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1088 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1089 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1091 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1096 Known, Known2, Depth, Q);
1100 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1101 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1107 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1108 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1116 computeKnownBits(Arm, DemandedElts, Res, Depth + 1, Q);
1117 adjustKnownBitsForSelectArm(Res, I->getOperand(0), Arm, Invert, Depth, Q);
1151 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1164 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1174 computeKnownFPClass(V, DemandedElts, fcAllFlags, Depth + 1, Q);
1243 Depth + 1, Q);
1255 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1268 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1282 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1296 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1304 DemandedElts, Known, Known2, Depth, Q);
1311 DemandedElts, Known, Known2, Depth, Q);
1315 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1316 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1321 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1322 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1331 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1374 computeKnownBits(Index, IndexBits, Depth + 1, Q);
1440 computeKnownBits(R, DemandedElts, Known2, Depth + 1, RecQ);
1480 computeKnownBits(R, DemandedElts, Known2, Depth + 1, RecQ);
1485 computeKnownBits(L, DemandedElts, Known3, Depth + 1, RecQ);
1533 if (Depth < MaxAnalysisRecursionDepth - 1 && Known.isUnknown()) {
1618 computeKnownBits(RV, Known2, Depth + 1, Q);
1633 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1639 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1644 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1649 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1660 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1671 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1693 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1694 computeKnownBits(I->getOperand(1), DemandedElts, Known3, Depth + 1, Q);
1703 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1704 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1708 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1709 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1713 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1714 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1718 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1719 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1725 Depth + 1, Q);
1735 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1738 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1753 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1754 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1758 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1759 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1763 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1764 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1768 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1769 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1773 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1777 computeKnownBits(Mask, DemandedElts, Known2, Depth + 1, Q);
1785 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1786 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1792 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1793 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1804 I, DemandedElts, Depth, Q,
1814 Known = computeKnownBitsForHorizontalOperation(I, DemandedElts, Depth,
1823 I, DemandedElts, Depth, Q,
1833 Known = computeKnownBitsForHorizontalOperation(I, DemandedElts, Depth,
1888 computeKnownBits(LHS, DemandedLHS, Known, Depth + 1, Q);
1895 computeKnownBits(RHS, DemandedRHS, Known2, Depth + 1, Q);
1920 computeKnownBits(Elt, Known, Depth + 1, Q);
1927 computeKnownBits(Vec, DemandedVecElts, Known2, Depth + 1, Q);
1947 computeKnownBits(Vec, DemandedVecElts, Known, Depth + 1, Q);
1961 /* NUW=*/false, DemandedElts, Known, Known2, Depth, Q);
1967 /* NUW=*/false, DemandedElts, Known, Known2, Depth, Q);
1972 DemandedElts, Known, Known2, Depth, Q);
1980 Depth + 1))
1981 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1989 unsigned Depth, const SimplifyQuery &Q) {
1991 ::computeKnownBits(V, DemandedElts, Known, Depth, Q);
1997 KnownBits llvm::computeKnownBits(const Value *V, unsigned Depth,
2000 computeKnownBits(V, Known, Depth, Q);
2020 KnownBits &Known, unsigned Depth,
2029 assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
2128 if (Depth == MaxAnalysisRecursionDepth)
2135 computeKnownBits(GA->getAliasee(), Known, Depth + 1, Q);
2140 computeKnownBitsFromOperator(I, DemandedElts, Known, Depth, Q);
2156 computeKnownBitsFromContext(V, Known, Depth, Q);
2162 unsigned Depth, SimplifyQuery &Q) {
2174 if (!isKnownToBeAPowerOfTwo(Start, OrZero, Depth, Q))
2190 isKnownToBeAPowerOfTwo(Step, OrZero, Depth, Q);
2202 isKnownToBeAPowerOfTwo(Step, false, Depth, Q);
2220 bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero, unsigned Depth,
2222 assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
2252 if (Depth++ == MaxAnalysisRecursionDepth)
2257 return isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q);
2259 return OrZero && isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q);
2262 return isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q);
2266 return isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q);
2270 return isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q);
2273 return isKnownToBeAPowerOfTwo(I->getOperand(1), OrZero, Depth, Q) &&
2274 isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q) &&
2275 (OrZero || isKnownNonZero(I, Q, Depth));
2279 (isKnownToBeAPowerOfTwo(I->getOperand(1), /*OrZero*/ true, Depth, Q) ||
2280 isKnownToBeAPowerOfTwo(I->getOperand(0), /*OrZero*/ true, Depth, Q)))
2285 return OrZero || isKnownNonZero(I->getOperand(0), Q, Depth);
2295 isKnownToBeAPowerOfTwo(I->getOperand(1), OrZero, Depth, Q))
2299 isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q))
2304 computeKnownBits(I->getOperand(0), LHSBits, Depth, Q);
2307 computeKnownBits(I->getOperand(1), RHSBits, Depth, Q);
2325 return isKnownToBeAPowerOfTwo(I->getOperand(1), OrZero, Depth, Q) &&
2326 isKnownToBeAPowerOfTwo(I->getOperand(2), OrZero, Depth, Q);
2335 if (isPowerOfTwoRecurrence(PN, OrZero, Depth, RecQ))
2340 unsigned NewDepth = std::max(Depth, MaxAnalysisRecursionDepth - 1);
2360 return isKnownToBeAPowerOfTwo(II->getArgOperand(1), OrZero, Depth, Q) &&
2361 isKnownToBeAPowerOfTwo(II->getArgOperand(0), OrZero, Depth, Q);
2366 return isKnownToBeAPowerOfTwo(II->getArgOperand(0), OrZero, Depth, Q);
2371 return isKnownToBeAPowerOfTwo(II->getArgOperand(0), OrZero, Depth, Q);
2390 static bool isGEPKnownNonNull(const GEPOperator *GEP, unsigned Depth,
2408 if (isKnownNonZero(GEP->getPointerOperand(), Q, Depth))
2432 // increment Depth when just zipping down an all-constant GEP.
2439 // We post-increment Depth here because while isKnownNonZero increments it
2444 if (Depth++ >= MaxAnalysisRecursionDepth)
2447 if (isKnownNonZero(GTI.getOperand(), Q, Depth))
2603 static bool isNonZeroAdd(const APInt &DemandedElts, unsigned Depth,
2611 return isKnownNonZero(Y, DemandedElts, Q, Depth) ||
2612 isKnownNonZero(X, DemandedElts, Q, Depth);
2614 KnownBits XKnown = computeKnownBits(X, DemandedElts, Depth, Q);
2615 KnownBits YKnown = computeKnownBits(Y, DemandedElts, Depth, Q);
2620 if (isKnownNonZero(Y, DemandedElts, Q, Depth) ||
2621 isKnownNonZero(X, DemandedElts, Q, Depth))
2640 isKnownToBeAPowerOfTwo(Y, /*OrZero*/ false, Depth, Q))
2643 isKnownToBeAPowerOfTwo(X, /*OrZero*/ false, Depth, Q))
2650 static bool isNonZeroSub(const APInt &DemandedElts, unsigned Depth,
2660 if (C->isNullValue() && isKnownNonZero(Y, DemandedElts, Q, Depth))
2663 return ::isKnownNonEqual(X, Y, DemandedElts, Depth, Q);
2666 static bool isNonZeroMul(const APInt &DemandedElts, unsigned Depth,
2672 return isKnownNonZero(X, DemandedElts, Q, Depth) &&
2673 isKnownNonZero(Y, DemandedElts, Q, Depth);
2677 KnownBits XKnown = computeKnownBits(X, DemandedElts, Depth, Q);
2679 return isKnownNonZero(Y, DemandedElts, Q, Depth);
2681 KnownBits YKnown = computeKnownBits(Y, DemandedElts, Depth, Q);
2683 return XKnown.isNonZero() || isKnownNonZero(X, DemandedElts, Q, Depth);
2695 unsigned Depth, const SimplifyQuery &Q,
2726 computeKnownBits(I->getOperand(1), DemandedElts, Depth, Q);
2739 isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth))
2747 unsigned Depth, const SimplifyQuery &Q) {
2755 return isGEPKnownNonNull(cast<GEPOperator>(I), Depth, Q);
2788 return isKnownNonZero(I->getOperand(0), Q, Depth);
2797 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
2805 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
2811 return isKnownNonZero(TI->getOperand(0), DemandedElts, Q, Depth);
2815 return isNonZeroSub(DemandedElts, Depth, Q, BitWidth, I->getOperand(0),
2827 return isKnownNonZero(I->getOperand(1), DemandedElts, Q, Depth) ||
2828 isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
2832 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
2838 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
2843 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth, Q);
2847 return isNonZeroShift(I, DemandedElts, Depth, Q, Known);
2854 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
2859 computeKnownBits(I->getOperand(0), DemandedElts, Depth, Q);
2863 return isNonZeroShift(I, DemandedElts, Depth, Q, Known);
2870 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
2873 computeKnownBits(I->getOperand(0), DemandedElts, Depth, Q);
2880 computeKnownBits(I->getOperand(1), DemandedElts, Depth, Q);
2898 return isNonZeroAdd(DemandedElts, Depth, Q, BitWidth, I->getOperand(0),
2904 return isNonZeroMul(DemandedElts, Depth, Q, BitWidth, I->getOperand(0),
2919 if (isKnownNonZero(Op, DemandedElts, Q, Depth))
2947 unsigned NewDepth = std::max(Depth, MaxAnalysisRecursionDepth - 1);
2991 return (SkipElt || isKnownNonZero(Elt, Q, Depth)) &&
2993 isKnownNonZero(Vec, DemandedVecElts, Q, Depth));
3005 return isKnownNonZero(Vec, DemandedVecElts, Q, Depth);
3020 isKnownNonZero(Shuf->getOperand(1), DemandedRHS, Q, Depth)) &&
3022 isKnownNonZero(Shuf->getOperand(0), DemandedLHS, Q, Depth));
3025 return isKnownNonZero(I->getOperand(0), Q, Depth) &&
3027 Depth);
3052 return isNonZeroAdd(DemandedElts, Depth, Q, BitWidth,
3057 return isNonZeroSub(DemandedElts, Depth, Q, BitWidth,
3060 return isNonZeroMul(DemandedElts, Depth, Q, BitWidth,
3075 return isKnownNonZero(RP, Q, Depth);
3085 if (RV->getType() == I->getType() && isKnownNonZero(RV, Q, Depth))
3097 return isKnownNonZero(II->getArgOperand(0), DemandedElts, Q, Depth);
3101 return isNonZeroSub(DemandedElts, Depth, Q, BitWidth,
3104 return isNonZeroAdd(DemandedElts, Depth, Q, BitWidth,
3110 Q, Depth);
3117 return isKnownNonZero(II->getArgOperand(0), Q, Depth);
3125 return isKnownNonZero(II->getArgOperand(1), DemandedElts, Q, Depth) ||
3126 isKnownNonZero(II->getArgOperand(0), DemandedElts, Q, Depth);
3134 isKnownNonZero(Op, DemandedElts, Q, Depth);
3140 computeKnownBits(II->getArgOperand(1), DemandedElts, Depth, Q);
3145 computeKnownBits(II->getArgOperand(0), DemandedElts, Depth, Q);
3156 computeKnownBits(II->getArgOperand(1), DemandedElts, Depth, Q);
3160 computeKnownBits(II->getArgOperand(0), DemandedElts, Depth, Q);
3169 return isKnownNonZero(II->getArgOperand(0), DemandedElts, Q, Depth) &&
3170 isKnownNonZero(II->getArgOperand(1), DemandedElts, Q, Depth);
3172 return computeKnownBits(II->getArgOperand(0), DemandedElts, Depth, Q)
3175 return computeKnownBits(II->getArgOperand(0), DemandedElts, Depth, Q)
3181 return isKnownNonZero(II->getArgOperand(0), DemandedElts, Q, Depth);
3186 return isKnownNonZero(I->getOperand(0), Q, Depth);
3198 computeKnownBits(I, DemandedElts, Known, Depth, Q);
3209 const SimplifyQuery &Q, unsigned Depth) {
3213 assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
3249 return isKnownNonZero(CPA->getPointer(), DemandedElts, Q, Depth);
3276 if (Depth++ >= MaxAnalysisRecursionDepth)
3293 if (isKnownNonZeroFromOperator(I, DemandedElts, Depth, Q))
3304 unsigned Depth) {
3308 return ::isKnownNonZero(V, DemandedElts, Q, Depth);
3435 const APInt &DemandedElts, unsigned Depth,
3456 return isKnownNonZero(Op, DemandedElts, Q, Depth + 1);
3464 const APInt &DemandedElts, unsigned Depth,
3471 isKnownNonZero(V1, DemandedElts, Q, Depth + 1);
3479 const APInt &DemandedElts, unsigned Depth,
3485 !C->isZero() && isKnownNonZero(V1, DemandedElts, Q, Depth + 1);
3491 const APInt &DemandedElts, unsigned Depth,
3514 if (!isKnownNonEqual(IV1, IV2, DemandedElts, Depth + 1, RecQ))
3522 const APInt &DemandedElts, unsigned Depth,
3533 DemandedElts, Depth + 1, Q) &&
3535 DemandedElts, Depth + 1, Q);
3537 return isKnownNonEqual(SI1->getTrueValue(), V2, DemandedElts, Depth + 1, Q) &&
3538 isKnownNonEqual(SI1->getFalseValue(), V2, DemandedElts, Depth + 1, Q);
3595 const APInt &DemandedElts, unsigned Depth,
3603 if (Depth >= MaxAnalysisRecursionDepth)
3614 Depth + 1, Q);
3620 if (isNonEqualPHIs(PN1, PN2, DemandedElts, Depth, Q))
3625 if (isModifyingBinopOfNonZero(V1, V2, DemandedElts, Depth, Q) ||
3626 isModifyingBinopOfNonZero(V2, V1, DemandedElts, Depth, Q))
3629 if (isNonEqualMul(V1, V2, DemandedElts, Depth, Q) ||
3630 isNonEqualMul(V2, V1, DemandedElts, Depth, Q))
3633 if (isNonEqualShl(V1, V2, DemandedElts, Depth, Q) ||
3634 isNonEqualShl(V2, V1, DemandedElts, Depth, Q))
3640 KnownBits Known1 = computeKnownBits(V1, DemandedElts, Depth, Q);
3642 KnownBits Known2 = computeKnownBits(V2, DemandedElts, Depth, Q);
3649 if (isNonEqualSelect(V1, V2, DemandedElts, Depth, Q) ||
3650 isNonEqualSelect(V2, V1, DemandedElts, Depth, Q))
3662 return isKnownNonEqual(A, B, DemandedElts, Depth + 1, Q);
3745 unsigned Depth, const SimplifyQuery &Q);
3748 unsigned Depth, const SimplifyQuery &Q) {
3749 unsigned Result = ComputeNumSignBitsImpl(V, DemandedElts, Depth, Q);
3763 unsigned Depth, const SimplifyQuery &Q) {
3766 assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
3793 if (Depth == MaxAnalysisRecursionDepth)
3801 return ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q) +
3815 ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
3824 Tmp = ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
3855 Tmp = ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
3878 Tmp = ComputeNumSignBits(X, DemandedElts, Depth + 1, Q);
3882 ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
3894 Tmp = ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
3896 Tmp2 = ComputeNumSignBits(U->getOperand(1), DemandedElts, Depth + 1, Q);
3912 Tmp = ComputeNumSignBits(U->getOperand(1), DemandedElts, Depth + 1, Q);
3915 Tmp2 = ComputeNumSignBits(U->getOperand(2), DemandedElts, Depth + 1, Q);
3922 Tmp = ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
3929 computeKnownBits(U->getOperand(0), DemandedElts, Known, Depth + 1, Q);
3942 Tmp2 = ComputeNumSignBits(U->getOperand(1), DemandedElts, Depth + 1, Q);
3948 Tmp2 = ComputeNumSignBits(U->getOperand(1), DemandedElts, Depth + 1, Q);
3956 computeKnownBits(U->getOperand(1), DemandedElts, Known, Depth + 1, Q);
3973 Tmp = ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
3982 ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
3986 ComputeNumSignBits(U->getOperand(1), DemandedElts, Depth + 1, Q);
4010 DemandedElts, Depth + 1, RecQ));
4019 Tmp = ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
4032 return ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
4050 Tmp = ComputeNumSignBits(LHS, DemandedLHS, Depth + 1, Q);
4058 Tmp2 = ComputeNumSignBits(RHS, DemandedRHS, Depth + 1, Q);
4075 ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
4103 computeKnownBits(V, DemandedElts, Known, Depth, Q);
4846 unsigned Depth, const SimplifyQuery &Q);
4849 FPClassTest InterestedClasses, unsigned Depth,
4854 computeKnownFPClass(V, DemandedElts, InterestedClasses, Known, Depth, Q);
4860 KnownFPClass &Known, unsigned Depth,
4868 KnownSrc, Depth + 1, Q);
4882 unsigned Depth, const SimplifyQuery &Q) {
4891 assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
4985 if (Depth == MaxAnalysisRecursionDepth)
4992 Known, Depth + 1, Q);
5038 Depth + 1, Q);
5042 Known2, Depth + 1, Q);
5057 InterestedClasses, Known, Depth + 1, Q);
5067 Known, Depth + 1, Q);
5069 KnownSign, Depth + 1, Q);
5087 KnownAddend, Depth + 1, Q);
5101 KnownSrc, Depth + 1, Q);
5129 KnownSrc, Depth + 1, Q);
5141 KnownLHS, Depth + 1, Q);
5143 KnownRHS, Depth + 1, Q);
5226 KnownSrc, Depth + 1, Q);
5277 InterestedClasses, Depth + 1, Q);
5287 II->getFastMathFlags(), InterestedClasses, Depth + 1, Q);
5303 KnownSrc, Depth + 1, Q);
5336 KnownSrc, Depth + 1, Q);
5346 Depth, Q);
5370 KnownSrc, Depth + 1, Q);
5393 ExponentKnownBits, Depth + 1, Q);
5410 KnownSrc, Depth + 1, Q);
5418 KnownSrc, Depth + 1, Q);
5444 ExpArg, true, Q.IIQ.UseInstrInfo, Q.AC, Q.CxtI, Q.DT, Depth + 1);
5477 Known, Depth + 1, Q);
5520 KnownRHS, Depth + 1, Q);
5529 KnownLHS, Depth + 1, Q);
5580 Depth + 1, Q);
5585 Depth + 1, Q);
5640 Depth + 1, Q);
5652 Depth + 1, Q);
5697 Known, Depth + 1, Q);
5720 Depth, Q);
5766 Depth + 1, Q);
5789 computeKnownFPClass(Elt, Known, InterestedClasses, Depth + 1, Q);
5801 Depth + 1, Q);
5818 Depth + 1, Q);
5831 Depth + 1, Q);
5850 InterestedClasses, KnownSrc, Depth + 1, Q);
5881 computeKnownFPClass(Src, DemandedElts, InterestedClasses, Known, Depth + 1,
5895 if (Depth < PhiRecursionLimit) {
5939 unsigned Depth,
5942 ::computeKnownFPClass(V, DemandedElts, InterestedClasses, KnownClasses, Depth,
5949 unsigned Depth,
5952 ::computeKnownFPClass(V, Known, InterestedClasses, Depth, SQ);
6973 KnownBits LHSKnown = computeKnownBits(LHS, /*Depth=*/0, SQ);
6974 KnownBits RHSKnown = computeKnownBits(RHS, /*Depth=*/0, SQ);
7016 KnownBits LHSKnown = computeKnownBits(LHS, /*Depth=*/0, SQ);
7017 KnownBits RHSKnown = computeKnownBits(RHS, /*Depth=*/0, SQ);
7085 computeKnownBitsFromContext(Add, AddKnown, /*Depth=*/0, SQ);
7414 unsigned Depth) {
7419 if (Depth >= MaxDepth)
7425 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
7442 unsigned Depth) {
7446 if (directlyImpliesPoison(ValAssumedPoison, V, /* Depth */ 0))
7450 if (Depth >= MaxDepth)
7456 return impliesPoison(Op, V, Depth + 1);
7463 return ::impliesPoison(ValAssumedPoison, V, /* Depth */ 0);
7470 const DominatorTree *DT, unsigned Depth, UndefPoisonKind Kind) {
7471 if (Depth >= MaxAnalysisRecursionDepth)
7518 return isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth + 1, Kind);
7540 DT, Depth + 1, Kind)) {
7616 unsigned Depth) {
7617 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth,
7623 const DominatorTree *DT, unsigned Depth) {
7624 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth,
7630 const DominatorTree *DT, unsigned Depth) {
7631 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth,
8172 unsigned Depth) {
8177 SelectPatternResult L = matchSelectPattern(TVal, A, B, nullptr, Depth + 1);
8182 SelectPatternResult R = matchSelectPattern(FVal, C, D, nullptr, Depth + 1);
8282 unsigned Depth) {
8291 SPR = matchMinMaxOfMinMax(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, Depth);
8405 unsigned Depth) {
8579 return matchMinMax(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS, RHS, Depth);
8703 unsigned Depth) {
8704 if (Depth >= MaxAnalysisRecursionDepth)
8717 CastOp, Depth);
8722 Instruction::CastOps *CastOp, unsigned Depth) {
8743 LHS, RHS, Depth);
8752 LHS, RHS, Depth);
8756 LHS, RHS, Depth);
9146 const DataLayout &DL, bool LHSIsTrue, unsigned Depth) {
9153 assert(Depth <= MaxAnalysisRecursionDepth && "Hit recursion limit");
9163 ALHS, RHSPred, RHSOp0, RHSOp1, DL, LHSIsTrue, Depth + 1))
9166 ARHS, RHSPred, RHSOp0, RHSOp1, DL, LHSIsTrue, Depth + 1))
9176 const DataLayout &DL, bool LHSIsTrue, unsigned Depth) {
9178 if (Depth == MaxAnalysisRecursionDepth)
9206 Depth);
9213 bool LHSIsTrue, unsigned Depth) {
9229 RHSCmp->getOperand(1), DL, LHSIsTrue, Depth))
9234 if (Depth == MaxAnalysisRecursionDepth)
9242 isImpliedCondition(LHS, RHS1, DL, LHSIsTrue, Depth + 1))
9246 isImpliedCondition(LHS, RHS2, DL, LHSIsTrue, Depth + 1))
9252 isImpliedCondition(LHS, RHS1, DL, LHSIsTrue, Depth + 1))
9256 isImpliedCondition(LHS, RHS2, DL, LHSIsTrue, Depth + 1))
9690 unsigned Depth) {
9693 if (Depth == MaxAnalysisRecursionDepth)
9712 SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT, Depth + 1);
9714 SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT, Depth + 1);
9757 UseInstrInfo, AC, I, DT, Depth + 1);