[Bug target/30484] INT_MIN % -1 is well defined for -fwrapv

["vincent-gcc at vinc17 dot net" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=30484

--- Comment #16 from Vincent Lefèvre <vincent-gcc at vinc17 dot net> ---
The issue is that the source code assuming -fno-wrapv may be more complex, thus
giving slower generated code. Here's an example, which consists in adding 3
signed integers, for which the user knows that the sum is representable, so
that the only issue is a potential integer overflow in the first addition. I've
used GCC 11.2.0 on x86_64.

With -fwrapv, the integer overflow is well-defined as wrapping, so that the
user can write:

int f (int a, int b, int c)
{
  return a + b + c;
}

The generated code with -O3 -fwrapv has 2 instructions (the 2 additions):

        addl    %edx, %esi
        leal    (%rsi,%rdi), %eax

But without -fwrapv, one needs to make sure that one doesn't get any integer
overflow. Assume that the user knows that there is a single negative number
among the 3 integers, so that using this negative number in the first addition
will avoid an integer overflow. So the user can write:

int f (int a, int b, int c)
{
  if (b < 0)
    return a + b + c;
  else
    return a + c + b;
}

The generated code with -O3 has 6 instructions:

        leal    (%rdi,%rdx), %eax
        addl    %esi, %edi
        addl    %edx, %edi
        addl    %esi, %eax
        testl   %esi, %esi
        cmovs   %edi, %eax

In theory, the compiler could normally optimize to produce the same code as
with the source that assumes -fwrapv (here, a + b + c and a + c + b are
obviously equivalent on a typical processor), but in practice, this is often
not the case as shown above.