| Message ID | 20200915011946.3395-5-amodra@gmail.com |
|---|---|
| State | New |
| Headers | show |
| Series | [RS6000] rs6000_rtx_costs comment | expand |
Hi! This took a while to digest, sorry. On Tue, Sep 15, 2020 at 10:49:42AM +0930, Alan Modra wrote: > + 1) Calls from places like optabs.c:avoid_expensive_constant will > + come here with OUTER_CODE set to an operation such as AND with X > + being a CONST_INT or other CONSTANT_P type. This will be compared > + against set_src_cost, where we'll come here with OUTER_CODE as SET > + and X the same constant. This (and similar) reasons are why I still haven't made set_src_cost based on insn_cost -- it is in some places compared to some rtx_cost. > + 2) Calls from places like combine:distribute_and_simplify_rtx are > + asking whether a possibly quite complex SET_SRC can be implemented > + more cheaply than some other logically equivalent SET_SRC. It is comparing the set_src_cost of two equivalent formulations, yeah. This is one place where set_src_cost can be pretty easily replaced by insn_cost (combine uses that in most other places, already, and that was a quite useful change). > + 3) Calls from places like default_noce_conversion_profitable_p will > + come here via seq_cost and pass the pattern of a SET insn in X. The pattern of the single SET in any instruction that is single_set, yeah. > + Presuming the insn is valid and set_dest a reg, rs6000_rtx_costs > + will next see the SET_SRC. The overall cost should be comparable > + to rs6000_insn_cost since the code is comparing one insn sequence > + (some of which may be costed by insn_cost) against another insn > + sequence. Yes. And our rtx_cost misses incredibly many cases, but most common things are handled okay. > + 4) Calls from places like cprop.c:try_replace_reg will come here > + with OUTER_CODE as INSN, and X either a valid pattern of a SET or > + one where some registers have been replaced with constants. The > + replacements may make the SET invalid, for example if > + (set (reg1) (and (reg2) (const_int 0xfff))) > + replaces reg2 as > + (set (reg1) (and (symbol_ref) (const_int 0xfff))) > + then the replacement can't be implemented in one instruction and > + really the cost should be higher by one instruction. However, > + the cost for invalid insns doesn't matter much except that a > + higher cost may lead to their rejection earlier. Yup. This uses set_rtx_cost, which also ideally will use insn_cost one day. > + 5) fwprop.c:should_replace_address puts yet another wrinkle on this > + function, where we prefer an address calculation that is more > + complex yet has the same address_cost. In this case "more > + complex" is determined by having a higher set_src_cost. So for > + example, if we want a plain (reg) address to be replaced with > + (plus (reg) (const)) when possible then PLUS needs to cost more > + than zero here. */ Maybe it helps if you more prominenty mention set_rtx_cost and set_src_cost? Either way, okay for trunk. Thanks! Segher
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index 523d029800a..5b3c0ee0e8c 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -21133,7 +21133,45 @@ rs6000_cannot_copy_insn_p (rtx_insn *insn) /* Compute a (partial) cost for rtx X. Return true if the complete cost has been computed, and false if subexpressions should be - scanned. In either case, *TOTAL contains the cost result. */ + scanned. In either case, *TOTAL contains the cost result. + + 1) Calls from places like optabs.c:avoid_expensive_constant will + come here with OUTER_CODE set to an operation such as AND with X + being a CONST_INT or other CONSTANT_P type. This will be compared + against set_src_cost, where we'll come here with OUTER_CODE as SET + and X the same constant. + + 2) Calls from places like combine:distribute_and_simplify_rtx are + asking whether a possibly quite complex SET_SRC can be implemented + more cheaply than some other logically equivalent SET_SRC. + + 3) Calls from places like default_noce_conversion_profitable_p will + come here via seq_cost and pass the pattern of a SET insn in X. + Presuming the insn is valid and set_dest a reg, rs6000_rtx_costs + will next see the SET_SRC. The overall cost should be comparable + to rs6000_insn_cost since the code is comparing one insn sequence + (some of which may be costed by insn_cost) against another insn + sequence. + + 4) Calls from places like cprop.c:try_replace_reg will come here + with OUTER_CODE as INSN, and X either a valid pattern of a SET or + one where some registers have been replaced with constants. The + replacements may make the SET invalid, for example if + (set (reg1) (and (reg2) (const_int 0xfff))) + replaces reg2 as + (set (reg1) (and (symbol_ref) (const_int 0xfff))) + then the replacement can't be implemented in one instruction and + really the cost should be higher by one instruction. However, + the cost for invalid insns doesn't matter much except that a + higher cost may lead to their rejection earlier. + + 5) fwprop.c:should_replace_address puts yet another wrinkle on this + function, where we prefer an address calculation that is more + complex yet has the same address_cost. In this case "more + complex" is determined by having a higher set_src_cost. So for + example, if we want a plain (reg) address to be replaced with + (plus (reg) (const)) when possible then PLUS needs to cost more + than zero here. */ static bool rs6000_rtx_costs (rtx x, machine_mode mode, int outer_code,