RFD: what to do about stale REG_EQUAL notes in dead_or_predictable

[Joern RENNECKE]

I wonder what best to do about rtl-optimization/21767.
We sometimes have REG_EQUAL notes that are only true when
the instruction stays exactly where it is, like:

(insn 11 10 12 0 (set (reg:SI 147 t)
       (eq:SI (reg/v:SI 159 [ i ])
           (reg:SI 161))) 1 {cmpeqsi_t} (nil)
   (expr_list:REG_EQUAL (eq:SI (reg/v:SI 159 [ i ])
           (const_int 2345678 [0x23cace]))
       (nil)))

(jump_insn 12 11 37 0 (set (pc)
       (if_then_else (eq (reg:SI 147 t)
               (const_int 0 [0x0]))
           (label_ref 17)
           (pc))) 201 {branch_false} (nil)
   (expr_list:REG_BR_PROB (const_int 7100 [0x1bbc])
       (nil)))
;; End of basic block 0, registers live:
(nil)

;; Start of basic block 1, registers live: (nil)
(note 37 12 14 1 [bb 1] NOTE_INSN_BASIC_BLOCK)

(insn 14 37 15 1 (set (reg/v:SI 160 [ r ])
       (reg/v:SI 159 [ i ])) 168 {movsi_ie} (nil)
   (expr_list:REG_EQUAL (const_int 2345678 [0x23cace])
       (nil)))

if-conversion changes this to

(insn 11 10 14 0 (set (reg:SI 147 t)
       (eq:SI (reg/v:SI 159 [ i ])
           (reg:SI 161))) 1 {cmpeqsi_t} (nil)
   (expr_list:REG_EQUAL (eq:SI (reg/v:SI 159 [ i ])
           (const_int 2345678 [0x23cace]))
       (nil)))

(insn 14 11 12 0 (set (reg/v:SI 160 [ r ])
       (reg/v:SI 159 [ i ])) 168 {movsi_ie} (nil)
   (expr_list:REG_EQUAL (const_int 2345678 [0x23cace])
       (nil)))

(jump_insn 12 14 38 0 (set (pc)
       (if_then_else (ne (reg:SI 147 t)
               (const_int 0 [0x0]))
           (label_ref:SI 21)
           (pc))) 200 {branch_true} (nil)
   (expr_list:REG_BR_PROB (const_int 2900 [0xb54])
       (nil)))
;; End of basic block 0, registers live:
(nil)

so the REG_EQUAL note on insn 14 is no longer true.
In general, if a REG_EQUAL note remains valid is not computable.
(any REG_EQUAL note is trivially valid if its insn is unreachable.)
Even where it is computable, you'd probably need as much complexity
and target-dependent knowledge to prove it as if you were computing
the equality from scratch.

So, I think our main options are to remove all REG_EQUAL notes
of insns that are moved above a branch, or to change the value to reflect
the condition it depends on.  I.e. we could have an UNKNOWN rtx
to describe an unknown value in a REG_EQUAL note (A note
with a bare UNKNOWN value would be meaningless and should be
removed), and then express the note for insn 14 as:

(expr_list:REG_EQUAL (if_then_else (ne (reg:SI 147 t) (const_int 0 [0x0]))
                                                               
(const_int 2345678 [0x23cace]) (unknwon))
(nil))