* flow.c: Update comment.
(notice_stack_pointer_modification): New static function.
(record_volatile_insns): Use it.
(mark_regs_live_at_end): Mark the stack pointer as alive
at the end of the function if current_function_sp_is_unchanging
is set.
(life_analysis_1): Set current_function_sp_is_unchanging.
* function.c: Define it.
(init_function_start): Initialize it.
* output.h: Declare it.
* reorg.c (fill_simple_delay_slots, dbr_schedule): Mark
the stack pointer as alive at the end of the function if
current_function_sp_is_unchanging is set.
* i386.c (ix86_epilogue): Optimize the restoring
of the stack pointer.
From-SVN: r23009
+Sun Oct 11 16:49:15 EDT 1998 John Wehle (john@feith.com)
+
+ * flow.c: Update comment.
+ (notice_stack_pointer_modification): New static function.
+ (record_volatile_insns): Use it.
+ (mark_regs_live_at_end): Mark the stack pointer as alive
+ at the end of the function if current_function_sp_is_unchanging
+ is set.
+ (life_analysis_1): Set current_function_sp_is_unchanging.
+ * function.c: Define it.
+ (init_function_start): Initialize it.
+ * output.h: Declare it.
+ * reorg.c (fill_simple_delay_slots, dbr_schedule): Mark
+ the stack pointer as alive at the end of the function if
+ current_function_sp_is_unchanging is set.
+ * i386.c (ix86_epilogue): Optimize the restoring
+ of the stack pointer.
+
Mon Oct 12 02:03:25 1998 Jason Merrill <jason@yorick.cygnus.com>
* i386/t-cygwin32 (TARGET_LIBGCC2_CFLAGS): Define.
rtx xops[3];
int pic_reg_used = flag_pic && (current_function_uses_pic_offset_table
|| current_function_uses_const_pool);
+ int sp_valid = !frame_pointer_needed || current_function_sp_is_unchanging;
long tsize = get_frame_size ();
/* Compute the number of registers to pop */
|| (regno == PIC_OFFSET_TABLE_REGNUM && pic_reg_used))
nregs++;
- /* sp is often unreliable so we must go off the frame pointer.
-
- In reality, we may not care if sp is unreliable, because we can restore
- the register relative to the frame pointer. In theory, since each move
- is the same speed as a pop, and we don't need the leal, this is faster.
- For now restore multiple registers the old way. */
+ /* sp is often unreliable so we may have to go off the frame pointer. */
offset = - tsize - (nregs * UNITS_PER_WORD);
if (flag_pic || profile_flag || profile_block_flag)
emit_insn (gen_blockage ());
- if (nregs > 1 || ! frame_pointer_needed)
+ /* If we're only restoring one register and sp is not valid then
+ using a move instruction to restore the register since it's
+ less work than reloading sp and popping the register. Otherwise,
+ restore sp (if necessary) and pop the registers. */
+
+ if (nregs > 1 || sp_valid)
{
- if (frame_pointer_needed)
+ if ( !sp_valid )
{
xops[0] = adj_offsettable_operand (AT_BP (QImode), offset);
if (do_rtl)
life_analysis fills in certain vectors containing information about
register usage: reg_n_refs, reg_n_deaths, reg_n_sets, reg_live_length,
- reg_n_calls_crosses and reg_basic_block. */
+ reg_n_calls_crosses and reg_basic_block.
+
+ life_analysis sets current_function_sp_is_unchanging if the function
+ doesn't modify the stack pointer. */
\f
#include "config.h"
#include "system.h"
static void count_reg_sets_1 PROTO ((rtx));
static void count_reg_sets PROTO ((rtx));
static void count_reg_references PROTO ((rtx));
+static void notice_stack_pointer_modification PROTO ((rtx, rtx));
\f
/* Find basic blocks of the current function.
F is the first insn of the function and NREGS the number of register numbers
return 0;
}
+static void
+notice_stack_pointer_modification (x, pat)
+ rtx x;
+ rtx pat ATTRIBUTE_UNUSED;
+{
+ if (x == stack_pointer_rtx
+ /* The stack pointer is only modified indirectly as the result
+ of a push until later in flow. See the comments in rtl.texi
+ regarding Embedded Side-Effects on Addresses. */
+ || (GET_CODE (x) == MEM
+ && (GET_CODE (XEXP (x, 0)) == PRE_DEC
+ || GET_CODE (XEXP (x, 0)) == PRE_INC
+ || GET_CODE (XEXP (x, 0)) == POST_DEC
+ || GET_CODE (XEXP (x, 0)) == POST_INC)
+ && XEXP (XEXP (x, 0), 0) == stack_pointer_rtx))
+ current_function_sp_is_unchanging = 0;
+}
+
/* Record which insns refer to any volatile memory
or for any reason can't be deleted just because they are dead stores.
- Also, delete any insns that copy a register to itself. */
+ Also, delete any insns that copy a register to itself.
+ And see if the stack pointer is modified. */
static void
record_volatile_insns (f)
rtx f;
NOTE_SOURCE_FILE (insn) = 0;
}
}
+
+ /* Check if insn modifies the stack pointer. */
+ if ( current_function_sp_is_unchanging
+ && GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ note_stores (PATTERN (insn), notice_stack_pointer_modification);
}
}
if (! EXIT_IGNORE_STACK
|| (! FRAME_POINTER_REQUIRED
&& ! current_function_calls_alloca
- && flag_omit_frame_pointer))
+ && flag_omit_frame_pointer)
+ || current_function_sp_is_unchanging)
#endif
/* If exiting needs the right stack value,
consider the stack pointer live at the end of the function. */
= (regset *) alloca (n_basic_blocks * sizeof (regset));
init_regset_vector (basic_block_significant, n_basic_blocks, &flow_obstack);
+ /* Assume that the stack pointer is unchanging if alloca hasn't been used.
+ This will be cleared by record_volatile_insns if it encounters an insn
+ which modifies the stack pointer. */
+ current_function_sp_is_unchanging = !current_function_calls_alloca;
+
record_volatile_insns (f);
if (n_basic_blocks > 0)
int current_function_contains_functions;
+/* Nonzero if function being compiled doesn't modify the stack pointer
+ (ignoring the prologue and epilogue). This is only valid after
+ life_analysis has run. */
+
+int current_function_sp_is_unchanging;
+
/* Nonzero if the current function is a thunk (a lightweight function that
just adjusts one of its arguments and forwards to another function), so
we should try to cut corners where we can. */
current_function_has_nonlocal_label = 0;
current_function_has_nonlocal_goto = 0;
current_function_contains_functions = 0;
+ current_function_sp_is_unchanging = 0;
current_function_is_thunk = 0;
current_function_returns_pcc_struct = 0;
extern int current_function_contains_functions;
+/* Nonzero if function being compiled doesn't modify the stack pointer
+ (ignoring the prologue and epilogue). This is only valid after
+ life_analysis has run. */
+
+extern int current_function_sp_is_unchanging;
+
/* Nonzero if the current function returns a pointer type */
extern int current_function_returns_pointer;
SET_HARD_REG_BIT (needed.regs, HARD_FRAME_POINTER_REGNUM);
#endif
#ifdef EXIT_IGNORE_STACK
- if (! EXIT_IGNORE_STACK)
+ if (! EXIT_IGNORE_STACK
+ || current_function_sp_is_unchanging)
#endif
SET_HARD_REG_BIT (needed.regs, STACK_POINTER_REGNUM);
}
SET_HARD_REG_BIT (end_of_function_needs.regs, HARD_FRAME_POINTER_REGNUM);
#endif
#ifdef EXIT_IGNORE_STACK
- if (! EXIT_IGNORE_STACK)
+ if (! EXIT_IGNORE_STACK
+ || current_function_sp_is_unchanging)
#endif
SET_HARD_REG_BIT (end_of_function_needs.regs, STACK_POINTER_REGNUM);
}