Re: Subtraction + comparison in one asm instruction?

"Vincent Lefevre" <vincent+news@vinc17.org> writes:
>But gcc (for instance) currently optimizes x + 1 - 1 to x. So,
>under this condition, there is no reason why x - 1 > 0 shouldn't
>be optimized to x > 1 (x being a *signed* integer).


For gcc, x+1-1 gives the same result as x on gcc for all signed
integers x (gcc does not report overflows for signed integers).


In contrast, x-1>0 gives a different result from x>1 if x is the
smallest signed integer. In that case the result of x-1 is undefined
(or implementation-defined or somesuch), so the implementation has the
right to perform this optimization according to the C standard. It's
not clear if it is a good idea, though.


Do you value such an optimization more than being able to get the same
results with and without optimization?


Also, do you want to be able to compile code into its intended
equivalent that is non-standard, but nonetheless exists? Here's an
example that might be affected by the optimization you propose; it
checks if adding n to n1 (giving n2) crosses the boundary between
nlimit-1 and nlimit but does not trigger on signed or unsigned
wraparound (this code assumes wrap-around 2s-complement arithmetics):


/* inputs: int n, n1, nlimit */
int n2;
int olddiff = n1-nlimit;
n2=n1+n;
if ((olddiff^(olddiff+n))>=0 /* the limit is not crossed */
        || (olddiff^n)>=0 /* it is a wrap-around effect */) {
...


You might be able to implement this in fully compliant ANSI C, but it
probably will be longer, and probably will also run slower when
compiled with gcc.


- anton
--
M. Anton Ertl
anton@mips.complang.tuwien.ac.at
http://www.complang.tuwien.ac.at/anton/home.html

Return to the comp.compilers page.
Search the comp.compilers archives again.