Cross Reference: /src/external/apache2/llvm/dist/clang/lib/Sema/SemaChecking.cpp

Lines Matching defs:IntRange
10651 struct IntRange {
10661   IntRange(unsigned Width, bool NonNegative)
10670   static IntRange forBoolType() {
10671     return IntRange(1, true);
10675   static IntRange forValueOfType(ASTContext &C, QualType T) {
10681   static IntRange forValueOfCanonicalType(ASTContext &C, const Type *T) {
10701         return IntRange(C.getIntWidth(QualType(T, 0)),
10709         return IntRange(NumPositive, true/*NonNegative*/);
10711         return IntRange(std::max(NumPositive + 1, NumNegative),
10716       return IntRange(EIT->getNumBits(), EIT->isUnsigned());
10721     return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger());
10729   static IntRange forTargetOfCanonicalType(ASTContext &C, const Type *T) {
10742       return IntRange(EIT->getNumBits(), EIT->isUnsigned());
10747     return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger());
10751   static IntRange join(IntRange L, IntRange R) {
10753     return IntRange(std::max(L.valueBits(), R.valueBits()) + !Unsigned,
10758   static IntRange bit_and(IntRange L, IntRange R) {
10769     return IntRange(Bits, NonNegative);
10773   static IntRange sum(IntRange L, IntRange R) {
10775     return IntRange(std::max(L.valueBits(), R.valueBits()) + 1 + !Unsigned,
10780   static IntRange difference(IntRange L, IntRange R) {
10786     return IntRange(std::max(L.valueBits(), R.valueBits()) + CanWiden +
10792   static IntRange product(IntRange L, IntRange R) {
10798     return IntRange(L.valueBits() + R.valueBits() + CanWiden + !Unsigned,
10803   static IntRange rem(IntRange L, IntRange R) {
10807     return IntRange(std::min(L.valueBits(), R.valueBits()) + !Unsigned,
10814 static IntRange GetValueRange(ASTContext &C, llvm::APSInt &value,
10817     return IntRange(value.getMinSignedBits(), false);
10824   return IntRange(value.getActiveBits(), true);
10827 static IntRange GetValueRange(ASTContext &C, APValue &result, QualType Ty,
10833     IntRange R = GetValueRange(C, result.getVectorElt(0), Ty, MaxWidth);
10835       IntRange El = GetValueRange(C, result.getVectorElt(i), Ty, MaxWidth);
10836       R = IntRange::join(R, El);
10842     IntRange R = GetValueRange(C, result.getComplexIntReal(), MaxWidth);
10843     IntRange I = GetValueRange(C, result.getComplexIntImag(), MaxWidth);
10844     return IntRange::join(R, I);
10853   return IntRange(MaxWidth, Ty->isUnsignedIntegerOrEnumerationType());
10871 static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth,
10888     IntRange OutputTypeRange = IntRange::forValueOfType(C, GetExprType(CE));
10897     IntRange SubRange = GetExprRange(C, CE->getSubExpr(),
10907     return IntRange(SubRange.Width,
10923     IntRange L = E->getType()->isVoidType()
10924                      ? IntRange{0, true}
10927     IntRange R = E->getType()->isVoidType()
10928                      ? IntRange{0, true}
10930     return IntRange::join(L, R);
10934     IntRange (*Combine)(IntRange, IntRange) = IntRange::join;
10949       return IntRange::forBoolType();
10961       return IntRange::forValueOfType(C, GetExprType(E));
10973       return IntRange::forValueOfType(C, GetExprType(E));
10978       Combine = IntRange::bit_and;
10988           IntRange R = IntRange::forValueOfType(C, GetExprType(E));
10989           return IntRange(R.Width, /*NonNegative*/ true);
10995       return IntRange::forValueOfType(C, GetExprType(E));
11000       IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth, InConstantContext,
11026         Combine = IntRange::sum;
11031         return IntRange::forValueOfType(C, GetExprType(E));
11033         Combine = IntRange::difference;
11038         Combine = IntRange::product;
11046       IntRange L = GetExprRange(C, BO->getLHS(), opWidth, InConstantContext,
11063       IntRange R = GetExprRange(C, BO->getRHS(), opWidth, InConstantContext,
11065       return IntRange(L.Width, L.NonNegative && R.NonNegative);
11069       Combine = IntRange::rem;
11082     IntRange L =
11084     IntRange R =
11086     IntRange C = Combine(L, R);
11096       return IntRange::forBoolType();
11101       return IntRange::forValueOfType(C, GetExprType(E));
11114     return IntRange(BitField->getBitWidthValue(C),
11117   return IntRange::forValueOfType(C, GetExprType(E));
11120 static IntRange GetExprRange(ASTContext &C, const Expr *E,
11211   PromotedRange(IntRange R, unsigned BitWidth, bool Unsigned) {
11368   IntRange OtherValueRange = GetExprRange(
11374   IntRange OtherTypeRange = IntRange::forValueOfType(S.Context, OtherT);
11377   // (Namely, macOS). FIXME: IntRange::forValueOfType should do this.
11387     OtherTypeRange = OtherValueRange = IntRange::forBoolType();
11582   IntRange signedRange = GetExprRange(
11600     IntRange unsignedRange =
11973                                       IntRange Range) {
12494     IntRange SourceRange = GetExprRange(S.Context, E, S.isConstantEvaluated(),
12560   IntRange SourceTypeRange =
12561       IntRange::forTargetOfCanonicalType(S.Context, Source);
12562   IntRange LikelySourceRange =
12564   IntRange TargetRange = IntRange::forTargetOfCanonicalType(S.Context, Target);
OpenGrok
