csa, postreload: Improve csa after recent cselib changes [PR94516]

This patch addresses a missed optimization caused by the cselib changes.
Already in the past postreload could replace sp = sp + const_int with
sp = regxy if regxy already has the right value, but with the cselib
changes it happens several times more often.  It can result in smaller
code, so it seems undesirable to prevent such optimizations, but
unfortunately it can get into the way of stack adjustment coalescing,
where e.g. if we used to have sp = sp + 32; sp = sp - 8;, previously
we'd turn that into sp = sp + 24;, but now postreload optimizes
into sp = r12; sp = sp - 8; and csa gives up.

The patch just adds a REG_EQUAL note when changing sp = sp + const into
sp = reg, where we remember it was actually a stack adjustment by certain
constant, and the combine-stack-adj changes than make use of those REG_EQUAL
notes, together with LR tracking (csa did enable the note problem, just
didn't simulate each insn) so that we can add the needed clobbers etc.
(taken from the other stack adjustment insn).

2020-05-05  Jakub Jelinek  <jakub@redhat.com>

	PR rtl-optimization/94516
	* postreload.c (reload_cse_simplify): When replacing sp = sp + const
	with sp = reg, add REG_EQUAL note with sp + const.
	* combine-stack-adj.c (try_apply_stack_adjustment): Change return
	type from int to bool.  Add LIVE and OTHER_INSN arguments.  Undo
	postreload sp = sp + const to sp = reg optimization if needed and
	possible.
	(combine_stack_adjustments_for_block): Add LIVE argument.  Handle
	reg = sp insn with sp + const REG_EQUAL note.  Adjust
	try_apply_stack_adjustment caller, call
	df_simulate_initialize_forwards and df_simulate_one_insn_forwards.
	(combine_stack_adjustments): Allocate and free LIVE bitmap,
	adjust combine_stack_adjustments_for_block caller.

1 files changed, 19 insertions, 0 deletions

diff --git a/gcc/postreload.c b/gcc/postreload.c
index 8849679..677b824 100644
--- a/gcc/postreload.c
+++ b/gcc/postreload.c
@@ -97,6 +97,16 @@ reload_cse_simplify (rtx_insn *insn, rtx testreg)
   if (NO_FUNCTION_CSE && CALL_P (insn))
     return false;
 
+  /* Remember if this insn has been sp += const_int.  */
+  rtx sp_set = set_for_reg_notes (insn);
+  rtx sp_addend = NULL_RTX;
+  if (sp_set
+      && SET_DEST (sp_set) == stack_pointer_rtx
+      && GET_CODE (SET_SRC (sp_set)) == PLUS
+      && XEXP (SET_SRC (sp_set), 0) == stack_pointer_rtx
+      && CONST_INT_P (XEXP (SET_SRC (sp_set), 1)))
+    sp_addend = XEXP (SET_SRC (sp_set), 1);
+
   if (GET_CODE (body) == SET)
     {
       int count = 0;
@@ -180,6 +190,15 @@ reload_cse_simplify (rtx_insn *insn, rtx testreg)
 	reload_cse_simplify_operands (insn, testreg);
     }
 
+  /* If sp += const_int insn is changed into sp = reg;, add REG_EQUAL
+     note so that the stack_adjustments pass can undo it if beneficial.  */
+  if (sp_addend
+      && SET_DEST (sp_set) == stack_pointer_rtx
+      && REG_P (SET_SRC (sp_set)))
+    set_dst_reg_note (insn, REG_EQUAL,
+		      gen_rtx_PLUS (Pmode, stack_pointer_rtx,
+				    sp_addend), stack_pointer_rtx);
+
 done:
   return (EDGE_COUNT (insn_bb->succs) != insn_bb_succs);
 }