Tue Aug 15 17:33:05 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+ * calls.c (ECF_SP_DEPRESSED): New macro.
+ (calls_function_1): Treat calling sp-depressed function as alloca.
+ (emit_call_1): Don't adjust SP if calling sp-depressed function.
+ (expand_call): Set ECF_SP_DEPRESSED if TYPE_RETURNS_STACK_DEPRESSED.
+ If sp-depressed, ensure block saves and restores SP.
+ * fold-const.c (extract_muldiv): Only check TYPE_IS_SIZETYPE
+ for INTEGER_TYPE.
+ * function.c (keep_stack_depressed): New function.
+ (thread_prologue_and_epilogue_insns): Call it.
+ * print-tree.c (print_node): Use HOST_WIDE_INT_PRINT_UNSIGNED
+ to print DECL_OFFSET_ALIGN.
+ Print no-force-blk and transparent-union flags properly.
+ * stmt.c (expand_goto_internal): Don't restore stack if last block
+ and function returns with sp depressed.
+ (fixup_gotos): Likewise.
+ (save_stack_pointer): New function, from code in expand_decl.
+ (expand_decl): Call new function.
+ * tree.h (TYPE_IS_SIZETYPE): Call INTEGER_TYPE_CHECK.
+ (TYPE_RETURNS_STACK_DEPRESSED): New macro.
+ (save_stack_pointer): New declaration.
+
* diagnostic.c (fatal_function): New variable.
(set_fatal_function): New function.
(fatal): Call it.
/* Nonzero if this is a call to "pure" function (like const function,
but may read memory. */
#define ECF_PURE 512
+/* Nonzero if this is a call to a function that returns with the stack
+ pointer depressed. */
+#define ECF_SP_DEPRESSED 1024
static void emit_call_1 PARAMS ((rtx, tree, tree, HOST_WIDE_INT,
HOST_WIDE_INT, HOST_WIDE_INT, rtx,
case CALL_EXPR:
if (which == 0)
return 1;
+ else if (TYPE_RETURNS_STACK_DEPRESSED
+ (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
+ return 1;
else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
&& (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
== FUNCTION_DECL)
We restore `inhibit_defer_pop' to that value.
CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
- denote registers used by the called function. */
-
+ denote registers used by the called function. */
+
static void
emit_call_1 (funexp, fndecl, funtype, stack_size, rounded_stack_size,
struct_value_size, next_arg_reg, valreg, old_inhibit_defer_pop,
even if the call has no arguments to pop. */
#if defined (HAVE_call) && defined (HAVE_call_value)
if (HAVE_call && HAVE_call_value && HAVE_call_pop && HAVE_call_value_pop
- && n_popped > 0)
+ && n_popped > 0 && ! (ecf_flags & ECF_SP_DEPRESSED))
#else
if (HAVE_call_pop && HAVE_call_value_pop)
#endif
If returning from the subroutine does pop the args, indicate that the
stack pointer will be changed. */
- if (rounded_stack_size != 0)
+ if (rounded_stack_size != 0 && ! (ecf_flags & ECF_SP_DEPRESSED))
{
if (flag_defer_pop && inhibit_defer_pop == 0
- && !(ecf_flags & (ECF_CONST | ECF_PURE)))
+ && ! (ecf_flags & (ECF_CONST | ECF_PURE)))
pending_stack_adjust += rounded_stack_size;
else
adjust_stack (rounded_stack_size_rtx);
}
/* Return nonzero when tree represent call to longjmp. */
+
int
setjmp_call_p (fndecl)
tree fndecl;
}
/* Detect flags (function attributes) from the function type node. */
+
static int
flags_from_decl_or_type (exp)
tree exp;
{
int flags = 0;
+
/* ??? We can't set IS_MALLOC for function types? */
if (DECL_P (exp))
{
flags |= ECF_NOTHROW;
}
- if (TREE_READONLY (exp) && !TREE_THIS_VOLATILE (exp))
+ if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
flags |= ECF_CONST;
if (TREE_THIS_VOLATILE (exp))
int old_inhibit_defer_pop = inhibit_defer_pop;
int old_stack_allocated;
rtx call_fusage;
- register tree p;
+ register tree p = TREE_OPERAND (exp, 0);
register int i;
/* The alignment of the stack, in bits. */
HOST_WIDE_INT preferred_stack_boundary;
/* If we don't have specific function to call, see if we have a
attributes set in the type. */
else
+ flags |= flags_from_decl_or_type (TREE_TYPE (TREE_TYPE (p)));
+
+ /* Mark if the function returns with the stack pointer depressed. */
+ if (TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (TREE_TYPE (p))))
{
- p = TREE_OPERAND (exp, 0);
- flags |= flags_from_decl_or_type (TREE_TYPE (TREE_TYPE (p)));
+ flags |= ECF_SP_DEPRESSED;
+ flags &= ~ (ECF_PURE | ECF_CONST);
}
#ifdef REG_PARM_STACK_SPACE
/* If size of args is variable or this was a constructor call for a stack
argument, restore saved stack-pointer value. */
- if (old_stack_level)
+ if (old_stack_level && ! (flags & ECF_SP_DEPRESSED))
{
emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
pending_stack_adjust = old_pending_adj;
currently_expanding_call--;
+ /* If this function returns with the stack pointer depressed, ensure
+ this block saves and restores the stack pointer, show it was
+ changed, and adjust for any outgoing arg space. */
+ if (flags & ECF_SP_DEPRESSED)
+ {
+ clear_pending_stack_adjust ();
+ emit_insn (gen_rtx (CLOBBER, VOIDmode, stack_pointer_rtx));
+ emit_move_insn (virtual_stack_dynamic_rtx, stack_pointer_rtx);
+ save_stack_pointer ();
+ }
+
return target;
}
\f
|| TREE_CODE_CLASS (TREE_CODE (op0)) == '2'
|| TREE_CODE_CLASS (TREE_CODE (op0)) == 'e')
&& TREE_UNSIGNED (TREE_TYPE (op0))
- && ! TYPE_IS_SIZETYPE (TREE_TYPE (op0))
+ && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
+ && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
&& (GET_MODE_SIZE (TYPE_MODE (ctype))
> GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
break;
the operation since it will change the result if the original
computation overflowed. */
if (TREE_UNSIGNED (ctype)
- && ! TYPE_IS_SIZETYPE (ctype)
+ && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
&& ctype != type)
break;
this since it will change the result if the original computation
overflowed. */
if ((! TREE_UNSIGNED (ctype)
- || TYPE_IS_SIZETYPE (ctype))
+ || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
&& ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
|| (tcode == MULT_EXPR
&& code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
static void put_addressof_into_stack PARAMS ((rtx, struct hash_table *));
static boolean purge_addressof_1 PARAMS ((rtx *, rtx, int, int,
struct hash_table *));
+#ifdef HAVE_epilogue
+static void keep_stack_depressed PARAMS ((rtx));
+#endif
static int is_addressof PARAMS ((rtx *, void *));
static struct hash_entry *insns_for_mem_newfunc PARAMS ((struct hash_entry *,
struct hash_table *,
}
#endif /* HAVE_return */
+#ifdef HAVE_epilogue
+
+/* Modify SEQ, a SEQUENCE that is part of the epilogue, to no modifications
+ to the stack pointer. */
+
+static void
+keep_stack_depressed (seq)
+ rtx seq;
+{
+ int i;
+ rtx sp_from_reg = 0;
+ int sp_modified_unknown = 0;
+
+ /* If the epilogue is just a single instruction, it's OK as is */
+
+ if (GET_CODE (seq) != SEQUENCE) return;
+
+ /* Scan all insns in SEQ looking for ones that modified the stack
+ pointer. Record if it modified the stack pointer by copying it
+ from the frame pointer or if it modified it in some other way.
+ Then modify any subsequent stack pointer references to take that
+ into account. We start by only allowing SP to be copied from a
+ register (presumably FP) and then be subsequently referenced. */
+
+ for (i = 0; i < XVECLEN (seq, 0); i++)
+ {
+ rtx insn = XVECEXP (seq, 0, i);
+
+ if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
+ continue;
+
+ if (reg_set_p (stack_pointer_rtx, insn))
+ {
+ rtx set = single_set (insn);
+
+ /* If SP is set as a side-effect, we can't support this. */
+ if (set == 0)
+ abort ();
+
+ if (GET_CODE (SET_SRC (set)) == REG)
+ sp_from_reg = SET_SRC (set);
+ else
+ sp_modified_unknown = 1;
+
+ /* Don't allow the SP modification to happen. */
+ PUT_CODE (insn, NOTE);
+ NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
+ NOTE_SOURCE_FILE (insn) = 0;
+ }
+ else if (reg_referenced_p (stack_pointer_rtx, PATTERN (insn)))
+ {
+ if (sp_modified_unknown)
+ abort ();
+
+ else if (sp_from_reg != 0)
+ PATTERN (insn)
+ = replace_rtx (PATTERN (insn), stack_pointer_rtx, sp_from_reg);
+ }
+ }
+}
+#endif
+
/* Generate the prologue and epilogue RTL if the machine supports it. Thread
this into place with notes indicating where the prologue ends and where
the epilogue begins. Update the basic block information when possible. */
epilogue_end = emit_note (NULL, NOTE_INSN_EPILOGUE_BEG);
seq = gen_epilogue ();
+
+ /* If this function returns with the stack depressed, massage
+ the epilogue to actually do that. */
+ if (TYPE_RETURNS_STACK_DEPRESSED (TREE_TYPE (current_function_decl)))
+ keep_stack_depressed (seq);
+
emit_jump_insn (seq);
/* Retain a map of the epilogue insns. */
deleted as dead by flow. */
clear_pending_stack_adjust ();
do_pending_stack_adjust ();
- emit_stack_restore (SAVE_BLOCK, stack_level, NULL_RTX);
+
+ /* Don't do this adjust if it's to the end label and this function
+ is to return with a depressed stack pointer. */
+ if (label == return_label
+ && (TYPE_RETURNS_STACK_DEPRESSED
+ (TREE_TYPE (current_function_decl))))
+ ;
+ else
+ emit_stack_restore (SAVE_BLOCK, stack_level, NULL_RTX);
}
if (body != 0 && DECL_TOO_LATE (body))
/* Restore stack level for the biggest contour that this
jump jumps out of. */
- if (f->stack_level)
+ if (f->stack_level
+ && ! (f->target_rtl == return_label
+ && (TYPE_RETURNS_STACK_DEPRESSED
+ (TREE_TYPE (current_function_decl)))))
emit_stack_restore (SAVE_BLOCK, f->stack_level, f->before_jump);
/* Finish up the sequence containing the insns which implement the
pop_temp_slots ();
}
\f
+/* Generate code to save the stack pointer at the start of the current block
+ and set up to restore it on exit. */
+
+void
+save_stack_pointer ()
+{
+ struct nesting *thisblock = block_stack;
+
+ if (thisblock->data.block.stack_level == 0)
+ {
+ emit_stack_save (thisblock->next ? SAVE_BLOCK : SAVE_FUNCTION,
+ &thisblock->data.block.stack_level,
+ thisblock->data.block.first_insn);
+ stack_block_stack = thisblock;
+ }
+}
+\f
/* Generate RTL for the automatic variable declaration DECL.
(Other kinds of declarations are simply ignored if seen here.) */
/* Record the stack pointer on entry to block, if have
not already done so. */
- if (thisblock->data.block.stack_level == 0)
- {
- do_pending_stack_adjust ();
- emit_stack_save (thisblock->next ? SAVE_BLOCK : SAVE_FUNCTION,
- &thisblock->data.block.stack_level,
- thisblock->data.block.first_insn);
- stack_block_stack = thisblock;
- }
+ do_pending_stack_adjust ();
+ save_stack_pointer ();
/* In function-at-a-time mode, variable_size doesn't expand this,
so do it now. */
/* In an INTEGER_TYPE, it means the type represents a size. We use this
both for validity checking and to permit optimziations that are unsafe
for other types. */
-#define TYPE_IS_SIZETYPE(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
+#define TYPE_IS_SIZETYPE(NODE) \
+ (INTEGER_TYPE_CHECK (NODE)->type.no_force_blk_flag)
+
+/* In a FUNCTION_TYPE, indicates that the function returns with the stack
+ pointer depressed. */
+#define TYPE_RETURNS_STACK_DEPRESSED(NODE) \
+ (FUNCTION_TYPE_CHECK(NODE)->type.no_force_blk_flag)
/* Nonzero in a type considered volatile as a whole. */
#define TYPE_VOLATILE(NODE) ((NODE)->common.volatile_flag)
extern void expand_start_target_temps PARAMS ((void));
extern void expand_end_target_temps PARAMS ((void));
extern void expand_elseif PARAMS ((tree));
+extern void save_stack_pointer PARAMS ((void));
extern void expand_decl PARAMS ((tree));
extern int expand_decl_cleanup PARAMS ((tree, tree));
extern void expand_anon_union_decl PARAMS ((tree, tree, tree));
OSDN Git Service
