rtx_cost of insns

[Alan Modra <amodra at gmail dot com>]

On Thu, Jun 25, 2015 at 01:28:39PM +0100, Richard Earnshaw wrote:
> Perhaps the best thing to do is to use the OUTER code to spot the
> specific case where you've got a SET and return non-zero in that case.

That's exactly the path I've been following.  It's not as easy as it
sounds..

First, some backends call rtx_cost from their targetm.rtx_costs.
ix86_rtx_costs for instance has this

    case PLUS:
...
	      if (val == 2 || val == 4 || val == 8)
		{
		  *total = cost->lea;
		  *total += rtx_cost (XEXP (XEXP (x, 0), 1),
				      outer_code, opno, speed);
		  *total += rtx_cost (XEXP (XEXP (XEXP (x, 0), 0), 0),
				      outer_code, opno, speed);
		  *total += rtx_cost (XEXP (x, 1), outer_code, opno, speed);
		  return true;
		}
which, when using a non-zero register move cost, results in

Successfully matched this instruction:
(set (reg:DI 198 [ D.74663 ])
    (plus:DI (plus:DI (reg/v/f:DI 172 [ use_entry ])
            (reg:DI 196 [ D.74662 ]))
        (const_int -32 [0xffffffffffffffe0])))
rejecting combination of insns 179 and 180
original costs 6 + 4 = 10
replacement cost 15

So here the x86 backend is calculating the cost of an lea, plus the
cost of (reg:DI 196), plus the cost of (reg/v/f:DI 172), plus the cost
of (const_int -32).  outer_code is SET.  That means we add two
register moves, increasing the overall cost from 7 to 15.

The second problem I've hit is that fwprop.c:should_replace_address
has this:

  /* If the addresses have equivalent cost, prefer the new address
     if it has the highest `set_src_cost'.  That has the potential of
     eliminating the most insns without additional costs, and it
     is the same that cse.c used to do.  */
  if (gain == 0)
    gain = (set_src_cost (new_rtx, VOIDmode, speed)
	    - set_src_cost (old_rtx, VOIDmode, speed));

  return (gain > 0);

If register moves have the same cost as adding a small constant to a
register, then this code no longer replaces a pseudo with its value as
an offset from a base.  I think this particular problem can be fixed
quite simply by "return gain >= 0;", but really, this code, like the
x86 code, is expecting the cost of a register move to be zero.

You'll notice that these example problems are not trying to cost a
whole instruction.  In both cases they want the cost of just a piece
of an instruction, but rtx_cost is called in a way that is
indistinguishable from other code that calls rtx_cost on whole
register move instructions.

The real difficulty is in separating out the whole insn cases from the
partial insn cases.

Note that we already have insn_rtx_cost, and it returns a minimum cost
for a SET, so register move insns get a cost of 1 insn.  However,
despite insn_rtx_cost starting life in combine.c, even combine doesn't
use it in all whole insn cases.  :-(

-- 
Alan Modra
Australia Development Lab, IBM