Lines Matching defs:IntRange

9588 struct IntRange {
9598   IntRange(unsigned Width, bool NonNegative)
9607   static IntRange forBoolType() {
9608     return IntRange(1, true);
9612   static IntRange forValueOfType(ASTContext &C, QualType T) {
9618   static IntRange forValueOfCanonicalType(ASTContext &C, const Type *T) {
9638         return IntRange(C.getIntWidth(QualType(T, 0)),
9646         return IntRange(NumPositive, true/*NonNegative*/);
9648         return IntRange(std::max(NumPositive + 1, NumNegative),
9653       return IntRange(EIT->getNumBits(), EIT->isUnsigned());
9658     return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger());
9666   static IntRange forTargetOfCanonicalType(ASTContext &C, const Type *T) {
9679       return IntRange(EIT->getNumBits(), EIT->isUnsigned());
9684     return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger());
9688   static IntRange join(IntRange L, IntRange R) {
9690     return IntRange(std::max(L.valueBits(), R.valueBits()) + !Unsigned,
9695   static IntRange bit_and(IntRange L, IntRange R) {
9706     return IntRange(Bits, NonNegative);
9710   static IntRange sum(IntRange L, IntRange R) {
9712     return IntRange(std::max(L.valueBits(), R.valueBits()) + 1 + !Unsigned,
9717   static IntRange difference(IntRange L, IntRange R) {
9723     return IntRange(std::max(L.valueBits(), R.valueBits()) + CanWiden +
9729   static IntRange product(IntRange L, IntRange R) {
9735     return IntRange(L.valueBits() + R.valueBits() + CanWiden + !Unsigned,
9740   static IntRange rem(IntRange L, IntRange R) {
9744     return IntRange(std::min(L.valueBits(), R.valueBits()) + !Unsigned,
9751 static IntRange GetValueRange(ASTContext &C, llvm::APSInt &value,
9754     return IntRange(value.getSignificantBits(), false);
9761   return IntRange(value.getActiveBits(), true);
9764 static IntRange GetValueRange(ASTContext &C, APValue &result, QualType Ty,
9770     IntRange R = GetValueRange(C, result.getVectorElt(0), Ty, MaxWidth);
9772       IntRange El = GetValueRange(C, result.getVectorElt(i), Ty, MaxWidth);
9773       R = IntRange::join(R, El);
9779     IntRange R = GetValueRange(C, result.getComplexIntReal(), MaxWidth);
9780     IntRange I = GetValueRange(C, result.getComplexIntImag(), MaxWidth);
9781     return IntRange::join(R, I);
9790   return IntRange(MaxWidth, Ty->isUnsignedIntegerOrEnumerationType());
9813 static std::optional<IntRange> TryGetExprRange(ASTContext &C, const Expr *E,
9832     IntRange OutputTypeRange = IntRange::forValueOfType(C, GetExprType(CE));
9841     std::optional<IntRange> SubRange = TryGetExprRange(
9853     return IntRange(SubRange->Width,
9872     std::optional<IntRange> L =
9881     std::optional<IntRange> R =
9886     return IntRange::join(*L, *R);
9890     IntRange (*Combine)(IntRange, IntRange) = IntRange::join;
9905       return IntRange::forBoolType();
9917       return IntRange::forValueOfType(C, GetExprType(E));
9929       return IntRange::forValueOfType(C, GetExprType(E));
9934       Combine = IntRange::bit_and;
9944           IntRange R = IntRange::forValueOfType(C, GetExprType(E));
9945           return IntRange(R.Width, /*NonNegative*/ true);
9951       return IntRange::forValueOfType(C, GetExprType(E));
9956       std::optional<IntRange> L = TryGetExprRange(
9983         Combine = IntRange::sum;
9988         return IntRange::forValueOfType(C, GetExprType(E));
9990         Combine = IntRange::difference;
9995         Combine = IntRange::product;
10003       std::optional<IntRange> L = TryGetExprRange(
10022       std::optional<IntRange> R = TryGetExprRange(
10027       return IntRange(L->Width, L->NonNegative && R->NonNegative);
10031       Combine = IntRange::rem;
10044     std::optional<IntRange> L = TryGetExprRange(C, BO->getLHS(), opWidth,
10049     std::optional<IntRange> R = TryGetExprRange(C, BO->getRHS(), opWidth,
10054     IntRange C = Combine(*L, *R);
10064       return IntRange::forBoolType();
10069       return IntRange::forValueOfType(C, GetExprType(E));
10082     return IntRange(BitField->getBitWidthValue(),
10088   return IntRange::forValueOfType(C, GetExprType(E));
10091 static std::optional<IntRange> TryGetExprRange(ASTContext &C, const Expr *E,
10183   PromotedRange(IntRange R, unsigned BitWidth, bool Unsigned) {
10340   std::optional<IntRange> OtherValueRange = TryGetExprRange(
10348   IntRange OtherTypeRange = IntRange::forValueOfType(S.Context, OtherT);
10351   // (Namely, macOS). FIXME: IntRange::forValueOfType should do this.
10361     OtherTypeRange = *OtherValueRange = IntRange::forBoolType();
10558   std::optional<IntRange> signedRange =
10579     std::optional<IntRange> unsignedRange = TryGetExprRange(
10938                                       IntRange Range) {
11396     std::optional<IntRange> SourceRange =
11464   std::optional<IntRange> LikelySourceRange = TryGetExprRange(
11469   IntRange SourceTypeRange =
11470       IntRange::forTargetOfCanonicalType(Context, Source);
11471   IntRange TargetRange = IntRange::forTargetOfCanonicalType(Context, Target);