From c27b5c621add2e8fb6b902db970f1567f98702e5 Mon Sep 17 00:00:00 2001 From: Jim Wilson Date: Sun, 2 Apr 1995 14:34:42 -0700 Subject: [PATCH] (simplify_relational_operation): Don't simplify A-B for compare of A and B when the compare is unsigned. From-SVN: r9296 --- gcc/cse.c | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/gcc/cse.c b/gcc/cse.c index 76f70e28c36b..7a0aba82ef12 100644 --- a/gcc/cse.c +++ b/gcc/cse.c @@ -4378,20 +4378,16 @@ simplify_relational_operation (code, mode, op0, op1) a register or a CONST_INT, this can't help; testing for these cases will prevent infinite recursion here and speed things up. - If CODE is an unsigned comparison, we can only do this if A - B is a - constant integer, and then we have to compare that integer with zero as a - signed comparison. Note that this will give the incorrect result from - comparisons that overflow. Since these are undefined, this is probably - OK. If it causes a problem, we can check for A or B being an address - (fp + const or SYMBOL_REF) and only do it in that case. */ + If CODE is an unsigned comparison, then we can never do this optimization, + because it gives an incorrect result if the subtraction wraps around zero. + ANSI C defines unsigned operations such that they never overflow, and + thus such cases can not be ignored. */ if (INTEGRAL_MODE_P (mode) && op1 != const0_rtx && ! ((GET_CODE (op0) == REG || GET_CODE (op0) == CONST_INT) && (GET_CODE (op1) == REG || GET_CODE (op1) == CONST_INT)) && 0 != (tem = simplify_binary_operation (MINUS, mode, op0, op1)) - && (GET_CODE (tem) == CONST_INT - || (code != GTU && code != GEU && - code != LTU && code != LEU))) + && code != GTU && code != GEU && code != LTU && code != LEU) return simplify_relational_operation (signed_condition (code), mode, tem, const0_rtx); -- 2.43.5