Hi Vlad,
While debugging a slightly modified version of the test case in PR16458:
int
foo (unsigned int a, unsigned int b)
{
if (a == b) return 1;
if (a> b) return 2;
if (a< b) return 3;
if (a != b) return 4;
return 0;
}
I noticed a couple of ugly code gen warts which I tracked back to IRA.
Namely, compiling the above with -O2 -m32 on powerpc64-linux, I'm seeing:
li 9,3
mr 3,9
blr
and:
li 9,1
mr 3,9
blr
If we look at the rtl just before IRA, we have the following:
BB2:
(set (reg/v:SI 122 [ a ]) (reg:SI 3 3 [ a ])) REG_DEAD (reg:SI 3 3 [ a ])
(set (reg/v:SI 123 [ b ]) (reg:SI 4 4 [ b ])) REG_DEAD (reg:SI 4 4 [ b ])
(set (reg:CC 124) (compare:CC (reg/v:SI 122 [ a ]) (reg/v:SI 123 [ b ])))
(if_then_else (eq (reg:CC 124) (const_int 0 [0]))
goto BB6;
BB3:
(set (reg:CCUNS 125) (compare:CCUNS (reg/v:SI 122 [ a ]) (reg/v:SI 123 [ b ]))) REG_DEAD (reg/v:SI 123 [ b ])
REG_DEAD (reg/v:SI 122 [ a ])
(set (reg:SI 120 [ D.1379 ]) (const_int 2 [0x2]))
(if_then_else (gtu (reg:CC 124) (const_int 0 [0]))
goto BB8;
BB4:
(if_then_else (geu (reg:CC 124) (const_int 0 [0]))
goto BB7;
BB5:
(set (reg:SI 120 [ D.1379 ]) (const_int 3 [0x3]))
goto BB8;
BB6:
(set (reg:SI 120 [ D.1379 ]) (const_int 1 [0x1]))
goto BB8;
BB7:
(set (reg:SI 120 [ D.1379 ]) (const_int 4 [0x4]))
BB8:
(set (reg/i:SI 3 3) (reg:SI 120 [ D.1379 ])) REG_DEAD (reg:SI 120 [ D.1379 ])
(use (reg/i:SI 3 3))
return
When we start coloring the allocnos, we get the following:
Pass 1 for finding pseudo/allocno costs
r125: preferred CR_REGS, ...
r124: preferred CR_REGS, ...
r123: preferred GENERAL_REGS, ...
r122: preferred GENERAL_REGS, ...
r120: preferred GENERAL_REGS, ...
...
Popping a3(r122,l0) -- assign reg 3
Popping a2(r123,l0) -- assign reg 4
Popping a0(r120,l0) -- assign reg 9
Popping a4(r124,l0) -- assign reg 75
Popping a1(r125,l0) -- assign reg 3
Assigning 75 to a1r125
This looks a little startling, since we're initially assigning r125 to r3,
even though it's preferred class is CR_REGS before improve_allocation()
saves us and reassigns r125 to r75 (a real CR reg). The reason r125
ends up initially in r3 is that we detect a "shuffle" copy during the
set of r125, because r122 (and r123) dies in the insn r125 is defined in.
This ends up preferencing the costs for r125, such that it wants r3.
This in turn via ALLOCNO_UPDATED_HARD_REG_COSTS() increases the cost
of assigning r120 to r3, such that r120 ends up with r9 instead, when
we really really want it to get r3.
Ala:
Index: ira-conflicts.c
===================================================================
--- ira-conflicts.c (revision 182936)
+++ ira-conflicts.c (working copy)
@@ -397,6 +397,11 @@ process_regs_for_copy (rtx reg1, rtx reg
enum machine_mode mode;
ira_copy_t cp;
+ if (!constraint_p
+&& reg_preferred_class (REGNO (reg1))
+ != reg_preferred_class (REGNO (reg2)))
+ return false;
+
gcc_assert (REG_SUBREG_P (reg1)&& REG_SUBREG_P (reg2));
only_regs_p = REG_P (reg1)&& REG_P (reg2);
reg1 = go_through_subreg (reg1,&offset1);
Your thoughts?