[PATCH 32/73] expand: Simplify signed constants early

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

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

Make constant simplification for trivial unary preops on integer
constants ('-5', '+5', '~0') available at type evaluation time via
early_simplify_preop().

Fold unary preop expressions such as '-5' and '~0' before bitwise type
evaluation so that all-bits-set constants such as -1 or ~0 are
recognized as special cases.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
[ bvanassche: Combine the two commits from Linus Torvalds ("simplify
  signed constants early" and "Fix early constant simplification"),
  rewrite the commit message in the imperative mood, include simplify.h in
  expand.c to fix make selfcheck, and guard bit_size in
  early_simplify_preop() ]
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 evaluate.c | 14 +++++++++++++-
 expand.c   | 31 +++++++++++++++++++++++++------
 simplify.h |  1 +
 3 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/evaluate.c b/evaluate.c
index 0e4e64d33192..23f87c8dff5b 100644
--- a/evaluate.c
+++ b/evaluate.c
@@ -35,6 +35,7 @@
 #include <limits.h>
 
 #include "evaluate.h"
+#include "simplify.h"
 #include "lib.h"
 #include "allocate.h"
 #include "bits.h"
@@ -1944,10 +1945,21 @@ Normal:
 	} else {
 		return bad_expr_type(expr);
 	}
-	if (expr->op == '+')
+	if (expr->op == '+') {
 		*expr = *expr->unop;
+		expr->flags = flags;
+		expr->ctype = ctype;
+		return ctype;
+	}
 	expr->flags = flags;
 	expr->ctype = ctype;
+
+	/*
+	 * We simplify sign ops of constants early, turning
+	 * a constant with a sign into just a plain constant
+	 * rather than a preop.
+	 */
+	early_simplify_preop(expr);
 	return ctype;
 Restr:
 	if (restricted_unop(expr->op, &ctype))
diff --git a/expand.c b/expand.c
index 208ce65a2442..267aaf00e9ce 100644
--- a/expand.c
+++ b/expand.c
@@ -44,6 +44,7 @@
 #include "expression.h"
 #include "evaluate.h"
 #include "expand.h"
+#include "simplify.h"
 
 
 static int expand_expression(struct expression *);
@@ -817,13 +818,24 @@ static int expand_dereference(struct expression *expr)
 	return UNSAFE;
 }
 
-static int simplify_preop(struct expression *expr)
+/*
+ * We want to do certain trivial constant simplifications
+ * early at the type evaluation stage, because those can
+ * depend on specific constants (ie ~0 is ok for restricted
+ * types).
+ *
+ * Return >0 for successful simplification, 0 for none,
+ * and <0 for "not simplified due to overflow".
+ */
+int early_simplify_preop(struct expression *expr)
 {
 	struct expression *op = expr->unop;
 	unsigned long long v, mask;
 
 	if (op->type != EXPR_VALUE)
 		return 0;
+	if (!expr->ctype || expr->ctype->bit_size <= 0 || expr->ctype->bit_size > 64)
+		return 0;
 
 	mask = sign_bit(expr->ctype->bit_size);
 	v = op->value;
@@ -831,7 +843,7 @@ static int simplify_preop(struct expression *expr)
 	case '+': break;
 	case '-':
 		if (v == mask && !(expr->ctype->ctype.modifiers & MOD_UNSIGNED))
-			goto Overflow;
+			return -1;
 		v = -v;
 		break;
 	case '!': v = !v; break;
@@ -843,11 +855,18 @@ static int simplify_preop(struct expression *expr)
 	expr->type = EXPR_VALUE;
 	expr->taint = op->taint;
 	return 1;
+}
 
-Overflow:
-	if (!conservative)
-		warning(expr->pos, "constant integer operation overflow");
-	return 0;
+static int simplify_preop(struct expression *expr)
+{
+	int simplified = early_simplify_preop(expr);
+
+	if (simplified < 0) {
+		if (!conservative)
+			warning(expr->pos, "constant integer operation overflow");
+		simplified = 0;
+	}
+	return simplified;
 }
 
 static int simplify_float_preop(struct expression *expr)
diff --git a/simplify.h b/simplify.h
index ed3dd9716a3e..15c887376445 100644
--- a/simplify.h
+++ b/simplify.h
@@ -4,6 +4,7 @@
 #include "linearize.h"
 
 int simplify_instruction(struct instruction *insn);
+int early_simplify_preop(struct expression *expr);
 
 int replace_with_pseudo(struct instruction *insn, pseudo_t pseudo);