manas updated this revision to Diff 445549.
manas added a comment.
Remove filling gaps and convert, use castTo, and add tests for short-ushort,
char-uchar pairs
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D112621/new/
https://reviews.llvm.org/D112621
Files:
clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp
clang/test/Analysis/constant-folding.c
Index: clang/test/Analysis/constant-folding.c
===================================================================
--- clang/test/Analysis/constant-folding.c
+++ clang/test/Analysis/constant-folding.c
@@ -281,3 +281,111 @@
clang_analyzer_eval((b % a) < x + 10); // expected-warning{{TRUE}}
}
}
+
+void testDisequalityRules(unsigned int u1, unsigned int u2, unsigned int u3,
+ int s1, int s2, int s3, unsigned char uch,
+ signed char sch, short ssh, unsigned short ush) {
+
+ // Check when RHS is in between two Ranges in LHS
+ if (((u1 >= 1 && u1 <= 2) || (u1 >= 8 && u1 <= 9)) &&
+ u2 >= 5 && u2 <= 6) {
+ // u1: [1, 2]U[8, 9], u2: [5, 6]
+ clang_analyzer_eval(u1 != u2); // expected-warning{{TRUE}}
+ }
+
+ // Checks for concrete value with same type
+ if (u1 > 1 && u1 < 3 && u2 > 1 && u2 < 3) {
+ // u1: [2, 2], u2: [2, 2]
+ clang_analyzer_eval(u1 != u2); // expected-warning{{FALSE}}
+ }
+
+ // Check for concrete value with different types
+ if (u1 > 4 && u1 < 6 && s1 > 4 && s1 < 6) {
+ // u1: [5, 5], s1: [5, 5]
+ clang_analyzer_eval(u1 != s1); // expected-warning{{FALSE}}
+ }
+
+ // Checks when ranges are not overlapping
+ if (u1 <= 10 && u2 >= 20) {
+ // u1: [0,10], u2: [20,UINT_MAX]
+ clang_analyzer_eval(u1 != u2); // expected-warning{{TRUE}}
+ }
+
+ if (s1 <= INT_MIN + 10 && s2 >= INT_MAX - 10) {
+ // s1: [INT_MIN,INT_MIN + 10], s2: [INT_MAX - 10,INT_MAX]
+ clang_analyzer_eval(s1 != s2); // expected-warning{{TRUE}}
+ }
+
+ // Checks when ranges are completely overlapping and have more than one point
+ if (u1 >= 20 && u1 <= 50 && u2 >= 20 && u2 <= 50) {
+ // u1: [20,50], u2: [20,50]
+ clang_analyzer_eval(u1 != u2); // expected-warning{{UNKNOWN}}
+ }
+
+ if (s1 >= -20 && s1 <= 20 && s2 >= -20 && s2 <= 20) {
+ // s1: [-20,20], s2: [-20,20]
+ clang_analyzer_eval(s1 != s2); // expected-warning{{UNKNOWN}}
+ }
+
+ // Checks when ranges are partially overlapping
+ if (u1 >= 100 && u1 <= 200 && u2 >= 150 && u2 <= 300) {
+ // u1: [100,200], u2: [150,300]
+ clang_analyzer_eval(u1 != u2); // expected-warning{{UNKNOWN}}
+ }
+
+ if (s1 >= -80 && s1 <= -50 && s2 >= -100 && s2 <= -75) {
+ // s1: [-80,-50], s2: [-100,-75]
+ clang_analyzer_eval(s1 != s2); // expected-warning{{UNKNOWN}}
+ }
+
+ // Checks for ranges which are subset of one-another
+ if (u1 >= 500 && u1 <= 1000 && u2 >= 750 && u2 <= 1000) {
+ // u1: [500,1000], u2: [750,1000]
+ clang_analyzer_eval(u1 != u2); // expected-warning{{UNKNOWN}}
+ }
+
+ if (s1 >= -1000 && s1 <= -500 && s2 <= -500 && s2 >= -750) {
+ // s1: [-1000,-500], s2: [-500,-750]
+ clang_analyzer_eval(s1 != s2); // expected-warning{{UNKNOWN}}
+ }
+
+ // Checks for comparison between different types
+ // Using different variables as previous constraints may interfere in the
+ // reasoning.
+ if (u3 <= 255 && s3 < 0) {
+ // u3: [0, 255], s3: [INT_MIN, -1]
+ clang_analyzer_eval(u3 != s3); // expected-warning{{TRUE}}
+ }
+
+ // Checks for char-uchar types
+ if (uch >= 1 && sch <= 1) {
+ // uch: [1, UCHAR_MAX], sch: [SCHAR_MIN, 1]
+ clang_analyzer_eval(uch != sch); // expected-warning{{UNKNOWN}}
+ }
+
+ if (uch > 1 && sch < 1) {
+ // uch: [2, CHAR_MAX], sch: [SCHAR_MIN, 0]
+ clang_analyzer_eval(uch != sch); // expected-warning{{TRUE}}
+ }
+
+ if (uch <= 1 && uch >= 1 && sch <= 1 && sch >= 1) {
+ // uch: [1, 1], sch: [1, 1]
+ clang_analyzer_eval(uch != sch); // expected-warning{{FALSE}}
+ }
+
+ // Checks for short-ushort types
+ if (ush >= 1 && ssh <= 1) {
+ // ush: [1, USHRT_MAX], ssh: [SHRT_MIN, 1]
+ clang_analyzer_eval(ush != ssh); // expected-warning{{UNKNOWN}}
+ }
+
+ if (ush > 1 && ssh < 1) {
+ // ush: [2, USHRT_MAX], ssh: [SHRT_MIN, 0]
+ clang_analyzer_eval(ush != ssh); // expected-warning{{TRUE}}
+ }
+
+ if (ush <= 1 && ush >= 1 && ssh <= 1 && ssh >= 1) {
+ // ush: [1, 1], ssh: [1, 1]
+ clang_analyzer_eval(ush != ssh); // expected-warning{{FALSE}}
+ }
+}
Index: clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp
===================================================================
--- clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp
+++ clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp
@@ -1333,18 +1333,7 @@
}
RangeSet VisitBinaryOperator(RangeSet LHS, BinaryOperator::Opcode Op,
- RangeSet RHS, QualType T) {
- switch (Op) {
- case BO_Or:
- return VisitBinaryOperator<BO_Or>(LHS, RHS, T);
- case BO_And:
- return VisitBinaryOperator<BO_And>(LHS, RHS, T);
- case BO_Rem:
- return VisitBinaryOperator<BO_Rem>(LHS, RHS, T);
- default:
- return infer(T);
- }
- }
+ RangeSet RHS, QualType T);
//===----------------------------------------------------------------------===//
// Ranges and operators
@@ -1625,6 +1614,38 @@
// Range-based reasoning about symbolic operations
//===----------------------------------------------------------------------===//
+template <>
+RangeSet SymbolicRangeInferrer::VisitBinaryOperator<BO_NE>(RangeSet LHS,
+ RangeSet RHS,
+ QualType T) {
+
+ // We must check for empty RangeSets. This gets done via VisitBinaryOperator
+ // for other operators, but BO_NE is handled specifically.
+ if (LHS.isEmpty() || RHS.isEmpty()) {
+ return RangeFactory.getEmptySet();
+ }
+
+ APSIntType ResultType = ValueFactory.getAPSIntType(T);
+
+ RangeSet CastedLHS = RangeFactory.castTo(LHS, ResultType);
+ RangeSet CastedRHS = RangeFactory.castTo(RHS, ResultType);
+
+ if (CastedLHS == RangeFactory.getEmptySet() ||
+ CastedRHS == RangeFactory.getEmptySet()) {
+ return infer(T);
+ }
+
+ // When both the Ranges are non-overlapping then all possible pairs of (x, y)
+ // in CastedLHS, CastedRHS respectively, will satisfy expression (x != y).
+ if (intersect(RangeFactory, CastedLHS, CastedRHS) ==
+ RangeFactory.getEmptySet()) {
+ return getTrueRange(T);
+ }
+
+ // In all other cases, the resulting range cannot be deduced.
+ return infer(T);
+}
+
template <>
RangeSet SymbolicRangeInferrer::VisitBinaryOperator<BO_Or>(Range LHS, Range RHS,
QualType T) {
@@ -1785,6 +1806,23 @@
return {RangeFactory, ValueFactory.getValue(Min), ValueFactory.getValue(Max)};
}
+RangeSet SymbolicRangeInferrer::VisitBinaryOperator(RangeSet LHS,
+ BinaryOperator::Opcode Op,
+ RangeSet RHS, QualType T) {
+ switch (Op) {
+ case BO_NE:
+ return VisitBinaryOperator<BO_NE>(LHS, RHS, T);
+ case BO_Or:
+ return VisitBinaryOperator<BO_Or>(LHS, RHS, T);
+ case BO_And:
+ return VisitBinaryOperator<BO_And>(LHS, RHS, T);
+ case BO_Rem:
+ return VisitBinaryOperator<BO_Rem>(LHS, RHS, T);
+ default:
+ return infer(T);
+ }
+}
+
//===----------------------------------------------------------------------===//
// Constraint manager implementation details
//===----------------------------------------------------------------------===//
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
