Lines Matching defs:Result
464 // greater than RHS, respectively. A three-way result allows recursive
672 /// BinomialCoefficient - Compute BC(It, K). The result has width W.
686 // overflow. Hence, we must assure that the result of our computation is
718 // the result must be zero anyway. We prefer here to do it in the width of
740 // W bits of the result.
778 // Truncate the result, and divide by K! / 2^T.
795 const SCEV *Result = getStart();
804 Result = SE.getAddExpr(Result, SE.getMulExpr(getOperand(i), Coeff));
806 return Result;
953 // attempting to ask for the backedge-taken count would likely result
1075 // result, the expression "Step + sext(PreIncAR)" is congruent with
1219 // attempting to ask for the backedge-taken count would likely result
1531 // type, see if factoring out the truncate would permit the result to be
1827 /// Compute the result of "n choose k", the binomial coefficient. If an
1835 // integral result, and helps reduce the chance of overflow in the
1837 // final result would fit.
2126 // If the denominator is zero, the result of the udiv is undefined. Don't
3210 // The result is the min of all operands results.
3218 // The result is the sum of all operands results.
3229 // The result is the min of all operands results.
3237 // The result is the min of all operands results.
3245 // The result is the min of all operands results.
3590 // and call getAddExpr with the result. However if we're looking at a
3740 // If the shift count is not less than the bitwidth, the result of
3758 // If the shift count is not less than the bitwidth, the result of
3779 // If the shift count is not less than the bitwidth, the result of
3981 ConstantInt *Result = MulC->getValue();
3984 if (!Result || Result->getValue().getActiveBits() > 32)
3987 return (unsigned)Result->getZExtValue();
4037 // backedge-taken count, which could result in infinite recursion.
4043 // ComputeBackedgeTakenCount may allocate memory for its result. Inserting it
4044 // into the BackedgeTakenCounts map transfers ownership. Otherwise, the result
4046 BackedgeTakenInfo Result = ComputeBackedgeTakenCount(L);
4048 if (Result.getExact(this) != getCouldNotCompute()) {
4049 assert(isLoopInvariant(Result.getExact(this), L) &&
4050 isLoopInvariant(Result.getMax(this), L) &&
4054 else if (Result.getMax(this) == getCouldNotCompute() &&
4065 if (Result.hasAnyInfo()) {
4098 // ComputeBackedgeTakenCount above could result in a
4102 return BackedgeTakenCounts.find(L)->second = Result;
4174 /// exits. A computable result can only be return for loops with a single exit.
4251 /// clear - Invalidate this result and free the ExitNotTakenInfo array.
4638 Constant *Result = ConstantFoldLoadThroughGEPIndices(GV->getInitializer(),
4640 if (Result == 0) break; // Cannot compute!
4643 Result = ConstantExpr::getICmp(predicate, Result, RHS);
4644 if (!isa<ConstantInt>(Result)) break; // Couldn't decide for sure
4645 if (cast<ConstantInt>(Result)->getValue().isMinValue()) {
4712 // If this operand is already visited, reuse the prior result.
5118 // result. This is particularly useful for computing loop exit values.
5328 APInt Result = (I * B.lshr(Mult2).zext(BW + 1)).urem(Mod);
5330 // The result is guaranteed to be less than 2^BW so we may truncate it to BW
5332 return SE.getConstant(Result.trunc(BW));
6392 // getBECount(MinStart, MaxEnd) may not compute. This would result in an
