Lines Matching defs:Depth
150 KnownBits &Known, unsigned Depth,
153 void llvm::computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth,
161 ::computeKnownBits(V, DemandedElts, Known, Depth, Q);
165 const DataLayout &DL, unsigned Depth,
169 V, Known, Depth,
174 unsigned Depth, AssumptionCache *AC,
178 V, Depth, SimplifyQuery(DL, DT, AC, safeCxtI(V, CxtI), UseInstrInfo));
182 const DataLayout &DL, unsigned Depth,
186 V, DemandedElts, Depth,
281 bool OrZero, unsigned Depth,
285 V, OrZero, Depth,
290 const SimplifyQuery &Q, unsigned Depth);
293 unsigned Depth) {
294 return computeKnownBits(V, Depth, SQ).isNonNegative();
298 unsigned Depth) {
304 KnownBits Known = computeKnownBits(V, Depth, SQ);
306 (Known.isNonZero() || isKnownNonZero(V, SQ, Depth));
310 unsigned Depth) {
311 return computeKnownBits(V, Depth, SQ).isNegative();
315 const APInt &DemandedElts, unsigned Depth,
334 const SimplifyQuery &SQ, unsigned Depth) {
336 computeKnownBits(V, Known, Depth, SQ);
341 unsigned Depth, const SimplifyQuery &Q);
343 static unsigned ComputeNumSignBits(const Value *V, unsigned Depth,
348 return ComputeNumSignBits(V, DemandedElts, Depth, Q);
352 unsigned Depth, AssumptionCache *AC,
356 V, Depth, SimplifyQuery(DL, DT, AC, safeCxtI(V, CxtI), UseInstrInfo));
360 unsigned Depth, AssumptionCache *AC,
363 unsigned SignBits = ComputeNumSignBits(V, DL, Depth, AC, CxtI, DT);
371 unsigned Depth, const SimplifyQuery &Q) {
372 computeKnownBits(Op1, DemandedElts, KnownOut, Depth + 1, Q);
379 computeKnownBits(Op0, DemandedElts, Known2, Depth + 1, Q);
386 unsigned Depth, const SimplifyQuery &Q) {
387 computeKnownBits(Op1, DemandedElts, Known, Depth + 1, Q);
388 computeKnownBits(Op0, DemandedElts, Known2, Depth + 1, Q);
425 isGuaranteedNotToBeUndef(Op0, Q.AC, Q.CxtI, Q.DT, Depth + 1);
809 KnownBits &Known, unsigned Depth,
812 if (Depth < MaxAnalysisRecursionDepth &&
816 computeKnownBitsFromCond(V, A, Known2, Depth + 1, SQ, Invert);
817 computeKnownBitsFromCond(V, B, Known3, Depth + 1, SQ, Invert);
831 unsigned Depth, const SimplifyQuery &Q) {
834 computeKnownBitsFromCond(V, Q.CC->Cond, Known, Depth, Q, Q.CC->Invert);
844 computeKnownBitsFromCond(V, BI->getCondition(), Known, Depth, Q,
849 computeKnownBitsFromCond(V, BI->getCondition(), Known, Depth, Q,
910 if (Depth == MaxAnalysisRecursionDepth)
939 KnownBits &Known2, unsigned Depth, const SimplifyQuery &Q,
941 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
942 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
948 isKnownNonZero(I->getOperand(1), DemandedElts, Q, Depth + 1));
955 unsigned Depth, const SimplifyQuery &Q) {
1012 computeKnownBits(Y, DemandedElts, KnownY, Depth + 1, Q);
1024 const Operator *I, const APInt &DemandedElts, unsigned Depth,
1034 [Depth, &Q, KnownBitsFunc](const Value *Op, APInt &DemandedEltsOp) {
1036 computeKnownBits(Op, DemandedEltsOp, Depth + 1, Q),
1037 computeKnownBits(Op, DemandedEltsOp << 1, Depth + 1, Q));
1053 unsigned Depth,
1059 return getKnownBitsFromAndXorOr(I, DemandedElts, KnownLHS, KnownRHS, Depth,
1083 Value *Arm, bool Invert, unsigned Depth,
1091 computeKnownBitsFromCond(Arm, Cond, CondRes, Depth + 1, Q, Invert);
1108 if (!isGuaranteedNotToBeUndef(Arm, Q.AC, Q.CxtI, Q.DT, Depth + 1))
1176 KnownBits &Known, unsigned Depth,
1189 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1190 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1192 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1195 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1196 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1198 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1201 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1202 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1204 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1210 DemandedElts, Known, Known2, Depth, Q);
1214 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1215 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1221 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1222 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1230 computeKnownBits(Arm, DemandedElts, Res, Depth + 1, Q);
1231 adjustKnownBitsForSelectArm(Res, I->getOperand(0), Arm, Invert, Depth, Q);
1265 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1278 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1288 computeKnownFPClass(V, DemandedElts, fcAllFlags, Depth + 1, Q);
1357 Depth + 1, Q);
1369 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1382 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1396 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1410 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1418 DemandedElts, Known, Known2, Depth, Q);
1425 DemandedElts, Known, Known2, Depth, Q);
1429 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1430 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1435 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1436 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1445 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1488 computeKnownBits(Index, IndexBits, Depth + 1, Q);
1562 computeKnownBits(R, DemandedElts, Known2, Depth + 1, RecQ);
1605 computeKnownBits(R, DemandedElts, Known2, Depth + 1, RecQ);
1610 computeKnownBits(L, DemandedElts, Known3, Depth + 1, RecQ);
1672 if (Depth < MaxAnalysisRecursionDepth - 1 && Known.isUnknown()) {
1761 computeKnownBits(RV, Known2, Depth + 1, Q);
1776 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1782 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1787 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1792 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1803 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1814 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1836 computeKnownBits(I->getOperand(0), DemandedElts, Known2, Depth + 1, Q);
1837 computeKnownBits(I->getOperand(1), DemandedElts, Known3, Depth + 1, Q);
1846 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1847 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1851 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1852 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1856 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1857 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1861 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1862 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1868 Depth + 1, Q);
1878 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1881 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1896 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1897 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1901 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1902 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1906 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1907 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1912 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1913 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1918 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1922 computeKnownBits(Mask, DemandedElts, Known2, Depth + 1, Q);
1930 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1931 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1937 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1938 computeKnownBits(I->getOperand(1), DemandedElts, Known2, Depth + 1, Q);
1949 I, DemandedElts, Depth, Q,
1957 Known = computeKnownBitsForHorizontalOperation(I, DemandedElts, Depth,
1966 I, DemandedElts, Depth, Q,
1974 Known = computeKnownBitsForHorizontalOperation(I, DemandedElts, Depth,
2029 computeKnownBits(LHS, DemandedLHS, Known, Depth + 1, Q);
2036 computeKnownBits(RHS, DemandedRHS, Known2, Depth + 1, Q);
2061 computeKnownBits(Elt, Known, Depth + 1, Q);
2068 computeKnownBits(Vec, DemandedVecElts, Known2, Depth + 1, Q);
2088 computeKnownBits(Vec, DemandedVecElts, Known, Depth + 1, Q);
2102 /* NUW=*/false, DemandedElts, Known, Known2, Depth, Q);
2108 /* NUW=*/false, DemandedElts, Known, Known2, Depth, Q);
2113 false, DemandedElts, Known, Known2, Depth, Q);
2121 Depth + 1))
2122 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
2130 unsigned Depth, const SimplifyQuery &Q) {
2132 ::computeKnownBits(V, DemandedElts, Known, Depth, Q);
2138 KnownBits llvm::computeKnownBits(const Value *V, unsigned Depth,
2141 computeKnownBits(V, Known, Depth, Q);
2161 KnownBits &Known, unsigned Depth,
2170 assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
2269 if (Depth == MaxAnalysisRecursionDepth)
2276 computeKnownBits(GA->getAliasee(), Known, Depth + 1, Q);
2281 computeKnownBitsFromOperator(I, DemandedElts, Known, Depth, Q);
2297 computeKnownBitsFromContext(V, Known, Depth, Q);
2303 unsigned Depth, SimplifyQuery &Q) {
2315 if (!isKnownToBeAPowerOfTwo(Start, OrZero, Depth, Q))
2331 isKnownToBeAPowerOfTwo(Step, OrZero, Depth, Q);
2343 isKnownToBeAPowerOfTwo(Step, false, Depth, Q);
2380 bool llvm::isKnownToBeAPowerOfTwo(const Value *V, bool OrZero, unsigned Depth,
2382 assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
2444 if (Depth++ == MaxAnalysisRecursionDepth)
2449 return isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q);
2451 return OrZero && isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q);
2454 return isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q);
2458 return isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q);
2462 return isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q);
2465 return isKnownToBeAPowerOfTwo(I->getOperand(1), OrZero, Depth, Q) &&
2466 isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q) &&
2467 (OrZero || isKnownNonZero(I, Q, Depth));
2471 (isKnownToBeAPowerOfTwo(I->getOperand(1), /*OrZero*/ true, Depth, Q) ||
2472 isKnownToBeAPowerOfTwo(I->getOperand(0), /*OrZero*/ true, Depth, Q)))
2477 return OrZero || isKnownNonZero(I->getOperand(0), Q, Depth);
2487 isKnownToBeAPowerOfTwo(I->getOperand(1), OrZero, Depth, Q))
2491 isKnownToBeAPowerOfTwo(I->getOperand(0), OrZero, Depth, Q))
2496 computeKnownBits(I->getOperand(0), LHSBits, Depth, Q);
2499 computeKnownBits(I->getOperand(1), RHSBits, Depth, Q);
2517 return isKnownToBeAPowerOfTwo(I->getOperand(1), OrZero, Depth, Q) &&
2518 isKnownToBeAPowerOfTwo(I->getOperand(2), OrZero, Depth, Q);
2527 if (isPowerOfTwoRecurrence(PN, OrZero, Depth, RecQ))
2532 unsigned NewDepth = std::max(Depth, MaxAnalysisRecursionDepth - 1);
2552 return isKnownToBeAPowerOfTwo(II->getArgOperand(1), OrZero, Depth, Q) &&
2553 isKnownToBeAPowerOfTwo(II->getArgOperand(0), OrZero, Depth, Q);
2558 return isKnownToBeAPowerOfTwo(II->getArgOperand(0), OrZero, Depth, Q);
2563 return isKnownToBeAPowerOfTwo(II->getArgOperand(0), OrZero, Depth, Q);
2582 static bool isGEPKnownNonNull(const GEPOperator *GEP, unsigned Depth,
2600 if (isKnownNonZero(GEP->getPointerOperand(), Q, Depth))
2624 // increment Depth when just zipping down an all-constant GEP.
2631 // We post-increment Depth here because while isKnownNonZero increments it
2636 if (Depth++ >= MaxAnalysisRecursionDepth)
2639 if (isKnownNonZero(GTI.getOperand(), Q, Depth))
2797 static bool isNonZeroAdd(const APInt &DemandedElts, unsigned Depth,
2805 return isKnownNonZero(Y, DemandedElts, Q, Depth) ||
2806 isKnownNonZero(X, DemandedElts, Q, Depth);
2808 KnownBits XKnown = computeKnownBits(X, DemandedElts, Depth, Q);
2809 KnownBits YKnown = computeKnownBits(Y, DemandedElts, Depth, Q);
2814 if (isKnownNonZero(Y, DemandedElts, Q, Depth) ||
2815 isKnownNonZero(X, DemandedElts, Q, Depth))
2834 isKnownToBeAPowerOfTwo(Y, /*OrZero*/ false, Depth, Q))
2837 isKnownToBeAPowerOfTwo(X, /*OrZero*/ false, Depth, Q))
2843 static bool isNonZeroSub(const APInt &DemandedElts, unsigned Depth,
2853 if (C->isNullValue() && isKnownNonZero(Y, DemandedElts, Q, Depth))
2856 return ::isKnownNonEqual(X, Y, DemandedElts, Depth, Q);
2859 static bool isNonZeroMul(const APInt &DemandedElts, unsigned Depth,
2865 return isKnownNonZero(X, DemandedElts, Q, Depth) &&
2866 isKnownNonZero(Y, DemandedElts, Q, Depth);
2870 KnownBits XKnown = computeKnownBits(X, DemandedElts, Depth, Q);
2872 return isKnownNonZero(Y, DemandedElts, Q, Depth);
2874 KnownBits YKnown = computeKnownBits(Y, DemandedElts, Depth, Q);
2876 return XKnown.isNonZero() || isKnownNonZero(X, DemandedElts, Q, Depth);
2888 unsigned Depth, const SimplifyQuery &Q,
2919 computeKnownBits(I->getOperand(1), DemandedElts, Depth, Q);
2932 isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth))
2940 unsigned Depth, const SimplifyQuery &Q) {
2948 return isGEPKnownNonNull(cast<GEPOperator>(I), Depth, Q);
2981 return isKnownNonZero(I->getOperand(0), Q, Depth);
2990 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
2998 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
3004 return isKnownNonZero(TI->getOperand(0), DemandedElts, Q, Depth);
3008 return isNonZeroSub(DemandedElts, Depth, Q, BitWidth, I->getOperand(0),
3020 return isKnownNonZero(I->getOperand(1), DemandedElts, Q, Depth) ||
3021 isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
3025 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
3031 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
3036 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth, Q);
3040 return isNonZeroShift(I, DemandedElts, Depth, Q, Known);
3047 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
3052 computeKnownBits(I->getOperand(0), DemandedElts, Depth, Q);
3056 return isNonZeroShift(I, DemandedElts, Depth, Q, Known);
3063 return isKnownNonZero(I->getOperand(0), DemandedElts, Q, Depth);
3066 computeKnownBits(I->getOperand(0), DemandedElts, Depth, Q);
3073 computeKnownBits(I->getOperand(1), DemandedElts, Depth, Q);
3091 return isNonZeroAdd(DemandedElts, Depth, Q, BitWidth, I->getOperand(0),
3097 return isNonZeroMul(DemandedElts, Depth, Q, BitWidth, I->getOperand(0),
3112 if (isKnownNonZero(Op, DemandedElts, Q, Depth))
3140 unsigned NewDepth = std::max(Depth, MaxAnalysisRecursionDepth - 1);
3184 return (SkipElt || isKnownNonZero(Elt, Q, Depth)) &&
3186 isKnownNonZero(Vec, DemandedVecElts, Q, Depth));
3198 return isKnownNonZero(Vec, DemandedVecElts, Q, Depth);
3213 isKnownNonZero(Shuf->getOperand(1), DemandedRHS, Q, Depth)) &&
3215 isKnownNonZero(Shuf->getOperand(0), DemandedLHS, Q, Depth));
3218 return isKnownNonZero(I->getOperand(0), Q, Depth) &&
3220 Depth);
3245 return isNonZeroAdd(DemandedElts, Depth, Q, BitWidth,
3250 return isNonZeroSub(DemandedElts, Depth, Q, BitWidth,
3253 return isNonZeroMul(DemandedElts, Depth, Q, BitWidth,
3268 return isKnownNonZero(RP, Q, Depth);
3278 if (RV->getType() == I->getType() && isKnownNonZero(RV, Q, Depth))
3290 return isKnownNonZero(II->getArgOperand(0), DemandedElts, Q, Depth);
3294 return isNonZeroSub(DemandedElts, Depth, Q, BitWidth,
3297 return isNonZeroAdd(DemandedElts, Depth, Q, BitWidth,
3303 Q, Depth);
3310 return isKnownNonZero(II->getArgOperand(0), Q, Depth);
3318 return isKnownNonZero(II->getArgOperand(1), DemandedElts, Q, Depth) ||
3319 isKnownNonZero(II->getArgOperand(0), DemandedElts, Q, Depth);
3327 isKnownNonZero(Op, DemandedElts, Q, Depth);
3333 computeKnownBits(II->getArgOperand(1), DemandedElts, Depth, Q);
3338 computeKnownBits(II->getArgOperand(0), DemandedElts, Depth, Q);
3349 computeKnownBits(II->getArgOperand(1), DemandedElts, Depth, Q);
3353 computeKnownBits(II->getArgOperand(0), DemandedElts, Depth, Q);
3362 return isKnownNonZero(II->getArgOperand(0), DemandedElts, Q, Depth) &&
3363 isKnownNonZero(II->getArgOperand(1), DemandedElts, Q, Depth);
3365 return computeKnownBits(II->getArgOperand(0), DemandedElts, Depth, Q)
3368 return computeKnownBits(II->getArgOperand(0), DemandedElts, Depth, Q)
3374 return isKnownNonZero(II->getArgOperand(0), DemandedElts, Q, Depth);
3379 return isKnownNonZero(I->getOperand(0), Q, Depth);
3391 computeKnownBits(I, DemandedElts, Known, Depth, Q);
3402 const SimplifyQuery &Q, unsigned Depth) {
3406 assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
3442 return isKnownNonZero(CPA->getPointer(), DemandedElts, Q, Depth);
3469 if (Depth++ >= MaxAnalysisRecursionDepth)
3486 if (isKnownNonZeroFromOperator(I, DemandedElts, Depth, Q))
3497 unsigned Depth) {
3501 return ::isKnownNonZero(V, DemandedElts, Q, Depth);
3628 const APInt &DemandedElts, unsigned Depth,
3649 return isKnownNonZero(Op, DemandedElts, Q, Depth + 1);
3657 const APInt &DemandedElts, unsigned Depth,
3664 isKnownNonZero(V1, DemandedElts, Q, Depth + 1);
3672 const APInt &DemandedElts, unsigned Depth,
3678 !C->isZero() && isKnownNonZero(V1, DemandedElts, Q, Depth + 1);
3684 const APInt &DemandedElts, unsigned Depth,
3707 if (!isKnownNonEqual(IV1, IV2, DemandedElts, Depth + 1, RecQ))
3715 const APInt &DemandedElts, unsigned Depth,
3726 DemandedElts, Depth + 1, Q) &&
3728 DemandedElts, Depth + 1, Q);
3730 return isKnownNonEqual(SI1->getTrueValue(), V2, DemandedElts, Depth + 1, Q) &&
3731 isKnownNonEqual(SI1->getFalseValue(), V2, DemandedElts, Depth + 1, Q);
3788 const APInt &DemandedElts, unsigned Depth,
3796 if (Depth >= MaxAnalysisRecursionDepth)
3807 Depth + 1, Q);
3813 if (isNonEqualPHIs(PN1, PN2, DemandedElts, Depth, Q))
3818 if (isModifyingBinopOfNonZero(V1, V2, DemandedElts, Depth, Q) ||
3819 isModifyingBinopOfNonZero(V2, V1, DemandedElts, Depth, Q))
3822 if (isNonEqualMul(V1, V2, DemandedElts, Depth, Q) ||
3823 isNonEqualMul(V2, V1, DemandedElts, Depth, Q))
3826 if (isNonEqualShl(V1, V2, DemandedElts, Depth, Q) ||
3827 isNonEqualShl(V2, V1, DemandedElts, Depth, Q))
3833 KnownBits Known1 = computeKnownBits(V1, DemandedElts, Depth, Q);
3835 KnownBits Known2 = computeKnownBits(V2, DemandedElts, Depth, Q);
3842 if (isNonEqualSelect(V1, V2, DemandedElts, Depth, Q) ||
3843 isNonEqualSelect(V2, V1, DemandedElts, Depth, Q))
3855 return isKnownNonEqual(A, B, DemandedElts, Depth + 1, Q);
3889 unsigned Depth, const SimplifyQuery &Q);
3892 unsigned Depth, const SimplifyQuery &Q) {
3893 unsigned Result = ComputeNumSignBitsImpl(V, DemandedElts, Depth, Q);
3907 unsigned Depth, const SimplifyQuery &Q) {
3910 assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
3937 if (Depth == MaxAnalysisRecursionDepth)
3945 return ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q) +
3959 ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
3968 Tmp = ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
3999 Tmp = ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
4022 Tmp = ComputeNumSignBits(X, DemandedElts, Depth + 1, Q);
4026 ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
4038 Tmp = ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
4040 Tmp2 = ComputeNumSignBits(U->getOperand(1), DemandedElts, Depth + 1, Q);
4056 Tmp = ComputeNumSignBits(U->getOperand(1), DemandedElts, Depth + 1, Q);
4059 Tmp2 = ComputeNumSignBits(U->getOperand(2), DemandedElts, Depth + 1, Q);
4066 Tmp = ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
4073 computeKnownBits(U->getOperand(0), DemandedElts, Known, Depth + 1, Q);
4086 Tmp2 = ComputeNumSignBits(U->getOperand(1), DemandedElts, Depth + 1, Q);
4092 Tmp2 = ComputeNumSignBits(U->getOperand(1), DemandedElts, Depth + 1, Q);
4100 computeKnownBits(U->getOperand(1), DemandedElts, Known, Depth + 1, Q);
4117 Tmp = ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
4126 ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
4130 ComputeNumSignBits(U->getOperand(1), DemandedElts, Depth + 1, Q);
4154 DemandedElts, Depth + 1, RecQ));
4163 Tmp = ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
4176 return ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
4194 Tmp = ComputeNumSignBits(LHS, DemandedLHS, Depth + 1, Q);
4202 Tmp2 = ComputeNumSignBits(RHS, DemandedRHS, Depth + 1, Q);
4219 ComputeNumSignBits(U->getOperand(0), DemandedElts, Depth + 1, Q);
4247 computeKnownBits(V, DemandedElts, Known, Depth, Q);
4942 unsigned Depth, bool CondIsTrue,
4946 if (Depth < MaxAnalysisRecursionDepth &&
4949 computeKnownFPClassFromCond(V, A, Depth + 1, CondIsTrue, CxtI,
4951 computeKnownFPClassFromCond(V, B, Depth + 1, CondIsTrue, CxtI,
4995 computeKnownFPClassFromCond(V, Cond, /*Depth=*/0, /*CondIsTrue=*/true,
5000 computeKnownFPClassFromCond(V, Cond, /*Depth=*/0, /*CondIsTrue=*/false,
5023 computeKnownFPClassFromCond(V, I->getArgOperand(0), /*Depth=*/0,
5032 unsigned Depth, const SimplifyQuery &Q);
5035 FPClassTest InterestedClasses, unsigned Depth,
5040 computeKnownFPClass(V, DemandedElts, InterestedClasses, Known, Depth, Q);
5046 KnownFPClass &Known, unsigned Depth,
5054 KnownSrc, Depth + 1, Q);
5068 unsigned Depth, const SimplifyQuery &Q) {
5077 assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
5171 if (Depth == MaxAnalysisRecursionDepth)
5178 Known, Depth + 1, Q);
5224 Depth + 1, Q);
5228 Known2, Depth + 1, Q);
5243 InterestedClasses, Known, Depth + 1, Q);
5253 Known, Depth + 1, Q);
5255 KnownSign, Depth + 1, Q);
5273 KnownAddend, Depth + 1, Q);
5287 KnownSrc, Depth + 1, Q);
5315 KnownSrc, Depth + 1, Q);
5327 KnownLHS, Depth + 1, Q);
5329 KnownRHS, Depth + 1, Q);
5412 KnownSrc, Depth + 1, Q);
5463 InterestedClasses, Depth + 1, Q);
5473 II->getFastMathFlags(), InterestedClasses, Depth + 1, Q);
5489 KnownSrc, Depth + 1, Q);
5522 KnownSrc, Depth + 1, Q);
5532 Depth, Q);
5556 KnownSrc, Depth + 1, Q);
5579 ExponentKnownBits, Depth + 1, Q);
5596 KnownSrc, Depth + 1, Q);
5604 KnownSrc, Depth + 1, Q);
5630 ExpArg, true, Q.IIQ.UseInstrInfo, Q.AC, Q.CxtI, Q.DT, Depth + 1);
5663 Known, Depth + 1, Q);
5706 KnownRHS, Depth + 1, Q);
5715 KnownLHS, Depth + 1, Q);
5766 Depth + 1, Q);
5771 Depth + 1, Q);
5826 Depth + 1, Q);
5838 Depth + 1, Q);
5883 Known, Depth + 1, Q);
5906 Depth, Q);
5952 Depth + 1, Q);
5975 computeKnownFPClass(Elt, Known, InterestedClasses, Depth + 1, Q);
5987 Depth + 1, Q);
6004 Depth + 1, Q);
6017 Depth + 1, Q);
6036 InterestedClasses, KnownSrc, Depth + 1, Q);
6067 computeKnownFPClass(Src, DemandedElts, InterestedClasses, Known, Depth + 1,
6081 if (Depth < PhiRecursionLimit) {
6126 computeKnownBits(Src, DemandedElts, Bits, Depth + 1, Q);
6181 unsigned Depth,
6184 ::computeKnownFPClass(V, DemandedElts, InterestedClasses, KnownClasses, Depth,
6191 unsigned Depth,
6194 ::computeKnownFPClass(V, Known, InterestedClasses, Depth, SQ);
7213 KnownBits LHSKnown = computeKnownBits(LHS, /*Depth=*/0, SQ);
7214 KnownBits RHSKnown = computeKnownBits(RHS, /*Depth=*/0, SQ);
7256 KnownBits LHSKnown = computeKnownBits(LHS, /*Depth=*/0, SQ);
7257 KnownBits RHSKnown = computeKnownBits(RHS, /*Depth=*/0, SQ);
7325 computeKnownBitsFromContext(Add, AddKnown, /*Depth=*/0, SQ);
7651 unsigned Depth) {
7656 if (Depth >= MaxDepth)
7662 directlyImpliesPoison(ValAssumedPoison, Op, Depth + 1);
7679 unsigned Depth) {
7683 if (directlyImpliesPoison(ValAssumedPoison, V, /* Depth */ 0))
7687 if (Depth >= MaxDepth)
7693 return impliesPoison(Op, V, Depth + 1);
7700 return ::impliesPoison(ValAssumedPoison, V, /* Depth */ 0);
7707 const DominatorTree *DT, unsigned Depth, UndefPoisonKind Kind) {
7708 if (Depth >= MaxAnalysisRecursionDepth)
7755 return isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth + 1, Kind);
7777 DT, Depth + 1, Kind)) {
7853 unsigned Depth) {
7854 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth,
7860 const DominatorTree *DT, unsigned Depth) {
7861 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth,
7867 const DominatorTree *DT, unsigned Depth) {
7868 return ::isGuaranteedNotToBeUndefOrPoison(V, AC, CtxI, DT, Depth,
8405 unsigned Depth) {
8410 SelectPatternResult L = matchSelectPattern(TVal, A, B, nullptr, Depth + 1);
8415 SelectPatternResult R = matchSelectPattern(FVal, C, D, nullptr, Depth + 1);
8515 unsigned Depth) {
8524 SPR = matchMinMaxOfMinMax(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, Depth);
8752 unsigned Depth) {
8907 return matchMinMax(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS, RHS, Depth);
9058 unsigned Depth) {
9059 if (Depth >= MaxAnalysisRecursionDepth)
9072 CastOp, Depth);
9077 Instruction::CastOps *CastOp, unsigned Depth) {
9098 LHS, RHS, Depth);
9107 LHS, RHS, Depth);
9111 LHS, RHS, Depth);
9540 const DataLayout &DL, bool LHSIsTrue, unsigned Depth) {
9547 assert(Depth <= MaxAnalysisRecursionDepth && "Hit recursion limit");
9557 ALHS, RHSPred, RHSOp0, RHSOp1, DL, LHSIsTrue, Depth + 1))
9560 ARHS, RHSPred, RHSOp0, RHSOp1, DL, LHSIsTrue, Depth + 1))
9570 const DataLayout &DL, bool LHSIsTrue, unsigned Depth) {
9572 if (Depth == MaxAnalysisRecursionDepth)
9600 Depth);
9607 bool LHSIsTrue, unsigned Depth) {
9623 RHSCmp->getOperand(1), DL, LHSIsTrue, Depth))
9628 if (Depth == MaxAnalysisRecursionDepth)
9636 isImpliedCondition(LHS, RHS1, DL, LHSIsTrue, Depth + 1))
9640 isImpliedCondition(LHS, RHS2, DL, LHSIsTrue, Depth + 1))
9646 isImpliedCondition(LHS, RHS1, DL, LHSIsTrue, Depth + 1))
9650 isImpliedCondition(LHS, RHS2, DL, LHSIsTrue, Depth + 1))
10091 unsigned Depth) {
10094 if (Depth == MaxAnalysisRecursionDepth)
10113 SI->getTrueValue(), ForSigned, UseInstrInfo, AC, CtxI, DT, Depth + 1);
10115 SI->getFalseValue(), ForSigned, UseInstrInfo, AC, CtxI, DT, Depth + 1);
10158 UseInstrInfo, AC, I, DT, Depth + 1);