[Bug middle-end/48580] missed optimization: integer overflow checks

["Martin.vGagern at gmx dot net" <gcc-bugzilla@gcc.gnu.org>]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=48580

Martin von Gagern <Martin.vGagern at gmx dot net> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |Martin.vGagern at gmx dot
                   |                            |net

--- Comment #15 from Martin von Gagern <Martin.vGagern at gmx dot net> 2013-02-02 14:03:12 UTC ---
(In reply to comment #7)
> […] built-in operations where you can just say "multiply two 
> (signed) values, check whether the result fits in 31-bit unsigned and set 
> an overflow flag accordingly".

Would be easier to read, easier to maintain, and less difficult to detect.
Sounds like an overall win. I'm very much in favor of builtins like these.

(In reply to comment #9)
> arith_mul_signed_check (a, b, 32, ARITH_WRAP, &overflow_p)

I'd rather make the overflow indicator the return value, and transfer the
result to a location indicated via a pointer. I.e.

overflow_p = arith_mul_signed_check (a, b, 32, ARITH_WRAP, &a_times_b)

One reason is that one usually wants to check for overflow BEFORE using the
result, i.e. the common use case would likely use the above as a condition of
some branching construct. A second reason is that this would allow for a flavor
which will not modify a_times_b in case of an overflow, which might be useful
for some scenarios, particularly if the result is stored in the same location
as one of the operands, thus overwriting the operand. So an unchecked a*=b
could be transformed into the checked construct

overflow_p = arith_mul_signed_check (a, b, 32, ARITH_CAREFUL, &a)

(In reply to comment #14)
> The trouble is that the nature of an operation is more a property of the 
> operation than of the type

I agree. The main point of all of this is optimization. And in terms of
optimization, one would want to examine some flag immediately after an
operation setting that flag. One would act upon the flag, and then discard it.
If the information were part of the type, one would require extra storage to
save those flags, which would lead to a change in the size of these types,
which in turn would severely impact many other things.