[Bug target/54829] bad optimization: sub followed by cmp w/ zero (x86 & ARM)

["rearnsha at gcc dot gnu.org" <gcc-bugzilla at gcc dot gnu dot org>]

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

--- Comment #8 from Richard Earnshaw <rearnsha at gcc dot gnu.org> ---
(In reply to Daniel Santos from comment #7)
> First off, I apologize for my late response here.
> 
> (In reply to comment #5)
> I'm going to respond a little backwards..
> 
> > In fact, on ARM there is no branch instruction that can be used for "> 0" as a
> > side effect of a subtract.  To get the desired effect the code would have to be
> > completely re-arranged to factor out the "< 0" (bmi) and then "== 0" (beq)
> > cases first.
> 
> I'm not an ARM programmer, but I'm looking at my reference book and it would
> appear that BGT would perform a branch of greater than for signed comparison
> and and BHI for unsigned comparison.  Again, convert the subtraction into a
> comparison (subtract, but discard the result) and branch based upon the
> flags (for signed numbers):
> 
>     cmp    r0, r1
>     bgt    .L1
>     bne    .L2
> ;handle equality here
> 

Unfortunately, computers don't to infinite precision arithmetic by default. 
That would perform a different comparison in that it checks that r0 > r1, not
whether r0 - r1 > 0.  The difference, for signed comparisons, is when overflow
occurs.

Consider the case where (in your original code) a has the value INT_MIN (ie
-2147483648) and b has the value 1.

Now clearly a < b and by the normal rules of arithmetic (infinite precision) we
would expect a - b to be less than zero.

However, INT_MIN - 1 cannot be represented in a 32-bit long value and becomes
INT_MAX due to overflow; the result is that for these values a - b > 0!

On ARM and x86, the flag setting that results from a subtract operation is, in
effect a comparison of the original operands, rather than a comparison of the
result; that is on ARM

   subs rd, rn, rm

is equivalent to 

   cmp rn, rm

except that the register rd is not written by the comparison.

Power PC is different: it's subtract and compare instruction really does use
the result of the subtraction to form the comparison.