Richard Guenther - Re: PATCH RFC: -Wstrict-overflow, take 2 (original) (raw)

This is the mail archive of the gcc-patches@gcc.gnu.orgmailing list for the GCC project.

• From: "Richard Guenther"
• To: "Ian Lance Taylor"
• Cc: gcc-patches at gcc dot gnu dot org
• Date: Fri, 9 Feb 2007 11:02:44 +0100
• Subject: Re: PATCH RFC: -Wstrict-overflow, take 2
• References: <m3hctwgi1d.fsf@localhost.localdomain>

On 08 Feb 2007 18:51:26 -0800, Ian Lance Taylor iant@google.com wrote:

Here is a new version of my -Wstrict-overflow patch. This incorporates all the comments made on the first version.

-Wstrict-overflow is a new warning about cases where the compiler optimizes based on the assumption that signed overflow is undefined. This warning can produce a number of false positives, because the values which actually appear in the program may be such that overflow never does, in fact, occur. Therefore, the warning comes in five levels.

-Wstrict-overflow is equivalent to -Wstrict-overflow=1. This level is automatically enabled by -Wall. It warns about questionable cases which are easy to avoid. For example, it will warn about optimizing (x + 1 > x) to 1 (this optimization will yield an unexpected result if X == INT_MAX).

-Wstrict-overflow=2 additionally warns about cases where a conditional expression is folded to a constant. A typical example would be (abs (x) >= 0), which will be folded to 1 (this optimization will yield an unexpected result if x == INT_MIN).

-Wstrict-overflow=3 additionally warns about cases where a comparison is changed in some way other than folding it to a constant. A typical example would be converting (x + 1 > 1) to (x > 0) (this optimization will yield an unexpected result if x == INT_MAX).

-Wstrict-overflow=4 additionally warns about warnings not covered by the above cases (or the case below). A typical example would be converting ((x * 10) / 5) to (x * 2) (this optimization will yield an unexpected result if x == ((INT_MAX / 2) - 1)).

-Wstrict-overflow=5 additionally warns about reducing the magnitude of a constant involved in a comparison. This is a particularly fertile source of false positives, as it is a canonicalization rather than an optimization per se. That is why it is segregated from the other options. For example: changing (x + 2 > y) to (x + 1 >= y) (this optimization will yield an unexpected result if x == INT_MAX - 1).

Are levels 4 and 5 useful at all? I wonder what would be a good level to turn on (apart from -Wall) for a distributor builting random packages. Did you try building emacs? ;)

Does -Wstrict-overflow=3 -Werror=strict-overflow=1 work? Hopefully at least -Wno-error=strict-overflow does.

     if (negate_expr_p (tem))

•        return fold_build2 (TREE_CODE (t), type,

•                           TREE_OPERAND (t, 0), negate_expr (tem));

•       {

•         if (INTEGRAL_TYPE_P (type)

•             && (TREE_CODE (tem) != INTEGER_CST

•                 || tree_int_cst_equal (tem,

•                                        build_int_cst (type, 1))))

integer_onep (tem)

•           fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);

•         return fold_build2 (TREE_CODE (t), type,

•                             TREE_OPERAND (t, 0), negate_expr (tem));

•       }

Thanks, Richard.

• Follow-Ups:
  • Re: PATCH RFC: -Wstrict-overflow, take 2
    * From: Ian Lance Taylor
• References:
  • PATCH RFC: -Wstrict-overflow, take 2
    * From: Ian Lance Taylor