[PATCH 34/73] bitwise: Allow restricted ordered compares with unrestricted values

[Bart Van Assche <bvanassche@acm.org>]

From: Linus Torvalds <torvalds@linux-foundation.org>

Update restricted_binop() to check unrestricted values (0 and ~0) for
ordered comparisons just like equality comparisons, and warn when '<' or
'>' is used against 0 or ~0 because restricted types are unsigned and
those comparisons are always true or false.

Allow idiomatic bounds checks such as 'flags <= 0' or 'flags >= ~0' on
bitwise types while catching tautological comparisons.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
[ bvanassche: Rewrite commit message in imperative mood, require unsigned
  types in can_order() without warning on '<' or '>', pass the target
  type to restricted_value(), and extend
  validation/bitwise-all-bits-and-casts.c ]
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 evaluate.c                              | 25 ++++++++++++++++++++++---
 validation/bitwise-all-bits-and-casts.c | 18 ++++++++++++++++++
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/evaluate.c b/evaluate.c
index f4d59d2679d6..23f9e0fcdc4a 100644
--- a/evaluate.c
+++ b/evaluate.c
@@ -465,7 +465,19 @@ static int restricted_value(struct expression *v, struct symbol *type)
 	return 0;
 }
 
-static int restricted_binop(int op, struct symbol *type)
+/*
+ * Bitwise types can do ordered comparisons with
+ * the unrestricted values, but not in general
+ */
+static bool can_order(struct symbol *type, struct expression *left, struct expression *right)
+{
+	if (!is_unsigned_restricted_or_int(type))
+		return false;
+	return !restricted_value(left, type) ||
+		!restricted_value(right, type);
+}
+
+static int restricted_binop(int op, struct symbol *type, struct expression *left, struct expression *right)
 {
 	switch (op) {
 		case '&':
@@ -478,6 +490,13 @@ static int restricted_binop(int op, struct symbol *type)
 		case '^':
 		case '?':
 			return 2;	/* keep fouled */
+		case '<':
+		case '>':
+		case SPECIAL_LTE:
+		case SPECIAL_GTE:
+			if (can_order(type, left, right))
+				return 3;
+			return 0;
 		case SPECIAL_EQUAL:
 		case SPECIAL_NOTEQUAL:
 			return 3;	/* warn if fouled */
@@ -530,7 +549,7 @@ static struct symbol *restricted_binop_type(int op,
 		ctype = rtype;
 
 	if (ctype) {
-		switch (restricted_binop(op, ctype)) {
+		switch (restricted_binop(op, ctype, left, right)) {
 		case 1:
 			if ((lclass ^ rclass) & TYPE_FOULED)
 				ctype = unfoul(ctype);
@@ -1364,7 +1383,7 @@ static int evaluate_assign_op(struct expression *expr)
 			return 0;
 		}
 		if (tclass & TYPE_RESTRICT) {
-			if (!restricted_binop(op, t)) {
+			if (!restricted_binop(op, t, expr->left, expr->right)) {
 				warning(expr->pos, "bad assignment (%s) to %s",
 					show_special(op), show_typename(t));
 				expr->right = cast_to(expr->right, target);
diff --git a/validation/bitwise-all-bits-and-casts.c b/validation/bitwise-all-bits-and-casts.c
index c69041f80318..08f2b4c43285 100644
--- a/validation/bitwise-all-bits-and-casts.c
+++ b/validation/bitwise-all-bits-and-casts.c
@@ -30,6 +30,24 @@ static be16 test_narrow_all_bits(void)
 	return a | b;
 }
 
+static int test_ordered_compare(be32 x, be16 y)
+{
+	int res = 0;
+	if (x > 0)
+		res++;
+	if (x <= 0)
+		res++;
+	if (0 < x)
+		res++;
+	if (0 >= x)
+		res++;
+	if (x < ~0)
+		res++;
+	if (y <= 0xffff)
+		res++;
+	return res;
+}
+
 /*
  * check-name: bitwise-all-bits-and-casts
  * check-command: sparse -Wbitwise $file