[RFA,middle-end/53623] Improve extension elimination

PR53623 is a case where transformations by the tree-ssa optimizers are 
inhibiting the RTL optimizers.

As noted in c#5 we have something like this:

   (set (reg:HI %ax) (mem:HI (whatever)))
   (set (reg:DI %rdx) (sign_extend:DI (reg:HI %ax))
   (set (reg:DI %rax) (zero_extend:DI (reg:QI %al))

The first extension can't be combined with the memory ref by REE because 
the source & destination registers are different.  The second extention 
can't be combined either because of the existence of the first extension.

What we'd really like is something like this:

   (set (reg:DI %rdx) (sign_extend:DI (mem:HI (whatever))))
   (set (reg:DI %rax) (zero_extend:DI (reg:QI %rdx))

Jakub had the idea that we could extend REE to handle elimination of 
extentions where the source and destination registers are not the same. 
  That's precisely what this patch does.

Rather than create the desired form directly, we instead generate this:

   (set (reg:DI %rdx) (sign_extend:DI (mem:HI (whatever))))
   (set (reg:DI %rax) (reg:DI $rdx)
   (set (reg:DI %rax) (zero_extend:DI (reg:QI %rax))

With the structure of REE, that's actually far simpler to generate and 
the hard register copy propagation which runs after REE will propagate 
away the unnecessary copy.

The extension is pretty simple.  First we remove the check that the 
source & destination registers must be the same in 
add_removable_extension.  That gets the first extension on the list of 
things to consider.

combine_reaching_defs has all the checks to ensure this is safe.  When 
the source & destination in the extension are not the same register, we 
require that:

1. There only be one reaching def for the source register of the 
extention.  This means we only have to fix up that single reaching def 
rather than multiple reaching defs.  We could certainly handle multiple 
reaching defs if we felt the need in the future, it's just more work.

2. We require both insns to not have already been modified.  This is 
probably overly conservative too.

3. We require both insns to be in the same block.  This simplifies the 
checks is #4.

4. We require the destination of the extension to be neither set nor 
modified between the memory reference and the extension.

[ All other tests for REE must also be passed, those are additional 
tests for this specific case. ]

Assuming all those tests pass, we allow combination of the extension 
with reaching def statement.  We change the destination of the reaching 
def to be the destination of the extension and delete the now dead 
extension.

The problem is that there may be other uses of the original destination 
of the memory load.  So we copy from the new destination of the load 
back into the old destination of the load.

And it "just works".  It triggers all over the place in a bootstrap.  A 
slightly older version triggered 24000 times during a bootstrap (yes, 
24000).

Bootstrapped and regression tested on x86_64-unknown-linux-gnu. 
Obviously fixes 53623 (P2 regression).  OK for the trunk?

Jeff
* ree.c (combine_set_extension): Handle case where source
	and destination registers in an extension insn are different.
	(combine_reaching_defs): Allow source and destination
	registers in extension to be different under limited
	circumstances.
	(add_removable_extension): Remove restriction that the
	source and destination registers in the extension are the
	same.
	(find_and_remove_re): Emit a copy from the extension's
	destination to its source after the defining insn if
	the source and destination registers are different.

testsuite/

	* gcc.target/i386/pr53623.c: New test.

[RFA,middle-end/53623] Improve extension elimination

Commit Message

Comments

Patch