Lines Matching defs:IntRange

9254 struct IntRange {
9264   IntRange(unsigned Width, bool NonNegative)
9273   static IntRange forBoolType() {
9274     return IntRange(1, true);
9278   static IntRange forValueOfType(ASTContext &C, QualType T) {
9284   static IntRange forValueOfCanonicalType(ASTContext &C, const Type *T) {
9304         return IntRange(C.getIntWidth(QualType(T, 0)),
9312         return IntRange(NumPositive, true/*NonNegative*/);
9314         return IntRange(std::max(NumPositive + 1, NumNegative),
9319       return IntRange(EIT->getNumBits(), EIT->isUnsigned());
9324     return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger());
9332   static IntRange forTargetOfCanonicalType(ASTContext &C, const Type *T) {
9345       return IntRange(EIT->getNumBits(), EIT->isUnsigned());
9350     return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger());
9354   static IntRange join(IntRange L, IntRange R) {
9356     return IntRange(std::max(L.valueBits(), R.valueBits()) + !Unsigned,
9361   static IntRange bit_and(IntRange L, IntRange R) {
9372     return IntRange(Bits, NonNegative);
9376   static IntRange sum(IntRange L, IntRange R) {
9378     return IntRange(std::max(L.valueBits(), R.valueBits()) + 1 + !Unsigned,
9383   static IntRange difference(IntRange L, IntRange R) {
9389     return IntRange(std::max(L.valueBits(), R.valueBits()) + CanWiden +
9395   static IntRange product(IntRange L, IntRange R) {
9401     return IntRange(L.valueBits() + R.valueBits() + CanWiden + !Unsigned,
9406   static IntRange rem(IntRange L, IntRange R) {
9410     return IntRange(std::min(L.valueBits(), R.valueBits()) + !Unsigned,
9417 static IntRange GetValueRange(ASTContext &C, llvm::APSInt &value,
9420     return IntRange(value.getSignificantBits(), false);
9427   return IntRange(value.getActiveBits(), true);
9430 static IntRange GetValueRange(ASTContext &C, APValue &result, QualType Ty,
9436     IntRange R = GetValueRange(C, result.getVectorElt(0), Ty, MaxWidth);
9438       IntRange El = GetValueRange(C, result.getVectorElt(i), Ty, MaxWidth);
9439       R = IntRange::join(R, El);
9445     IntRange R = GetValueRange(C, result.getComplexIntReal(), MaxWidth);
9446     IntRange I = GetValueRange(C, result.getComplexIntImag(), MaxWidth);
9447     return IntRange::join(R, I);
9456   return IntRange(MaxWidth, Ty->isUnsignedIntegerOrEnumerationType());
9474 static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth,
9491     IntRange OutputTypeRange = IntRange::forValueOfType(C, GetExprType(CE));
9500     IntRange SubRange = GetExprRange(C, CE->getSubExpr(),
9510     return IntRange(SubRange.Width,
9526     IntRange L = E->getType()->isVoidType()
9527                      ? IntRange{0, true}
9530     IntRange R = E->getType()->isVoidType()
9531                      ? IntRange{0, true}
9533     return IntRange::join(L, R);
9537     IntRange (*Combine)(IntRange, IntRange) = IntRange::join;
9552       return IntRange::forBoolType();
9564       return IntRange::forValueOfType(C, GetExprType(E));
9576       return IntRange::forValueOfType(C, GetExprType(E));
9581       Combine = IntRange::bit_and;
9591           IntRange R = IntRange::forValueOfType(C, GetExprType(E));
9592           return IntRange(R.Width, /*NonNegative*/ true);
9598       return IntRange::forValueOfType(C, GetExprType(E));
9603       IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth, InConstantContext,
9628         Combine = IntRange::sum;
9633         return IntRange::forValueOfType(C, GetExprType(E));
9635         Combine = IntRange::difference;
9640         Combine = IntRange::product;
9648       IntRange L = GetExprRange(C, BO->getLHS(), opWidth, InConstantContext,
9665       IntRange R = GetExprRange(C, BO->getRHS(), opWidth, InConstantContext,
9667       return IntRange(L.Width, L.NonNegative && R.NonNegative);
9671       Combine = IntRange::rem;
9684     IntRange L =
9686     IntRange R =
9688     IntRange C = Combine(L, R);
9698       return IntRange::forBoolType();
9703       return IntRange::forValueOfType(C, GetExprType(E));
9716     return IntRange(BitField->getBitWidthValue(C),
9719   return IntRange::forValueOfType(C, GetExprType(E));
9722 static IntRange GetExprRange(ASTContext &C, const Expr *E,
9813   PromotedRange(IntRange R, unsigned BitWidth, bool Unsigned) {
9970   IntRange OtherValueRange = GetExprRange(
9976   IntRange OtherTypeRange = IntRange::forValueOfType(S.Context, OtherT);
9979   // (Namely, macOS). FIXME: IntRange::forValueOfType should do this.
9989     OtherTypeRange = OtherValueRange = IntRange::forBoolType();
10186   IntRange signedRange =
10205     IntRange unsignedRange =
10562                                       IntRange Range) {
11020     IntRange SourceRange =
11087   IntRange SourceTypeRange =
11088       IntRange::forTargetOfCanonicalType(Context, Source);
11089   IntRange LikelySourceRange = GetExprRange(
11091   IntRange TargetRange = IntRange::forTargetOfCanonicalType(Context, Target);