We start out with (eq (plus X A) 0):
simplify_comparison (code=EQ, pop0=0xbfd722b4, pop1=0xbfd722b0) at
/home/rask/cvssrc/ia16-gcc/gcc/combine.c:9915
(gdb) call debug_rtx (*pop0)
(plus:SI (reg/v:SI 59 [ b ])
(mem/c/i:SI (reg/f:SI 16 argp) [2 a+0 S4 A32]))
(gdb) call debug_rtx (*pop1)
(const_int 0 [0x0])
We get to line 10534 in combine.c:
/* (eq (plus X A) B) -> (eq X (minus B A)).
Following that, we simplify (eq X (minus 0 A)) to (eq X (neg A)).
I'm not sure (eq X (neg A)) is any better than (eq (plus X A) 0), but the
real problem is that we have two different canonicalizations of three
equivalent expressions at the source code level:
a + b == 0 -> (eq A (neg B))
a == -b -> (eq (neg B) A)
-a == b -> (eq (neg A) B)
I think the first form is actually wrong in not being canonical. From the
internals manual ("Canonicalization of Instructions"):
* For the compare operator, [...]
An operand of neg, not, mult, plus, or minus is made the first
operand under the same conditions as above.
It is not clear exactly what "conditions as above" refers to, but it
seems to me that the rules are such that when possible, NEG will be the
first of two operands.
I want to hear some opinions on which form we should choose as the
canonical one. I'm proposing two forms:
1) (eq (neg X) Y) because the change to simplify_comparison will be simpler.
2) (eq (plus X Y) 0) because that's the least surpricing form and the same
as used for other comparisons, avoiding needless insn pattern duplication.
The arm and i386 back ends implement 1).
The c4x, i386, frv, rs6000, s390, score and sparc back ends implement 2).
The c4x back end also implements the (eq (X (neg Y)) form.
I'm voting for 2). The arm back end nearly implements 2) already. It just
needs an "*addsi3_compare0_scratch" pattern witht the same CCmode as
"*compare_negsi_si". That should be easy.
The target macro CANONICALIZE_COMPARISON can override whatever form is
chosen.
Note that when combining two instructions, of which one is a comparison
of the result of a previous instruction against zero and that result is
still needed after the comparison, combine knows not to mess with the
expression. What's special in this case is that we are really only
interested in the comparison result, so combine goes ahead and does the
simplifications. Unfortunately, the result is an expression which targets
aren't likely to have an instruction pattern for.
--
Rask Ingemann Lambertsen
