#include "output.h"
#include "tm_p.h"
+#if !defined FUNCTION_OK_FOR_SIBCALL
+#define FUNCTION_OK_FOR_SIBCALL(DECL) 1
+#endif
+
#if !defined PREFERRED_STACK_BOUNDARY && defined STACK_BOUNDARY
#define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY
#endif
static int calls_function PARAMS ((tree, int));
static int calls_function_1 PARAMS ((tree, int));
+
+#define ECF_IS_CONST 1
+#define ECF_NOTHROW 2
+#define ECF_SIBCALL 4
static void emit_call_1 PARAMS ((rtx, tree, tree, HOST_WIDE_INT,
HOST_WIDE_INT, HOST_WIDE_INT, rtx,
- rtx, int, rtx, int, int));
+ rtx, int, rtx, int));
static void precompute_register_parameters PARAMS ((int,
struct arg_data *,
int *));
static void
emit_call_1 (funexp, fndecl, funtype, stack_size, rounded_stack_size,
struct_value_size, next_arg_reg, valreg, old_inhibit_defer_pop,
- call_fusage, is_const, nothrow)
+ call_fusage, ecf_flags)
rtx funexp;
tree fndecl ATTRIBUTE_UNUSED;
tree funtype ATTRIBUTE_UNUSED;
rtx valreg;
int old_inhibit_defer_pop;
rtx call_fusage;
- int is_const, nothrow;
+ int ecf_flags;
{
rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
#if defined (HAVE_call) && defined (HAVE_call_value)
funexp = memory_address (FUNCTION_MODE, funexp);
#ifndef ACCUMULATE_OUTGOING_ARGS
+#if defined (HAVE_sibcall_pop) && defined (HAVE_sibcall_value_pop)
+ if ((ecf_flags & ECF_SIBCALL)
+ && HAVE_sibcall_pop && HAVE_sibcall_value_pop
+ && (RETURN_POPS_ARGS (fndecl, funtype, stack_size) > 0
+ || stack_size == 0))
+ {
+ rtx n_pop = GEN_INT (RETURN_POPS_ARGS (fndecl, funtype, stack_size));
+ rtx pat;
+
+ /* If this subroutine pops its own args, record that in the call insn
+ if possible, for the sake of frame pointer elimination. */
+
+ if (valreg)
+ pat = gen_sibcall_value_pop (valreg,
+ gen_rtx_MEM (FUNCTION_MODE, funexp),
+ rounded_stack_size_rtx, next_arg_reg,
+ n_pop);
+ else
+ pat = gen_sibcall_pop (gen_rtx_MEM (FUNCTION_MODE, funexp),
+ rounded_stack_size_rtx, next_arg_reg, n_pop);
+
+ emit_call_insn (pat);
+ already_popped = 1;
+ }
+ else
+#endif
+
#if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
/* If the target has "call" or "call_value" insns, then prefer them
if no arguments are actually popped. If the target does not have
#endif
#endif
+#if defined (HAVE_sibcall) && defined (HAVE_sibcall_value)
+ if ((ecf_flags & ECF_SIBCALL)
+ && HAVE_sibcall && HAVE_sibcall_value)
+ {
+ if (valreg)
+ emit_call_insn (gen_sibcall_value (valreg,
+ gen_rtx_MEM (FUNCTION_MODE, funexp),
+ rounded_stack_size_rtx,
+ next_arg_reg, NULL_RTX));
+ else
+ emit_call_insn (gen_sibcall (gen_rtx_MEM (FUNCTION_MODE, funexp),
+ rounded_stack_size_rtx, next_arg_reg,
+ struct_value_size_rtx));
+ }
+ else
+#endif
+
#if defined (HAVE_call) && defined (HAVE_call_value)
if (HAVE_call && HAVE_call_value)
{
CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
/* If this is a const call, then set the insn's unchanging bit. */
- if (is_const)
+ if (ecf_flags & ECF_IS_CONST)
CONST_CALL_P (call_insn) = 1;
/* If this call can't throw, attach a REG_EH_REGION reg note to that
effect. */
- if (nothrow)
+ if (ecf_flags & ECF_NOTHROW)
REG_NOTES (call_insn) = gen_rtx_EXPR_LIST (REG_EH_REGION, const0_rtx,
REG_NOTES (call_insn));
+ SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
+
/* Restore this now, so that we do defer pops for this call's args
if the context of the call as a whole permits. */
inhibit_defer_pop = old_inhibit_defer_pop;
if (rounded_stack_size != 0)
{
- if (flag_defer_pop && inhibit_defer_pop == 0 && !is_const)
+ if (flag_defer_pop && inhibit_defer_pop == 0
+ && !(ecf_flags & ECF_IS_CONST))
pending_stack_adjust += rounded_stack_size;
else
adjust_stack (rounded_stack_size_rtx);
{
#ifdef PREFERRED_STACK_BOUNDARY
preferred_stack_boundary /= BITS_PER_UNIT;
+ if (preferred_stack_boundary < 1)
+ preferred_stack_boundary = 1;
args_size->constant = (((args_size->constant
+ arg_space_so_far
+ pending_stack_adjust
rtx target;
int ignore;
{
+ /* Nonzero if we are currently expanding a call. */
+ static int currently_expanding_call = 0;
+
/* List of actual parameters. */
tree actparms = TREE_OPERAND (exp, 1);
/* RTX for the function to be called. */
rtx funexp;
+ /* Sequence of insns to perform a tail recursive "call". */
+ rtx tail_recursion_insns = NULL_RTX;
+ /* Sequence of insns to perform a normal "call". */
+ rtx normal_call_insns = NULL_RTX;
+ /* Sequence of insns to perform a tail recursive "call". */
+ rtx tail_call_insns = NULL_RTX;
/* Data type of the function. */
tree funtype;
/* Declaration of the function being called,
or 0 if the function is computed (not known by name). */
tree fndecl = 0;
char *name = 0;
+#ifdef ACCUMULATE_OUTGOING_ARGS
rtx before_call;
+#endif
+ rtx insn;
+ int safe_for_reeval;
+ int pass;
/* Register in which non-BLKmode value will be returned,
or 0 if no value or if value is BLKmode. */
rtx old_stack_level = 0;
int old_pending_adj = 0;
int old_inhibit_defer_pop = inhibit_defer_pop;
- rtx call_fusage = 0;
+ rtx call_fusage;
register tree p;
register int i;
-#ifdef PREFERRED_STACK_BOUNDARY
- int preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
-#else
- /* In this case preferred_stack_boundary variable is meaningless.
- It is used only in order to keep ifdef noise down when calling
- compute_argument_block_size. */
- int preferred_stack_boundary = 0;
-#endif
+ int preferred_stack_boundary;
/* The value of the function call can be put in a hard register. But
if -fcheck-memory-usage, code which invokes functions (and thus
mark_addressable (fndecl);
}
+ currently_expanding_call++;
+
+ /* If we're considering tail recursion optimizations, verify that the
+ arguments are safe for re-evaluation. If we can unsave them, wrap
+ each argument in an UNSAVE_EXPR. */
+
+ safe_for_reeval = 0;
+ if (optimize >= 2
+ && currently_expanding_call == 1
+ && stmt_loop_nest_empty ())
+ {
+ /* Verify that each argument is safe for re-evaluation. */
+ for (p = actparms; p; p = TREE_CHAIN (p))
+ if (! safe_for_unsave (TREE_VALUE (p)))
+ break;
+
+ if (p == NULL_TREE)
+ {
+ tree new_actparms = NULL_TREE, q;
+
+ for (p = actparms; p ; p = TREE_CHAIN (p))
+ {
+ tree np = build_tree_list (TREE_PURPOSE (p),
+ unsave_expr (TREE_VALUE (p)));
+ if (new_actparms)
+ TREE_CHAIN (q) = np;
+ else
+ new_actparms = np;
+ q = np;
+ }
+
+ actparms = new_actparms;
+ safe_for_reeval = 1;
+ }
+ }
+
+ /* Generate a tail recursion sequence when calling ourselves. */
+
+ if (safe_for_reeval
+ && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
+ && TREE_OPERAND (TREE_OPERAND (exp, 0), 0) == current_function_decl)
+ {
+ /* We want to emit any pending stack adjustments before the tail
+ recursion "call". That way we know any adjustment after the tail
+ recursion call can be ignored if we indeed use the tail recursion
+ call expansion. */
+ int save_pending_stack_adjust = pending_stack_adjust;
+ rtx last;
+
+ /* Use a new sequence to hold any RTL we generate. We do not even
+ know if we will use this RTL yet. The final decision can not be
+ made until after RTL generation for the entire function is
+ complete. */
+ push_to_sequence (0);
+
+ /* Emit the pending stack adjustments before we expand any arguments. */
+ do_pending_stack_adjust ();
+
+ optimize_tail_recursion (exp, get_last_insn ());
+
+ last = get_last_insn ();
+ tail_recursion_insns = get_insns ();
+ end_sequence ();
+
+ /* If the last insn on the tail recursion sequence is not a
+ BARRIER, then tail recursion optimization failed. */
+ if (last == NULL_RTX || GET_CODE (last) != BARRIER)
+ tail_recursion_insns = NULL_RTX;
+
+ /* Restore the original pending stack adjustment for the sibling and
+ normal call cases below. */
+ pending_stack_adjust = save_pending_stack_adjust;
+ }
+
function_call_count++;
if (fndecl && DECL_NAME (fndecl))
name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
+#ifdef PREFERRED_STACK_BOUNDARY
+ preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
+#else
+ preferred_stack_boundary = STACK_BOUNDARY;
+#endif
+
/* Ensure current function's preferred stack boundary is at least
what we need. We don't have to increase alignment for recursive
functions. */
abort ();
funtype = TREE_TYPE (funtype);
- /* When calling a const function, we must pop the stack args right away,
- so that the pop is deleted or moved with the call. */
- if (is_const)
- NO_DEFER_POP;
+ /* We want to make two insn chains; one for a sibling call, the other
+ for a normal call. We will select one of the two chains after
+ initial RTL generation is complete. */
+ for (pass = 0; pass < 2; pass++)
+ {
+ int sibcall_failure = 0;
+ /* We want to emit ay pending stack adjustments before the tail
+ recursion "call". That way we know any adjustment after the tail
+ recursion call can be ignored if we indeed use the tail recursion
+ call expansion. */
+ int save_pending_stack_adjust;
+ rtx insns;
+ rtx before_call;
- /* Don't let pending stack adjusts add up to too much.
- Also, do all pending adjustments now
- if there is any chance this might be a call to alloca. */
+ if (pass == 0)
+ {
+ /* Various reasons we can not use a sibling call. */
+ if (! safe_for_reeval
+#ifdef HAVE_sibcall_epilogue
+ || ! HAVE_sibcall_epilogue
+#else
+ || 1
+#endif
+ /* The structure value address is used and modified in the
+ loop below. It does not seem worth the effort to save and
+ restore it as a state variable since few optimizable
+ sibling calls will return a structure. */
+ || structure_value_addr != NULL_RTX
+ /* If the register holding the address is a callee saved
+ register, then we lose. We have no way to prevent that,
+ so we only allow calls to named functions. */
+ || fndecl == NULL_TREE
+ || ! FUNCTION_OK_FOR_SIBCALL (fndecl))
+ continue;
- if (pending_stack_adjust >= 32
- || (pending_stack_adjust > 0 && may_be_alloca))
- do_pending_stack_adjust ();
+ /* State variables we need to save and restore between
+ iterations. */
+ save_pending_stack_adjust = pending_stack_adjust;
+ }
- if (profile_arc_flag && fork_or_exec)
- {
- /* A fork duplicates the profile information, and an exec discards
- it. We can't rely on fork/exec to be paired. So write out the
- profile information we have gathered so far, and clear it. */
- emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__bb_fork_func"), 0,
- VOIDmode, 0);
-
- /* ??? When __clone is called with CLONE_VM set, profiling is
- subject to race conditions, just as with multithreaded programs. */
- }
+ /* Other state variables that we must reinitialize each time
+ through the loop (that are not initialized by the loop itself. */
+ argblock = 0;
+ call_fusage = 0;
- /* Push the temporary stack slot level so that we can free any temporaries
- we make. */
- push_temp_slots ();
+ /* Start a new sequence for the normal call case.
- /* Start updating where the next arg would go.
+ From this point on, if the sibling call fails, we want to set
+ sibcall_failure instead of continuing the loop. */
+ start_sequence ();
- On some machines (such as the PA) indirect calls have a different
- calling convention than normal calls. The last argument in
- INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
- or not. */
- INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, (fndecl == 0));
+ /* When calling a const function, we must pop the stack args right away,
+ so that the pop is deleted or moved with the call. */
+ if (is_const)
+ NO_DEFER_POP;
- /* If struct_value_rtx is 0, it means pass the address
- as if it were an extra parameter. */
- if (structure_value_addr && struct_value_rtx == 0)
- {
- /* If structure_value_addr is a REG other than
- virtual_outgoing_args_rtx, we can use always use it. If it
- is not a REG, we must always copy it into a register.
- If it is virtual_outgoing_args_rtx, we must copy it to another
- register in some cases. */
- rtx temp = (GET_CODE (structure_value_addr) != REG
-#ifdef ACCUMULATE_OUTGOING_ARGS
- || (stack_arg_under_construction
- && structure_value_addr == virtual_outgoing_args_rtx)
-#endif
- ? copy_addr_to_reg (structure_value_addr)
- : structure_value_addr);
-
- actparms
- = tree_cons (error_mark_node,
- make_tree (build_pointer_type (TREE_TYPE (funtype)),
- temp),
- actparms);
- structure_value_addr_parm = 1;
- }
+ /* Don't let pending stack adjusts add up to too much.
+ Also, do all pending adjustments now if there is any chance
+ this might be a call to alloca or if we are expanding a sibling
+ call sequence. */
+ if (pending_stack_adjust >= 32
+ || (pending_stack_adjust > 0 && may_be_alloca)
+ || pass == 0)
+ do_pending_stack_adjust ();
- /* Count the arguments and set NUM_ACTUALS. */
- for (p = actparms, i = 0; p; p = TREE_CHAIN (p)) i++;
- num_actuals = i;
-
- /* Compute number of named args.
- Normally, don't include the last named arg if anonymous args follow.
- We do include the last named arg if STRICT_ARGUMENT_NAMING is nonzero.
- (If no anonymous args follow, the result of list_length is actually
- one too large. This is harmless.)
-
- If PRETEND_OUTGOING_VARARGS_NAMED is set and STRICT_ARGUMENT_NAMING is
- zero, this machine will be able to place unnamed args that were passed in
- registers into the stack. So treat all args as named. This allows the
- insns emitting for a specific argument list to be independent of the
- function declaration.
-
- If PRETEND_OUTGOING_VARARGS_NAMED is not set, we do not have any reliable
- way to pass unnamed args in registers, so we must force them into
- memory. */
-
- if ((STRICT_ARGUMENT_NAMING
- || ! PRETEND_OUTGOING_VARARGS_NAMED)
- && TYPE_ARG_TYPES (funtype) != 0)
- n_named_args
- = (list_length (TYPE_ARG_TYPES (funtype))
- /* Don't include the last named arg. */
- - (STRICT_ARGUMENT_NAMING ? 0 : 1)
- /* Count the struct value address, if it is passed as a parm. */
- + structure_value_addr_parm);
- else
- /* If we know nothing, treat all args as named. */
- n_named_args = num_actuals;
+ if (profile_arc_flag && fork_or_exec)
+ {
+ /* A fork duplicates the profile information, and an exec discards
+ it. We can't rely on fork/exec to be paired. So write out the
+ profile information we have gathered so far, and clear it. */
+ /* ??? When Linux's __clone is called with CLONE_VM set, profiling
+ is subject to race conditions, just as with multithreaded
+ programs. */
+
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__bb_fork_func"), 0,
+ VOIDmode, 0);
+ }
- /* Make a vector to hold all the information about each arg. */
- args = (struct arg_data *) alloca (num_actuals * sizeof (struct arg_data));
- bzero ((char *) args, num_actuals * sizeof (struct arg_data));
+ /* Push the temporary stack slot level so that we can free any
+ temporaries we make. */
+ push_temp_slots ();
+
+ /* Start updating where the next arg would go.
+
+ On some machines (such as the PA) indirect calls have a different
+ calling convention than normal calls. The last argument in
+ INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
+ or not. */
+ INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, (fndecl == 0));
+
+ /* If struct_value_rtx is 0, it means pass the address
+ as if it were an extra parameter. */
+ if (structure_value_addr && struct_value_rtx == 0)
+ {
+ /* If structure_value_addr is a REG other than
+ virtual_outgoing_args_rtx, we can use always use it. If it
+ is not a REG, we must always copy it into a register.
+ If it is virtual_outgoing_args_rtx, we must copy it to another
+ register in some cases. */
+ rtx temp = (GET_CODE (structure_value_addr) != REG
+#ifdef ACCUMULATE_OUTGOING_ARGS
+ || (stack_arg_under_construction
+ && structure_value_addr == virtual_outgoing_args_rtx)
+#endif
+ ? copy_addr_to_reg (structure_value_addr)
+ : structure_value_addr);
+
+ actparms
+ = tree_cons (error_mark_node,
+ make_tree (build_pointer_type (TREE_TYPE (funtype)),
+ temp),
+ actparms);
+ structure_value_addr_parm = 1;
+ }
- /* Build up entries inthe ARGS array, compute the size of the arguments
- into ARGS_SIZE, etc. */
- initialize_argument_information (num_actuals, args, &args_size, n_named_args,
- actparms, fndecl, &args_so_far,
- reg_parm_stack_space, &old_stack_level,
- &old_pending_adj, &must_preallocate,
- &is_const);
+ /* Count the arguments and set NUM_ACTUALS. */
+ for (p = actparms, i = 0; p; p = TREE_CHAIN (p)) i++;
+ num_actuals = i;
+
+ /* Compute number of named args.
+ Normally, don't include the last named arg if anonymous args follow.
+ We do include the last named arg if STRICT_ARGUMENT_NAMING is nonzero.
+ (If no anonymous args follow, the result of list_length is actually
+ one too large. This is harmless.)
+
+ If PRETEND_OUTGOING_VARARGS_NAMED is set and STRICT_ARGUMENT_NAMING is
+ zero, this machine will be able to place unnamed args that were
+ passed in registers into the stack. So treat all args as named.
+ This allows the insns emitting for a specific argument list to be
+ independent of the function declaration.
+
+ If PRETEND_OUTGOING_VARARGS_NAMED is not set, we do not have any
+ reliable way to pass unnamed args in registers, so we must force
+ them into memory. */
+
+ if ((STRICT_ARGUMENT_NAMING
+ || ! PRETEND_OUTGOING_VARARGS_NAMED)
+ && TYPE_ARG_TYPES (funtype) != 0)
+ n_named_args
+ = (list_length (TYPE_ARG_TYPES (funtype))
+ /* Don't include the last named arg. */
+ - (STRICT_ARGUMENT_NAMING ? 0 : 1)
+ /* Count the struct value address, if it is passed as a parm. */
+ + structure_value_addr_parm);
+ else
+ /* If we know nothing, treat all args as named. */
+ n_named_args = num_actuals;
+
+ /* Make a vector to hold all the information about each arg. */
+ args = (struct arg_data *) alloca (num_actuals
+ * sizeof (struct arg_data));
+ bzero ((char *) args, num_actuals * sizeof (struct arg_data));
+
+ /* Build up entries inthe ARGS array, compute the size of the arguments
+ into ARGS_SIZE, etc. */
+ initialize_argument_information (num_actuals, args, &args_size,
+ n_named_args, actparms, fndecl,
+ &args_so_far, reg_parm_stack_space,
+ &old_stack_level, &old_pending_adj,
+ &must_preallocate, &is_const);
#ifdef FINAL_REG_PARM_STACK_SPACE
- reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
- args_size.var);
+ reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
+ args_size.var);
#endif
- if (args_size.var)
- {
- /* If this function requires a variable-sized argument list, don't try to
- make a cse'able block for this call. We may be able to do this
- eventually, but it is too complicated to keep track of what insns go
- in the cse'able block and which don't. */
+ if (args_size.var)
+ {
+ /* If this function requires a variable-sized argument list, don't
+ try to make a cse'able block for this call. We may be able to
+ do this eventually, but it is too complicated to keep track of
+ what insns go in the cse'able block and which don't.
- is_const = 0;
- must_preallocate = 1;
- }
+ Also do not make a sibling call. */
- /* Compute the actual size of the argument block required. The variable
- and constant sizes must be combined, the size may have to be rounded,
- and there may be a minimum required size. */
- unadjusted_args_size
- = compute_argument_block_size (reg_parm_stack_space, &args_size,
- preferred_stack_boundary);
-
- /* Now make final decision about preallocating stack space. */
- must_preallocate = finalize_must_preallocate (must_preallocate,
- num_actuals, args, &args_size);
-
- /* If the structure value address will reference the stack pointer, we must
- stabilize it. We don't need to do this if we know that we are not going
- to adjust the stack pointer in processing this call. */
-
- if (structure_value_addr
- && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
- || reg_mentioned_p (virtual_outgoing_args_rtx, structure_value_addr))
- && (args_size.var
+ is_const = 0;
+ must_preallocate = 1;
+ sibcall_failure = 1;
+ }
+
+ /* Compute the actual size of the argument block required. The variable
+ and constant sizes must be combined, the size may have to be rounded,
+ and there may be a minimum required size. When generating a sibcall
+ pattern, do not round up, since we'll be re-using whatever space our
+ caller provided. */
+ unadjusted_args_size
+ = compute_argument_block_size (reg_parm_stack_space, &args_size,
+ (pass == 0 ? 0
+ : preferred_stack_boundary));
+
+ /* If the callee pops its own arguments, then it must pop exactly
+ the same number of arguments as the current function. */
+ if (RETURN_POPS_ARGS (fndecl, funtype, unadjusted_args_size)
+ != RETURN_POPS_ARGS (current_function_decl,
+ TREE_TYPE (current_function_decl),
+ current_function_args_size))
+ sibcall_failure = 1;
+
+ /* Now make final decision about preallocating stack space. */
+ must_preallocate = finalize_must_preallocate (must_preallocate,
+ num_actuals, args,
+ &args_size);
+
+ /* If the structure value address will reference the stack pointer, we
+ must stabilize it. We don't need to do this if we know that we are
+ not going to adjust the stack pointer in processing this call. */
+
+ if (structure_value_addr
+ && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
+ || reg_mentioned_p (virtual_outgoing_args_rtx,
+ structure_value_addr))
+ && (args_size.var
#ifndef ACCUMULATE_OUTGOING_ARGS
- || args_size.constant
+ || args_size.constant
#endif
- ))
- structure_value_addr = copy_to_reg (structure_value_addr);
+ ))
+ structure_value_addr = copy_to_reg (structure_value_addr);
- /* Precompute any arguments as needed. */
- precompute_arguments (is_const, must_preallocate, num_actuals,
- args, &args_size);
+ /* Precompute any arguments as needed. */
+ precompute_arguments (is_const, must_preallocate, num_actuals,
+ args, &args_size);
- /* Now we are about to start emitting insns that can be deleted
- if a libcall is deleted. */
- if (is_const || is_malloc)
- start_sequence ();
+ /* Now we are about to start emitting insns that can be deleted
+ if a libcall is deleted. */
+ if (is_const || is_malloc)
+ start_sequence ();
- /* If we have no actual push instructions, or shouldn't use them,
- make space for all args right now. */
+ /* If we have no actual push instructions, or shouldn't use them,
+ make space for all args right now. */
- if (args_size.var != 0)
- {
- if (old_stack_level == 0)
+ if (args_size.var != 0)
{
- emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
- old_pending_adj = pending_stack_adjust;
- pending_stack_adjust = 0;
+ if (old_stack_level == 0)
+ {
+ emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
+ old_pending_adj = pending_stack_adjust;
+ pending_stack_adjust = 0;
#ifdef ACCUMULATE_OUTGOING_ARGS
- /* stack_arg_under_construction says whether a stack arg is
- being constructed at the old stack level. Pushing the stack
- gets a clean outgoing argument block. */
- old_stack_arg_under_construction = stack_arg_under_construction;
- stack_arg_under_construction = 0;
+ /* stack_arg_under_construction says whether a stack arg is
+ being constructed at the old stack level. Pushing the stack
+ gets a clean outgoing argument block. */
+ old_stack_arg_under_construction = stack_arg_under_construction;
+ stack_arg_under_construction = 0;
#endif
+ }
+ argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0);
}
- argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0);
- }
- else
- {
- /* Note that we must go through the motions of allocating an argument
- block even if the size is zero because we may be storing args
- in the area reserved for register arguments, which may be part of
- the stack frame. */
+ else
+ {
+ /* Note that we must go through the motions of allocating an argument
+ block even if the size is zero because we may be storing args
+ in the area reserved for register arguments, which may be part of
+ the stack frame. */
- int needed = args_size.constant;
+ int needed = args_size.constant;
- /* Store the maximum argument space used. It will be pushed by
- the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
- checking). */
+ /* Store the maximum argument space used. It will be pushed by
+ the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
+ checking). */
- if (needed > current_function_outgoing_args_size)
- current_function_outgoing_args_size = needed;
+ if (needed > current_function_outgoing_args_size)
+ current_function_outgoing_args_size = needed;
- if (must_preallocate)
- {
+ if (must_preallocate)
+ {
#ifdef ACCUMULATE_OUTGOING_ARGS
- /* Since the stack pointer will never be pushed, it is possible for
- the evaluation of a parm to clobber something we have already
- written to the stack. Since most function calls on RISC machines
- do not use the stack, this is uncommon, but must work correctly.
+ /* Since the stack pointer will never be pushed, it is possible
+ for the evaluation of a parm to clobber something we have
+ already written to the stack. Since most function calls on
+ RISC machines do not use the stack, this is uncommon, but
+ must work correctly.
- Therefore, we save any area of the stack that was already written
- and that we are using. Here we set up to do this by making a new
- stack usage map from the old one. The actual save will be done
- by store_one_arg.
+ Therefore, we save any area of the stack that was already
+ written and that we are using. Here we set up to do this by
+ making a new stack usage map from the old one. The actual
+ save will be done by store_one_arg.
- Another approach might be to try to reorder the argument
- evaluations to avoid this conflicting stack usage. */
+ Another approach might be to try to reorder the argument
+ evaluations to avoid this conflicting stack usage. */
#ifndef OUTGOING_REG_PARM_STACK_SPACE
- /* Since we will be writing into the entire argument area, the
- map must be allocated for its entire size, not just the part that
- is the responsibility of the caller. */
- needed += reg_parm_stack_space;
+ /* Since we will be writing into the entire argument area, the
+ map must be allocated for its entire size, not just the part
+ that is the responsibility of the caller. */
+ needed += reg_parm_stack_space;
#endif
#ifdef ARGS_GROW_DOWNWARD
- highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
- needed + 1);
+ highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
+ needed + 1);
#else
- highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
- needed);
+ highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
+ needed);
#endif
- stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
+ stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
- if (initial_highest_arg_in_use)
- bcopy (initial_stack_usage_map, stack_usage_map,
- initial_highest_arg_in_use);
+ if (initial_highest_arg_in_use)
+ bcopy (initial_stack_usage_map, stack_usage_map,
+ initial_highest_arg_in_use);
- if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
- bzero (&stack_usage_map[initial_highest_arg_in_use],
- highest_outgoing_arg_in_use - initial_highest_arg_in_use);
- needed = 0;
+ if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
+ bzero (&stack_usage_map[initial_highest_arg_in_use],
+ (highest_outgoing_arg_in_use
+ - initial_highest_arg_in_use));
+ needed = 0;
- /* The address of the outgoing argument list must not be copied to a
- register here, because argblock would be left pointing to the
- wrong place after the call to allocate_dynamic_stack_space below.
- */
+ /* The address of the outgoing argument list must not be copied
+ to a register here, because argblock would be left pointing
+ to the wrong place after the call to
+ allocate_dynamic_stack_space below. */
- argblock = virtual_outgoing_args_rtx;
+ argblock = virtual_outgoing_args_rtx;
#else /* not ACCUMULATE_OUTGOING_ARGS */
- if (inhibit_defer_pop == 0)
- {
- /* Try to reuse some or all of the pending_stack_adjust
- to get this space. Maybe we can avoid any pushing. */
- if (needed > pending_stack_adjust)
+ if (inhibit_defer_pop == 0)
{
- needed -= pending_stack_adjust;
- pending_stack_adjust = 0;
+ /* Try to reuse some or all of the pending_stack_adjust
+ to get this space. Maybe we can avoid any pushing. */
+ if (needed > pending_stack_adjust)
+ {
+ needed -= pending_stack_adjust;
+ pending_stack_adjust = 0;
+ }
+ else
+ {
+ pending_stack_adjust -= needed;
+ needed = 0;
+ }
}
+ /* Special case this because overhead of `push_block' in this
+ case is non-trivial. */
+ if (needed == 0)
+ argblock = virtual_outgoing_args_rtx;
else
- {
- pending_stack_adjust -= needed;
- needed = 0;
- }
- }
- /* Special case this because overhead of `push_block' in this
- case is non-trivial. */
- if (needed == 0)
- argblock = virtual_outgoing_args_rtx;
- else
- argblock = push_block (GEN_INT (needed), 0, 0);
-
- /* We only really need to call `copy_to_reg' in the case where push
- insns are going to be used to pass ARGBLOCK to a function
- call in ARGS. In that case, the stack pointer changes value
- from the allocation point to the call point, and hence
- the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well.
- But might as well always do it. */
- argblock = copy_to_reg (argblock);
+ argblock = push_block (GEN_INT (needed), 0, 0);
+
+ /* We only really need to call `copy_to_reg' in the case where
+ push insns are going to be used to pass ARGBLOCK to a function
+ call in ARGS. In that case, the stack pointer changes value
+ from the allocation point to the call point, and hence
+ the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well.
+ But might as well always do it. */
+ argblock = copy_to_reg (argblock);
#endif /* not ACCUMULATE_OUTGOING_ARGS */
+ }
+ }
+
+ /* The argument block when performing a sibling call is the
+ incoming argument block. */
+ if (pass == 0)
+ {
+ rtx temp = plus_constant (arg_pointer_rtx,
+ FIRST_PARM_OFFSET (current_function_decl));
+ argblock = force_reg (Pmode, force_operand (temp, NULL_RTX));
}
- }
#ifdef ACCUMULATE_OUTGOING_ARGS
- /* The save/restore code in store_one_arg handles all cases except one:
- a constructor call (including a C function returning a BLKmode struct)
- to initialize an argument. */
- if (stack_arg_under_construction)
- {
+ /* The save/restore code in store_one_arg handles all cases except one:
+ a constructor call (including a C function returning a BLKmode struct)
+ to initialize an argument. */
+ if (stack_arg_under_construction)
+ {
#ifndef OUTGOING_REG_PARM_STACK_SPACE
- rtx push_size = GEN_INT (reg_parm_stack_space + args_size.constant);
+ rtx push_size = GEN_INT (reg_parm_stack_space + args_size.constant);
#else
- rtx push_size = GEN_INT (args_size.constant);
+ rtx push_size = GEN_INT (args_size.constant);
#endif
- if (old_stack_level == 0)
- {
- emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
- old_pending_adj = pending_stack_adjust;
- pending_stack_adjust = 0;
- /* stack_arg_under_construction says whether a stack arg is
- being constructed at the old stack level. Pushing the stack
- gets a clean outgoing argument block. */
- old_stack_arg_under_construction = stack_arg_under_construction;
- stack_arg_under_construction = 0;
- /* Make a new map for the new argument list. */
- stack_usage_map = (char *)alloca (highest_outgoing_arg_in_use);
- bzero (stack_usage_map, highest_outgoing_arg_in_use);
- highest_outgoing_arg_in_use = 0;
+ if (old_stack_level == 0)
+ {
+ emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
+ old_pending_adj = pending_stack_adjust;
+ pending_stack_adjust = 0;
+ /* stack_arg_under_construction says whether a stack arg is
+ being constructed at the old stack level. Pushing the stack
+ gets a clean outgoing argument block. */
+ old_stack_arg_under_construction = stack_arg_under_construction;
+ stack_arg_under_construction = 0;
+ /* Make a new map for the new argument list. */
+ stack_usage_map = (char *)alloca (highest_outgoing_arg_in_use);
+ bzero (stack_usage_map, highest_outgoing_arg_in_use);
+ highest_outgoing_arg_in_use = 0;
+ }
+ allocate_dynamic_stack_space (push_size, NULL_RTX, BITS_PER_UNIT);
}
- allocate_dynamic_stack_space (push_size, NULL_RTX, BITS_PER_UNIT);
- }
- /* If argument evaluation might modify the stack pointer, copy the
- address of the argument list to a register. */
- for (i = 0; i < num_actuals; i++)
- if (args[i].pass_on_stack)
- {
- argblock = copy_addr_to_reg (argblock);
- break;
- }
+ /* If argument evaluation might modify the stack pointer, copy the
+ address of the argument list to a register. */
+ for (i = 0; i < num_actuals; i++)
+ if (args[i].pass_on_stack)
+ {
+ argblock = copy_addr_to_reg (argblock);
+ break;
+ }
#endif
- compute_argument_addresses (args, argblock, num_actuals);
+ compute_argument_addresses (args, argblock, num_actuals);
#ifdef PUSH_ARGS_REVERSED
#ifdef PREFERRED_STACK_BOUNDARY
- /* If we push args individually in reverse order, perform stack alignment
- before the first push (the last arg). */
- if (args_size.constant != unadjusted_args_size)
- {
- /* When the stack adjustment is pending,
- we get better code by combining the adjustments. */
- if (pending_stack_adjust && !is_const
- && !inhibit_defer_pop)
+ /* If we push args individually in reverse order, perform stack alignment
+ before the first push (the last arg). */
+ if (args_size.constant != unadjusted_args_size)
{
- args_size.constant = (unadjusted_args_size
- + ((pending_stack_adjust + args_size.constant
- + arg_space_so_far
- - unadjusted_args_size)
- % (preferred_stack_boundary / BITS_PER_UNIT)));
- pending_stack_adjust -= args_size.constant - unadjusted_args_size;
- do_pending_stack_adjust ();
- }
- else if (argblock == 0)
- anti_adjust_stack (GEN_INT (args_size.constant - unadjusted_args_size));
- arg_space_so_far += args_size.constant - unadjusted_args_size;
+ /* When the stack adjustment is pending, we get better code
+ by combining the adjustments. */
+ if (pending_stack_adjust && ! is_const
+ && ! inhibit_defer_pop)
+ {
+ args_size.constant = (unadjusted_args_size
+ + ((pending_stack_adjust
+ + args_size.constant
+ + arg_space_so_far
+ - unadjusted_args_size)
+ % (preferred_stack_boundary
+ / BITS_PER_UNIT)));
+ pending_stack_adjust -= (args_size.constant
+ - unadjusted_args_size);
+ do_pending_stack_adjust ();
+ }
+ else if (argblock == 0)
+ anti_adjust_stack (GEN_INT (args_size.constant
+ - unadjusted_args_size));
+ arg_space_so_far += args_size.constant - unadjusted_args_size;
- /* Now that the stack is properly aligned, pops can't safely
- be deferred during the evaluation of the arguments. */
- NO_DEFER_POP;
- }
+ /* Now that the stack is properly aligned, pops can't safely
+ be deferred during the evaluation of the arguments. */
+ NO_DEFER_POP;
+ }
#endif
#endif
- /* Don't try to defer pops if preallocating, not even from the first arg,
- since ARGBLOCK probably refers to the SP. */
- if (argblock)
- NO_DEFER_POP;
+ /* Don't try to defer pops if preallocating, not even from the first arg,
+ since ARGBLOCK probably refers to the SP. */
+ if (argblock)
+ NO_DEFER_POP;
- funexp = rtx_for_function_call (fndecl, exp);
+ funexp = rtx_for_function_call (fndecl, exp);
- /* Figure out the register where the value, if any, will come back. */
- valreg = 0;
- if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
- && ! structure_value_addr)
- {
- if (pcc_struct_value)
- valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
- fndecl, 0);
- else
- valreg = hard_function_value (TREE_TYPE (exp), fndecl, 0);
- }
+ /* Figure out the register where the value, if any, will come back. */
+ valreg = 0;
+ if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
+ && ! structure_value_addr)
+ {
+ if (pcc_struct_value)
+ valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
+ fndecl, 0);
+ else
+ valreg = hard_function_value (TREE_TYPE (exp), fndecl, 0);
+ }
- /* Precompute all register parameters. It isn't safe to compute anything
- once we have started filling any specific hard regs. */
- precompute_register_parameters (num_actuals, args, ®_parm_seen);
+ /* Precompute all register parameters. It isn't safe to compute anything
+ once we have started filling any specific hard regs. */
+ precompute_register_parameters (num_actuals, args, ®_parm_seen);
#if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
-
- /* Save the fixed argument area if it's part of the caller's frame and
- is clobbered by argument setup for this call. */
- save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
- &low_to_save, &high_to_save);
+ /* Save the fixed argument area if it's part of the caller's frame and
+ is clobbered by argument setup for this call. */
+ save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
+ &low_to_save, &high_to_save);
#endif
-
- /* Now store (and compute if necessary) all non-register parms.
- These come before register parms, since they can require block-moves,
- which could clobber the registers used for register parms.
- Parms which have partial registers are not stored here,
- but we do preallocate space here if they want that. */
+ /* Now store (and compute if necessary) all non-register parms.
+ These come before register parms, since they can require block-moves,
+ which could clobber the registers used for register parms.
+ Parms which have partial registers are not stored here,
+ but we do preallocate space here if they want that. */
- for (i = 0; i < num_actuals; i++)
- if (args[i].reg == 0 || args[i].pass_on_stack)
- store_one_arg (&args[i], argblock, may_be_alloca,
- args_size.var != 0, reg_parm_stack_space);
-
- /* If we have a parm that is passed in registers but not in memory
- and whose alignment does not permit a direct copy into registers,
- make a group of pseudos that correspond to each register that we
- will later fill. */
- if (STRICT_ALIGNMENT)
- store_unaligned_arguments_into_pseudos (args, num_actuals);
-
- /* Now store any partially-in-registers parm.
- This is the last place a block-move can happen. */
- if (reg_parm_seen)
- for (i = 0; i < num_actuals; i++)
- if (args[i].partial != 0 && ! args[i].pass_on_stack)
- store_one_arg (&args[i], argblock, may_be_alloca,
- args_size.var != 0, reg_parm_stack_space);
+ for (i = 0; i < num_actuals; i++)
+ if (args[i].reg == 0 || args[i].pass_on_stack)
+ store_one_arg (&args[i], argblock, may_be_alloca,
+ args_size.var != 0, reg_parm_stack_space);
+
+ /* If we have a parm that is passed in registers but not in memory
+ and whose alignment does not permit a direct copy into registers,
+ make a group of pseudos that correspond to each register that we
+ will later fill. */
+ if (STRICT_ALIGNMENT)
+ store_unaligned_arguments_into_pseudos (args, num_actuals);
+
+ /* Now store any partially-in-registers parm.
+ This is the last place a block-move can happen. */
+ if (reg_parm_seen)
+ for (i = 0; i < num_actuals; i++)
+ if (args[i].partial != 0 && ! args[i].pass_on_stack)
+ store_one_arg (&args[i], argblock, may_be_alloca,
+ args_size.var != 0, reg_parm_stack_space);
#ifndef PUSH_ARGS_REVERSED
#ifdef PREFERRED_STACK_BOUNDARY
- /* If we pushed args in forward order, perform stack alignment
- after pushing the last arg. */
- if (argblock == 0)
- anti_adjust_stack (GEN_INT (args_size.constant - unadjusted_args_size));
+ /* If we pushed args in forward order, perform stack alignment
+ after pushing the last arg. */
+ /* ??? Fix for arg_space_so_far. */
+ if (argblock == 0)
+ anti_adjust_stack (GEN_INT (args_size.constant
+ - unadjusted_args_size));
#endif
#endif
- /* If register arguments require space on the stack and stack space
- was not preallocated, allocate stack space here for arguments
- passed in registers. */
+ /* If register arguments require space on the stack and stack space
+ was not preallocated, allocate stack space here for arguments
+ passed in registers. */
#if ! defined(ACCUMULATE_OUTGOING_ARGS) && defined(OUTGOING_REG_PARM_STACK_SPACE)
- if (must_preallocate == 0 && reg_parm_stack_space > 0)
- anti_adjust_stack (GEN_INT (reg_parm_stack_space));
+ if (must_preallocate == 0 && reg_parm_stack_space > 0)
+ anti_adjust_stack (GEN_INT (reg_parm_stack_space));
#endif
- /* Pass the function the address in which to return a structure value. */
- if (structure_value_addr && ! structure_value_addr_parm)
- {
- emit_move_insn (struct_value_rtx,
- force_reg (Pmode,
- force_operand (structure_value_addr,
- NULL_RTX)));
-
- /* Mark the memory for the aggregate as write-only. */
- if (current_function_check_memory_usage)
- emit_library_call (chkr_set_right_libfunc, 1,
- VOIDmode, 3,
- structure_value_addr, Pmode,
- GEN_INT (struct_value_size), TYPE_MODE (sizetype),
- GEN_INT (MEMORY_USE_WO),
- TYPE_MODE (integer_type_node));
-
- if (GET_CODE (struct_value_rtx) == REG)
- use_reg (&call_fusage, struct_value_rtx);
- }
-
- funexp = prepare_call_address (funexp, fndecl, &call_fusage, reg_parm_seen);
-
- load_register_parameters (args, num_actuals, &call_fusage);
-
- /* Perform postincrements before actually calling the function. */
- emit_queue ();
-
- /* Save a pointer to the last insn before the call, so that we can
- later safely search backwards to find the CALL_INSN. */
- before_call = get_last_insn ();
+ /* Pass the function the address in which to return a
+ structure value. */
+ if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
+ {
+ emit_move_insn (struct_value_rtx,
+ force_reg (Pmode,
+ force_operand (structure_value_addr,
+ NULL_RTX)));
+
+ /* Mark the memory for the aggregate as write-only. */
+ if (current_function_check_memory_usage)
+ emit_library_call (chkr_set_right_libfunc, 1,
+ VOIDmode, 3,
+ structure_value_addr, ptr_mode,
+ GEN_INT (struct_value_size),
+ TYPE_MODE (sizetype),
+ GEN_INT (MEMORY_USE_WO),
+ TYPE_MODE (integer_type_node));
+
+ if (GET_CODE (struct_value_rtx) == REG)
+ use_reg (&call_fusage, struct_value_rtx);
+ }
- /* All arguments and registers used for the call must be set up by now! */
+ funexp = prepare_call_address (funexp, fndecl, &call_fusage,
+ reg_parm_seen);
- /* Generate the actual call instruction. */
- emit_call_1 (funexp, fndecl, funtype, unadjusted_args_size,
- args_size.constant, struct_value_size,
- FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
- valreg, old_inhibit_defer_pop, call_fusage, is_const, nothrow);
+ load_register_parameters (args, num_actuals, &call_fusage);
+
+ /* Perform postincrements before actually calling the function. */
+ emit_queue ();
- /* If call is cse'able, make appropriate pair of reg-notes around it.
- Test valreg so we don't crash; may safely ignore `const'
- if return type is void. Disable for PARALLEL return values, because
- we have no way to move such values into a pseudo register. */
- if (is_const && valreg != 0 && GET_CODE (valreg) != PARALLEL)
- {
- rtx note = 0;
- rtx temp = gen_reg_rtx (GET_MODE (valreg));
- rtx insns;
+ /* Save a pointer to the last insn before the call, so that we can
+ later safely search backwards to find the CALL_INSN. */
+ before_call = get_last_insn ();
- /* Mark the return value as a pointer if needed. */
- if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
+ /* All arguments and registers used for the call must be set up by
+ now! */
+
+ /* Generate the actual call instruction. */
+ emit_call_1 (funexp, fndecl, funtype, unadjusted_args_size,
+ args_size.constant, struct_value_size,
+ FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
+ valreg, old_inhibit_defer_pop, call_fusage,
+ ((is_const ? ECF_IS_CONST : 0)
+ | (nothrow ? ECF_NOTHROW : 0)
+ | (pass == 0 ? ECF_SIBCALL : 0)));
+
+ /* If call is cse'able, make appropriate pair of reg-notes around it.
+ Test valreg so we don't crash; may safely ignore `const'
+ if return type is void. Disable for PARALLEL return values, because
+ we have no way to move such values into a pseudo register. */
+ if (is_const && valreg != 0 && GET_CODE (valreg) != PARALLEL)
{
- tree pointed_to = TREE_TYPE (TREE_TYPE (exp));
- mark_reg_pointer (temp, TYPE_ALIGN (pointed_to) / BITS_PER_UNIT);
- }
+ rtx note = 0;
+ rtx temp = gen_reg_rtx (GET_MODE (valreg));
+ rtx insns;
- /* Construct an "equal form" for the value which mentions all the
- arguments in order as well as the function name. */
+ /* Mark the return value as a pointer if needed. */
+ if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
+ {
+ tree pointed_to = TREE_TYPE (TREE_TYPE (exp));
+ mark_reg_pointer (temp, TYPE_ALIGN (pointed_to) / BITS_PER_UNIT);
+ }
+
+ /* Construct an "equal form" for the value which mentions all the
+ arguments in order as well as the function name. */
#ifdef PUSH_ARGS_REVERSED
- for (i = 0; i < num_actuals; i++)
- note = gen_rtx_EXPR_LIST (VOIDmode, args[i].initial_value, note);
+ for (i = 0; i < num_actuals; i++)
+ note = gen_rtx_EXPR_LIST (VOIDmode, args[i].initial_value, note);
#else
- for (i = num_actuals - 1; i >= 0; i--)
- note = gen_rtx_EXPR_LIST (VOIDmode, args[i].initial_value, note);
+ for (i = num_actuals - 1; i >= 0; i--)
+ note = gen_rtx_EXPR_LIST (VOIDmode, args[i].initial_value, note);
#endif
- note = gen_rtx_EXPR_LIST (VOIDmode, funexp, note);
-
- insns = get_insns ();
- end_sequence ();
-
- emit_libcall_block (insns, temp, valreg, note);
+ note = gen_rtx_EXPR_LIST (VOIDmode, funexp, note);
- valreg = temp;
- }
- else if (is_const)
- {
- /* Otherwise, just write out the sequence without a note. */
- rtx insns = get_insns ();
-
- end_sequence ();
- emit_insns (insns);
- }
- else if (is_malloc)
- {
- rtx temp = gen_reg_rtx (GET_MODE (valreg));
- rtx last, insns;
+ insns = get_insns ();
+ end_sequence ();
- /* The return value from a malloc-like function is a pointer. */
- if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
- mark_reg_pointer (temp, BIGGEST_ALIGNMENT / BITS_PER_UNIT);
-
- emit_move_insn (temp, valreg);
-
- /* The return value from a malloc-like function can not alias
- anything else. */
- last = get_last_insn ();
- REG_NOTES (last) =
- gen_rtx_EXPR_LIST (REG_NOALIAS, temp, REG_NOTES (last));
+ emit_libcall_block (insns, temp, valreg, note);
+
+ valreg = temp;
+ }
+ else if (is_const)
+ {
+ /* Otherwise, just write out the sequence without a note. */
+ rtx insns = get_insns ();
- /* Write out the sequence. */
- insns = get_insns ();
- end_sequence ();
- emit_insns (insns);
- valreg = temp;
- }
+ end_sequence ();
+ emit_insns (insns);
+ }
+ else if (is_malloc)
+ {
+ rtx temp = gen_reg_rtx (GET_MODE (valreg));
+ rtx last, insns;
+
+ /* The return value from a malloc-like function is a pointer. */
+ if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
+ mark_reg_pointer (temp, BIGGEST_ALIGNMENT / BITS_PER_UNIT);
+
+ emit_move_insn (temp, valreg);
+
+ /* The return value from a malloc-like function can not alias
+ anything else. */
+ last = get_last_insn ();
+ REG_NOTES (last) =
+ gen_rtx_EXPR_LIST (REG_NOALIAS, temp, REG_NOTES (last));
+
+ /* Write out the sequence. */
+ insns = get_insns ();
+ end_sequence ();
+ emit_insns (insns);
+ valreg = temp;
+ }
- /* For calls to `setjmp', etc., inform flow.c it should complain
- if nonvolatile values are live. */
+ /* For calls to `setjmp', etc., inform flow.c it should complain
+ if nonvolatile values are live. For functions that cannot return,
+ inform flow that control does not fall through. */
- if (returns_twice)
- {
- /* The NOTE_INSN_SETJMP note must be emitted immediately after the
- CALL_INSN. Some ports emit more than just a CALL_INSN above, so
- we must search for it here. */
- rtx last = get_last_insn ();
- while (GET_CODE (last) != CALL_INSN)
+ if (returns_twice || is_volatile || is_longjmp || pass == 0)
{
- last = PREV_INSN (last);
- /* There was no CALL_INSN? */
- if (last == before_call)
- abort ();
- }
- emit_note_after (NOTE_INSN_SETJMP, last);
- current_function_calls_setjmp = 1;
- }
+ /* The barrier or NOTE_INSN_SETJMP note must be emitted
+ immediately after the CALL_INSN. Some ports emit more
+ than just a CALL_INSN above, so we must search for it here. */
- if (is_longjmp)
- current_function_calls_longjmp = 1;
+ rtx last = get_last_insn ();
+ while (GET_CODE (last) != CALL_INSN)
+ {
+ last = PREV_INSN (last);
+ /* There was no CALL_INSN? */
+ if (last == before_call)
+ abort ();
+ }
- /* Notice functions that cannot return.
- If optimizing, insns emitted below will be dead.
- If not optimizing, they will exist, which is useful
- if the user uses the `return' command in the debugger. */
+ if (returns_twice)
+ {
+ emit_note_after (NOTE_INSN_SETJMP, last);
+ current_function_calls_setjmp = 1;
+ sibcall_failure = 1;
+ }
+ else
+ emit_barrier_after (last);
+ }
- if (is_volatile || is_longjmp)
- emit_barrier ();
+ if (is_longjmp)
+ current_function_calls_longjmp = 1, sibcall_failure = 1;
- /* If value type not void, return an rtx for the value. */
+ /* If value type not void, return an rtx for the value. */
- /* If there are cleanups to be called, don't use a hard reg as target.
- We need to double check this and see if it matters anymore. */
- if (any_pending_cleanups (1)
- && target && REG_P (target)
- && REGNO (target) < FIRST_PSEUDO_REGISTER)
- target = 0;
+ /* If there are cleanups to be called, don't use a hard reg as target.
+ We need to double check this and see if it matters anymore. */
+ if (any_pending_cleanups (1)
+ && target && REG_P (target)
+ && REGNO (target) < FIRST_PSEUDO_REGISTER)
+ target = 0, sibcall_failure = 1;
- if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
- || ignore)
- {
- target = const0_rtx;
- }
- else if (structure_value_addr)
- {
- if (target == 0 || GET_CODE (target) != MEM)
+ if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
+ || ignore)
{
- target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
- memory_address (TYPE_MODE (TREE_TYPE (exp)),
- structure_value_addr));
- MEM_SET_IN_STRUCT_P (target,
- AGGREGATE_TYPE_P (TREE_TYPE (exp)));
+ target = const0_rtx;
}
- }
- else if (pcc_struct_value)
- {
- /* This is the special C++ case where we need to
- know what the true target was. We take care to
- never use this value more than once in one expression. */
- target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
- copy_to_reg (valreg));
- MEM_SET_IN_STRUCT_P (target, AGGREGATE_TYPE_P (TREE_TYPE (exp)));
- }
- /* Handle calls that return values in multiple non-contiguous locations.
- The Irix 6 ABI has examples of this. */
- else if (GET_CODE (valreg) == PARALLEL)
- {
- int bytes = int_size_in_bytes (TREE_TYPE (exp));
-
- if (target == 0)
+ else if (structure_value_addr)
{
- target = assign_stack_temp (TYPE_MODE (TREE_TYPE (exp)), bytes, 0);
+ if (target == 0 || GET_CODE (target) != MEM)
+ {
+ target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
+ memory_address (TYPE_MODE (TREE_TYPE (exp)),
+ structure_value_addr));
+ MEM_SET_IN_STRUCT_P (target,
+ AGGREGATE_TYPE_P (TREE_TYPE (exp)));
+ }
+ }
+ else if (pcc_struct_value)
+ {
+ /* This is the special C++ case where we need to
+ know what the true target was. We take care to
+ never use this value more than once in one expression. */
+ target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
+ copy_to_reg (valreg));
MEM_SET_IN_STRUCT_P (target, AGGREGATE_TYPE_P (TREE_TYPE (exp)));
- preserve_temp_slots (target);
}
+ /* Handle calls that return values in multiple non-contiguous locations.
+ The Irix 6 ABI has examples of this. */
+ else if (GET_CODE (valreg) == PARALLEL)
+ {
+ int bytes = int_size_in_bytes (TREE_TYPE (exp));
- if (! rtx_equal_p (target, valreg))
- emit_group_store (target, valreg, bytes,
- TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
- }
- else if (target && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
- && GET_MODE (target) == GET_MODE (valreg))
- /* TARGET and VALREG cannot be equal at this point because the latter
- would not have REG_FUNCTION_VALUE_P true, while the former would if
- it were referring to the same register.
-
- If they refer to the same register, this move will be a no-op, except
- when function inlining is being done. */
- emit_move_insn (target, valreg);
- else if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
- target = copy_blkmode_from_reg (target, valreg, TREE_TYPE (exp));
- else
- target = copy_to_reg (valreg);
+ if (target == 0)
+ {
+ target = assign_stack_temp (TYPE_MODE (TREE_TYPE (exp)),
+ bytes, 0);
+ MEM_SET_IN_STRUCT_P (target, AGGREGATE_TYPE_P (TREE_TYPE (exp)));
+ preserve_temp_slots (target);
+ }
+
+ if (! rtx_equal_p (target, valreg))
+ emit_group_store (target, valreg, bytes,
+ TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
+ /* We can not support sibling calls for this case. */
+ sibcall_failure = 1;
+ }
+ else if (target
+ && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
+ && GET_MODE (target) == GET_MODE (valreg))
+ {
+ /* TARGET and VALREG cannot be equal at this point because the
+ latter would not have REG_FUNCTION_VALUE_P true, while the
+ former would if it were referring to the same register.
+
+ If they refer to the same register, this move will be a no-op,
+ except when function inlining is being done. */
+ emit_move_insn (target, valreg);
+ }
+ else if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
+ target = copy_blkmode_from_reg (target, valreg, TREE_TYPE (exp));
+ else
+ target = copy_to_reg (valreg);
#ifdef PROMOTE_FUNCTION_RETURN
- /* If we promoted this return value, make the proper SUBREG. TARGET
- might be const0_rtx here, so be careful. */
- if (GET_CODE (target) == REG
- && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
- && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
- {
- tree type = TREE_TYPE (exp);
- int unsignedp = TREE_UNSIGNED (type);
+ /* If we promoted this return value, make the proper SUBREG. TARGET
+ might be const0_rtx here, so be careful. */
+ if (GET_CODE (target) == REG
+ && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
+ && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
+ {
+ tree type = TREE_TYPE (exp);
+ int unsignedp = TREE_UNSIGNED (type);
- /* If we don't promote as expected, something is wrong. */
- if (GET_MODE (target)
- != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
- abort ();
+ /* If we don't promote as expected, something is wrong. */
+ if (GET_MODE (target)
+ != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
+ abort ();
- target = gen_rtx_SUBREG (TYPE_MODE (type), target, 0);
- SUBREG_PROMOTED_VAR_P (target) = 1;
- SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp;
- }
+ target = gen_rtx_SUBREG (TYPE_MODE (type), target, 0);
+ SUBREG_PROMOTED_VAR_P (target) = 1;
+ SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp;
+ }
#endif
- /* If size of args is variable or this was a constructor call for a stack
- argument, restore saved stack-pointer value. */
+ /* 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)
- {
- emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
- pending_stack_adjust = old_pending_adj;
+ if (old_stack_level)
+ {
+ emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
+ pending_stack_adjust = old_pending_adj;
#ifdef ACCUMULATE_OUTGOING_ARGS
- stack_arg_under_construction = old_stack_arg_under_construction;
- highest_outgoing_arg_in_use = initial_highest_arg_in_use;
- stack_usage_map = initial_stack_usage_map;
+ stack_arg_under_construction = old_stack_arg_under_construction;
+ highest_outgoing_arg_in_use = initial_highest_arg_in_use;
+ stack_usage_map = initial_stack_usage_map;
#endif
- }
+ sibcall_failure = 1;
+ }
#ifdef ACCUMULATE_OUTGOING_ARGS
- else
- {
+ else
+ {
#ifdef REG_PARM_STACK_SPACE
- if (save_area)
- restore_fixed_argument_area (save_area, argblock,
- high_to_save, low_to_save);
+ if (save_area)
+ {
+ restore_fixed_argument_area (save_area, argblock,
+ high_to_save, low_to_save);
+ sibcall_failure = 1;
+ }
#endif
- /* If we saved any argument areas, restore them. */
- for (i = 0; i < num_actuals; i++)
- if (args[i].save_area)
- {
- enum machine_mode save_mode = GET_MODE (args[i].save_area);
- rtx stack_area
- = gen_rtx_MEM (save_mode,
- memory_address (save_mode,
- XEXP (args[i].stack_slot, 0)));
-
- if (save_mode != BLKmode)
- emit_move_insn (stack_area, args[i].save_area);
- else
- emit_block_move (stack_area, validize_mem (args[i].save_area),
- GEN_INT (args[i].size.constant),
- PARM_BOUNDARY / BITS_PER_UNIT);
- }
+ /* If we saved any argument areas, restore them. */
+ for (i = 0; i < num_actuals; i++)
+ if (args[i].save_area)
+ {
+ enum machine_mode save_mode = GET_MODE (args[i].save_area);
+ rtx stack_area
+ = gen_rtx_MEM (save_mode,
+ memory_address (save_mode,
+ XEXP (args[i].stack_slot, 0)));
+
+ if (save_mode != BLKmode)
+ emit_move_insn (stack_area, args[i].save_area);
+ else
+ emit_block_move (stack_area,
+ validize_mem (args[i].save_area),
+ GEN_INT (args[i].size.constant),
+ PARM_BOUNDARY / BITS_PER_UNIT);
+ sibcall_failure = 1;
+ }
- highest_outgoing_arg_in_use = initial_highest_arg_in_use;
- stack_usage_map = initial_stack_usage_map;
- }
+ highest_outgoing_arg_in_use = initial_highest_arg_in_use;
+ stack_usage_map = initial_stack_usage_map;
+ }
#endif
- /* If this was alloca, record the new stack level for nonlocal gotos.
- Check for the handler slots since we might not have a save area
- for non-local gotos. */
+ /* If this was alloca, record the new stack level for nonlocal gotos.
+ Check for the handler slots since we might not have a save area
+ for non-local gotos. */
- if (may_be_alloca && nonlocal_goto_handler_slots != 0)
- emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
+ if (may_be_alloca && nonlocal_goto_handler_slots != 0)
+ emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
- pop_temp_slots ();
+ pop_temp_slots ();
+
+ /* Free up storage we no longer need. */
+ for (i = 0; i < num_actuals; ++i)
+ if (args[i].aligned_regs)
+ free (args[i].aligned_regs);
+
+ insns = get_insns ();
+ end_sequence ();
+
+ if (pass == 0)
+ {
+ tail_call_insns = insns;
+
+ /* If the current function's argument block is not large enough
+ to hold the outoing arguments, or we encountered some other
+ situation we couldn't handle, zero out the sequence. */
+ if (current_function_args_size < args_size.constant
+ || sibcall_failure)
+ tail_call_insns = NULL_RTX;
+
+ /* Restore the pending stack adjustment now that we have
+ finished generating the sibling call sequence. */
+ pending_stack_adjust = save_pending_stack_adjust;
+ }
+ else
+ normal_call_insns = insns;
+ }
+
+ /* The function optimize_sibling_and_tail_recursive_calls doesn't
+ handle CALL_PLACEHOLDERs inside other CALL_PLACEHOLDERs. This
+ can happen if the arguments to this function call an inline
+ function who's expansion contains another CALL_PLACEHOLDER.
+
+ If there are any C_Ps in any of these sequences, replace them
+ with their normal call. */
+
+ for (insn = normal_call_insns; insn; insn = NEXT_INSN (insn))
+ if (GET_CODE (insn) == CALL_INSN
+ && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
+ replace_call_placeholder (insn, sibcall_use_normal);
+
+ for (insn = tail_call_insns; insn; insn = NEXT_INSN (insn))
+ if (GET_CODE (insn) == CALL_INSN
+ && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
+ replace_call_placeholder (insn, sibcall_use_normal);
+
+ for (insn = tail_recursion_insns; insn; insn = NEXT_INSN (insn))
+ if (GET_CODE (insn) == CALL_INSN
+ && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
+ replace_call_placeholder (insn, sibcall_use_normal);
+
+ /* If this was a potential tail recursion site, then emit a
+ CALL_PLACEHOLDER with the normal and the tail recursion streams.
+ One of them will be selected later. */
+ if (tail_recursion_insns || tail_call_insns)
+ {
+ /* The tail recursion label must be kept around. We could expose
+ its use in the CALL_PLACEHOLDER, but that creates unwanted edges
+ and makes determining true tail recursion sites difficult.
+
+ So we set LABEL_PRESERVE_P here, then clear it when we select
+ one of the call sequences after rtl generation is complete. */
+ if (tail_recursion_insns)
+ LABEL_PRESERVE_P (tail_recursion_label) = 1;
+ emit_call_insn (gen_rtx_CALL_PLACEHOLDER (VOIDmode, normal_call_insns,
+ tail_call_insns,
+ tail_recursion_insns,
+ tail_recursion_label));
+ }
+ else
+ emit_insns (normal_call_insns);
- /* Free up storage we no longer need. */
- for (i = 0; i < num_actuals; ++i)
- if (args[i].aligned_regs)
- free (args[i].aligned_regs);
+ currently_expanding_call--;
return target;
}
original_args_size.constant, args_size.constant, 0,
FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
outmode != VOIDmode ? hard_libcall_value (outmode) : NULL_RTX,
- old_inhibit_defer_pop + 1, call_fusage, no_queue, nothrow);
+ old_inhibit_defer_pop + 1, call_fusage,
+ ((no_queue ? ECF_IS_CONST : 0)
+ | (nothrow ? ECF_NOTHROW : 0)));
pop_temp_slots ();
struct_value_size,
FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
mem_value == 0 ? hard_libcall_value (outmode) : NULL_RTX,
- old_inhibit_defer_pop + 1, call_fusage, is_const, nothrow);
+ old_inhibit_defer_pop + 1, call_fusage,
+ ((is_const ? ECF_IS_CONST : 0)
+ | (nothrow ? ECF_NOTHROW : 0)));
/* Now restore inhibit_defer_pop to its actual original value. */
OK_DEFER_POP;
struct function *all_functions = 0;
/* These arrays record the INSN_UIDs of the prologue and epilogue insns. */
-static int *prologue;
-static int *epilogue;
+static varray_type prologue;
+static varray_type epilogue;
+
+/* Array of INSN_UIDs to hold the INSN_UIDs for each sibcall epilogue
+ in this function. */
+static varray_type sibcall_epilogue;
\f
/* In order to evaluate some expressions, such as function calls returning
structures in memory, we need to temporarily allocate stack locations.
static tree round_down PARAMS ((tree, int));
#endif
static rtx round_trampoline_addr PARAMS ((rtx));
+static tree *identify_blocks_1 PARAMS ((rtx, tree *, tree *, tree *));
+static void reorder_blocks_1 PARAMS ((rtx, tree, varray_type *));
static tree blocks_nreverse PARAMS ((tree));
static int all_blocks PARAMS ((tree, tree *));
static tree *get_block_vector PARAMS ((tree, int *));
/* We always define `record_insns' even if its not used so that we
can always export `prologue_epilogue_contains'. */
-static int *record_insns PARAMS ((rtx)) ATTRIBUTE_UNUSED;
-static int contains PARAMS ((rtx, int *));
+static void record_insns PARAMS ((rtx, varray_type *)) ATTRIBUTE_UNUSED;
+static int contains PARAMS ((rtx, varray_type));
#ifdef HAVE_return
static void emit_return_into_block PARAMS ((basic_block));
#endif
rtx first_insn = get_insns ();
struct sequence_stack *stack = seq_stack;
tree rtl_exps = rtl_expr_chain;
+ rtx insn;
/* Must scan all insns for stack-refs that exceed the limit. */
fixup_var_refs_insns (var, promoted_mode, unsignedp, first_insn,
fixup_var_refs_insns (var, promoted_mode, unsignedp, catch_clauses,
0, 0);
end_sequence ();
+
+ /* Scan sequences saved in CALL_PLACEHOLDERS too. */
+ for (insn = first_insn; insn; insn = NEXT_INSN (insn))
+ {
+ if (GET_CODE (insn) == CALL_INSN
+ && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
+ {
+ int i;
+
+ /* Look at the Normal call, sibling call and tail recursion
+ sequences attached to the CALL_PLACEHOLDER. */
+ for (i = 0; i < 3; i++)
+ {
+ rtx seq = XEXP (PATTERN (insn), i);
+ if (seq)
+ {
+ push_to_sequence (seq);
+ fixup_var_refs_insns (var, promoted_mode, unsignedp,
+ seq, 0, 0);
+ XEXP (PATTERN (insn), i) = get_insns ();
+ end_sequence ();
+ }
+ }
+ }
+ }
}
\f
/* REPLACEMENTS is a pointer to a list of the struct fixup_replacement and X is
rtx insns;
{
int n_blocks;
- tree *block_vector;
+ tree *block_vector, *last_block_vector;
tree *block_stack;
- int depth = 0;
- int current_block_number = 1;
- rtx insn;
if (block == 0)
return;
block_vector = get_block_vector (block, &n_blocks);
block_stack = (tree *) xmalloc (n_blocks * sizeof (tree));
+ last_block_vector = identify_blocks_1 (insns, block_vector + 1,
+ block_vector + n_blocks, block_stack);
+
+ /* If we didn't use all of the subblocks, we've misplaced block notes. */
+ /* ??? This appears to happen all the time. Latent bugs elsewhere? */
+ if (0 && last_block_vector != block_vector + n_blocks)
+ abort ();
+
+ free (block_vector);
+ free (block_stack);
+}
+
+/* Subroutine of identify_blocks. Do the block substitution on the
+ insn chain beginning with INSNS. Recurse for CALL_PLACEHOLDER chains.
+
+ BLOCK_STACK is pushed and popped for each BLOCK_BEGIN/BLOCK_END pair.
+ BLOCK_VECTOR is incremented for each block seen. */
+
+static tree *
+identify_blocks_1 (insns, block_vector, end_block_vector, orig_block_stack)
+ rtx insns;
+ tree *block_vector;
+ tree *end_block_vector;
+ tree *orig_block_stack;
+{
+ rtx insn;
+ tree *block_stack = orig_block_stack;
+
for (insn = insns; insn; insn = NEXT_INSN (insn))
- if (GET_CODE (insn) == NOTE)
- {
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
- {
- tree b;
+ {
+ if (GET_CODE (insn) == NOTE)
+ {
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
+ {
+ tree b;
- /* If there are more block notes than BLOCKs, something
- is badly wrong. */
- if (current_block_number == n_blocks)
- abort ();
+ /* If there are more block notes than BLOCKs, something
+ is badly wrong. */
+ if (block_vector == end_block_vector)
+ abort ();
- b = block_vector[current_block_number++];
- NOTE_BLOCK (insn) = b;
- block_stack[depth++] = b;
- }
- else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
- {
- if (depth == 0)
- /* There are more NOTE_INSN_BLOCK_ENDs that
- NOTE_INSN_BLOCK_BEGs. Something is badly wrong. */
- abort ();
+ b = *block_vector++;
+ NOTE_BLOCK (insn) = b;
+ *block_stack++ = b;
+ }
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
+ {
+ /* If there are more NOTE_INSN_BLOCK_ENDs than
+ NOTE_INSN_BLOCK_BEGs, something is badly wrong. */
+ if (block_stack == orig_block_stack)
+ abort ();
- NOTE_BLOCK (insn) = block_stack[--depth];
- }
- }
+ NOTE_BLOCK (insn) = *--block_stack;
+ }
+ }
+ else if (GET_CODE (insn) == CALL_INSN
+ && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
+ {
+ rtx cp = PATTERN (insn);
+
+ block_vector = identify_blocks_1 (XEXP (cp, 0), block_vector,
+ end_block_vector, block_stack);
+ if (XEXP (cp, 1))
+ block_vector = identify_blocks_1 (XEXP (cp, 1), block_vector,
+ end_block_vector, block_stack);
+ if (XEXP (cp, 2))
+ block_vector = identify_blocks_1 (XEXP (cp, 2), block_vector,
+ end_block_vector, block_stack);
+ }
+ }
- free (block_vector);
- free (block_stack);
+ /* If there are more NOTE_INSN_BLOCK_BEGINs than NOTE_INSN_BLOCK_ENDs,
+ something is badly wrong. */
+ if (block_stack != orig_block_stack)
+ abort ();
+
+ return block_vector;
}
/* Given a revised instruction chain, rebuild the tree structure of
rtx insns;
{
tree current_block = block;
- rtx insn;
varray_type block_stack;
if (block == NULL_TREE)
BLOCK_SUBBLOCKS (current_block) = 0;
BLOCK_CHAIN (current_block) = 0;
- for (insn = insns; insn; insn = NEXT_INSN (insn))
- if (GET_CODE (insn) == NOTE)
- {
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
- {
- tree block = NOTE_BLOCK (insn);
- /* If we have seen this block before, copy it. */
- if (TREE_ASM_WRITTEN (block))
- {
- block = copy_node (block);
- NOTE_BLOCK (insn) = block;
- }
- BLOCK_SUBBLOCKS (block) = 0;
- TREE_ASM_WRITTEN (block) = 1;
- BLOCK_SUPERCONTEXT (block) = current_block;
- BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
- BLOCK_SUBBLOCKS (current_block) = block;
- current_block = block;
- VARRAY_PUSH_TREE (block_stack, block);
- }
- else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
- {
- NOTE_BLOCK (insn) = VARRAY_TOP_TREE (block_stack);
- VARRAY_POP (block_stack);
- BLOCK_SUBBLOCKS (current_block)
- = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
- current_block = BLOCK_SUPERCONTEXT (current_block);
- }
- }
+ reorder_blocks_1 (insns, current_block, &block_stack);
BLOCK_SUBBLOCKS (current_block)
= blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
return current_block;
}
+/* Helper function for reorder_blocks. Process the insn chain beginning
+ at INSNS. Recurse for CALL_PLACEHOLDER insns. */
+
+static void
+reorder_blocks_1 (insns, current_block, p_block_stack)
+ rtx insns;
+ tree current_block;
+ varray_type *p_block_stack;
+{
+ rtx insn;
+
+ for (insn = insns; insn; insn = NEXT_INSN (insn))
+ {
+ if (GET_CODE (insn) == NOTE)
+ {
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
+ {
+ tree block = NOTE_BLOCK (insn);
+ /* If we have seen this block before, copy it. */
+ if (TREE_ASM_WRITTEN (block))
+ {
+ block = copy_node (block);
+ NOTE_BLOCK (insn) = block;
+ }
+ BLOCK_SUBBLOCKS (block) = 0;
+ TREE_ASM_WRITTEN (block) = 1;
+ BLOCK_SUPERCONTEXT (block) = current_block;
+ BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
+ BLOCK_SUBBLOCKS (current_block) = block;
+ current_block = block;
+ VARRAY_PUSH_TREE (*p_block_stack, block);
+ }
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
+ {
+ NOTE_BLOCK (insn) = VARRAY_TOP_TREE (*p_block_stack);
+ VARRAY_POP (*p_block_stack);
+ BLOCK_SUBBLOCKS (current_block)
+ = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
+ current_block = BLOCK_SUPERCONTEXT (current_block);
+ }
+ }
+ else if (GET_CODE (insn) == CALL_INSN
+ && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
+ {
+ rtx cp = PATTERN (insn);
+ reorder_blocks_1 (XEXP (cp, 0), current_block, p_block_stack);
+ if (XEXP (cp, 1))
+ reorder_blocks_1 (XEXP (cp, 1), current_block, p_block_stack);
+ if (XEXP (cp, 2))
+ reorder_blocks_1 (XEXP (cp, 2), current_block, p_block_stack);
+ }
+ }
+}
+
/* Reverse the order of elements in the chain T of blocks,
and return the new head of the chain (old last element). */
cfun->preferred_stack_boundary = STACK_BOUNDARY;
#else
cfun->stack_alignment_needed = 0;
+ cfun->preferred_stack_boundary = 0;
#endif
/* Set if a call to setjmp is seen. */
init_function_for_compilation ()
{
reg_renumber = 0;
+
/* No prologue/epilogue insns yet. */
- prologue = epilogue = 0;
+ VARRAY_GROW (prologue, 0);
+ VARRAY_GROW (epilogue, 0);
+ VARRAY_GROW (sibcall_epilogue, 0);
}
/* Indicate that the current function uses extra args
expand_fixups (get_insns ());
}
\f
-/* Create an array that records the INSN_UIDs of INSNS (either a sequence
- or a single insn). */
+/* Extend a vector that records the INSN_UIDs of INSNS (either a
+ sequence or a single insn). */
-static int *
-record_insns (insns)
+static void
+record_insns (insns, vecp)
rtx insns;
+ varray_type *vecp;
{
- int *vec;
-
if (GET_CODE (insns) == SEQUENCE)
{
int len = XVECLEN (insns, 0);
- vec = (int *) oballoc ((len + 1) * sizeof (int));
- vec[len] = 0;
+ int i = VARRAY_SIZE (*vecp);
+
+ VARRAY_GROW (*vecp, i + len);
while (--len >= 0)
- vec[len] = INSN_UID (XVECEXP (insns, 0, len));
+ {
+ VARRAY_INT (*vecp, i) = INSN_UID (XVECEXP (insns, 0, len));
+ ++i;
+ }
}
else
{
- vec = (int *) oballoc (2 * sizeof (int));
- vec[0] = INSN_UID (insns);
- vec[1] = 0;
+ int i = VARRAY_SIZE (*vecp);
+ VARRAY_GROW (*vecp, i + 1);
+ VARRAY_INT (*vecp, i) = INSN_UID (insns);
}
- return vec;
}
/* Determine how many INSN_UIDs in VEC are part of INSN. */
static int
contains (insn, vec)
rtx insn;
- int *vec;
+ varray_type vec;
{
register int i, j;
{
int count = 0;
for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
- for (j = 0; vec[j]; j++)
- if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == vec[j])
+ for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
+ if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == VARRAY_INT (vec, j))
count++;
return count;
}
else
{
- for (j = 0; vec[j]; j++)
- if (INSN_UID (insn) == vec[j])
+ for (j = VARRAY_SIZE (vec) - 1; j >= 0; --j)
+ if (INSN_UID (insn) == VARRAY_INT (vec, j))
return 1;
}
return 0;
prologue_epilogue_contains (insn)
rtx insn;
{
- if (prologue && contains (insn, prologue))
+ if (contains (insn, prologue))
return 1;
- if (epilogue && contains (insn, epilogue))
+ if (contains (insn, epilogue))
return 1;
return 0;
}
+int
+sibcall_epilogue_contains (insn)
+ rtx insn;
+{
+ if (sibcall_epilogue)
+ return contains (insn, sibcall_epilogue);
+ return 0;
+}
+
#ifdef HAVE_return
/* Insert gen_return at the end of block BB. This also means updating
block_for_insn appropriately. */
/* Retain a map of the prologue insns. */
if (GET_CODE (seq) != SEQUENCE)
seq = get_insns ();
- prologue = record_insns (seq);
+ record_insns (seq, &prologue);
emit_note (NULL, NOTE_INSN_PROLOGUE_END);
/* GDB handles `break f' by setting a breakpoint on the first
/* Retain a map of the epilogue insns. */
if (GET_CODE (seq) != SEQUENCE)
seq = get_insns ();
- epilogue = record_insns (seq);
+ record_insns (seq, &epilogue);
seq = gen_sequence ();
end_sequence();
if (insertted)
commit_edge_insertions ();
+
+#ifdef HAVE_sibcall_epilogue
+ /* Emit sibling epilogues before any sibling call sites. */
+ for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next)
+ {
+ basic_block bb = e->src;
+ rtx insn = bb->end;
+ rtx i;
+
+ if (GET_CODE (insn) != CALL_INSN
+ || ! SIBLING_CALL_P (insn))
+ continue;
+
+ start_sequence ();
+ seq = gen_sibcall_epilogue ();
+ end_sequence ();
+
+ i = PREV_INSN (insn);
+ emit_insn_before (seq, insn);
+
+ /* Update the UID to basic block map. */
+ for (i = NEXT_INSN (i); i != insn; i = NEXT_INSN (i))
+ set_block_for_insn (i, bb);
+
+ /* Retain a map of the epilogue insns. Used in life analysis to
+ avoid getting rid of sibcall epilogue insns. */
+ record_insns (seq, &sibcall_epilogue);
+ }
+#endif
}
/* Reposition the prologue-end and epilogue-begin notes after instruction
rtx f ATTRIBUTE_UNUSED;
{
#if defined (HAVE_prologue) || defined (HAVE_epilogue)
- /* Reposition the prologue and epilogue notes. */
- if (n_basic_blocks)
+ int len;
+
+ if ((len = VARRAY_SIZE (prologue)) > 0)
{
- int len;
+ register rtx insn, note = 0;
- if (prologue)
+ /* Scan from the beginning until we reach the last prologue insn.
+ We apparently can't depend on basic_block_{head,end} after
+ reorg has run. */
+ for (insn = f; len && insn; insn = NEXT_INSN (insn))
{
- register rtx insn, note = 0;
-
- /* Scan from the beginning until we reach the last prologue insn.
- We apparently can't depend on basic_block_{head,end} after
- reorg has run. */
- for (len = 0; prologue[len]; len++)
- ;
- for (insn = f; len && insn; insn = NEXT_INSN (insn))
+ if (GET_CODE (insn) == NOTE)
{
- if (GET_CODE (insn) == NOTE)
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
+ note = insn;
+ }
+ else if ((len -= contains (insn, prologue)) == 0)
+ {
+ rtx next;
+ /* Find the prologue-end note if we haven't already, and
+ move it to just after the last prologue insn. */
+ if (note == 0)
{
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
- note = insn;
+ for (note = insn; (note = NEXT_INSN (note));)
+ if (GET_CODE (note) == NOTE
+ && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END)
+ break;
}
- else if ((len -= contains (insn, prologue)) == 0)
- {
- rtx next;
- /* Find the prologue-end note if we haven't already, and
- move it to just after the last prologue insn. */
- if (note == 0)
- {
- for (note = insn; (note = NEXT_INSN (note));)
- if (GET_CODE (note) == NOTE
- && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END)
- break;
- }
- next = NEXT_INSN (note);
+ next = NEXT_INSN (note);
- /* Whether or not we can depend on BLOCK_HEAD,
- attempt to keep it up-to-date. */
- if (BLOCK_HEAD (0) == note)
- BLOCK_HEAD (0) = next;
+ /* Whether or not we can depend on BLOCK_HEAD,
+ attempt to keep it up-to-date. */
+ if (BLOCK_HEAD (0) == note)
+ BLOCK_HEAD (0) = next;
- remove_insn (note);
- add_insn_after (note, insn);
- }
+ remove_insn (note);
+ add_insn_after (note, insn);
}
}
+ }
+
+ if ((len = VARRAY_SIZE (epilogue)) > 0)
+ {
+ register rtx insn, note = 0;
- if (epilogue)
+ /* Scan from the end until we reach the first epilogue insn.
+ We apparently can't depend on basic_block_{head,end} after
+ reorg has run. */
+ for (insn = get_last_insn (); len && insn; insn = PREV_INSN (insn))
{
- register rtx insn, note = 0;
-
- /* Scan from the end until we reach the first epilogue insn.
- We apparently can't depend on basic_block_{head,end} after
- reorg has run. */
- for (len = 0; epilogue[len]; len++)
- ;
- for (insn = get_last_insn (); len && insn; insn = PREV_INSN (insn))
+ if (GET_CODE (insn) == NOTE)
{
- if (GET_CODE (insn) == NOTE)
+ if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
+ note = insn;
+ }
+ else if ((len -= contains (insn, epilogue)) == 0)
+ {
+ /* Find the epilogue-begin note if we haven't already, and
+ move it to just before the first epilogue insn. */
+ if (note == 0)
{
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
- note = insn;
+ for (note = insn; (note = PREV_INSN (note));)
+ if (GET_CODE (note) == NOTE
+ && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG)
+ break;
}
- else if ((len -= contains (insn, epilogue)) == 0)
- {
- /* Find the epilogue-begin note if we haven't already, and
- move it to just before the first epilogue insn. */
- if (note == 0)
- {
- for (note = insn; (note = PREV_INSN (note));)
- if (GET_CODE (note) == NOTE
- && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG)
- break;
- }
- /* Whether or not we can depend on BLOCK_HEAD,
- attempt to keep it up-to-date. */
- if (n_basic_blocks
- && BLOCK_HEAD (n_basic_blocks-1) == insn)
- BLOCK_HEAD (n_basic_blocks-1) = note;
+ /* Whether or not we can depend on BLOCK_HEAD,
+ attempt to keep it up-to-date. */
+ if (n_basic_blocks
+ && BLOCK_HEAD (n_basic_blocks-1) == insn)
+ BLOCK_HEAD (n_basic_blocks-1) = note;
- remove_insn (note);
- add_insn_before (note, insn);
- }
+ remove_insn (note);
+ add_insn_before (note, insn);
}
}
}
{
ggc_add_root (&all_functions, 1, sizeof all_functions,
mark_function_chain);
+
+ VARRAY_INT_INIT (prologue, 0, "prologue");
+ VARRAY_INT_INIT (epilogue, 0, "epilogue");
+ VARRAY_INT_INIT (sibcall_epilogue, 0, "sibcall_epilogue");
}
--- /dev/null
+/* Generic sibling call optimization support
+ Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING. If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+#include "config.h"
+#include "system.h"
+
+#include "rtl.h"
+#include "regs.h"
+#include "function.h"
+#include "hard-reg-set.h"
+#include "flags.h"
+#include "insn-config.h"
+#include "recog.h"
+#include "basic-block.h"
+#include "output.h"
+#include "except.h"
+
+static int identify_call_return_value PARAMS ((rtx, rtx *, rtx *));
+static rtx skip_copy_to_return_value PARAMS ((rtx, rtx, rtx));
+static rtx skip_use_of_return_value PARAMS ((rtx, enum rtx_code));
+static rtx skip_stack_adjustment PARAMS ((rtx));
+static rtx skip_jump_insn PARAMS ((rtx));
+static int uses_addressof PARAMS ((rtx));
+static int sequence_uses_addressof PARAMS ((rtx));
+static void purge_reg_equiv_notes PARAMS ((void));
+
+/* Examine a CALL_PLACEHOLDER pattern and determine where the call's
+ return value is located. P_HARD_RETURN receives the hard register
+ that the function used; P_SOFT_RETURN receives the pseudo register
+ that the sequence used. Return non-zero if the values were located. */
+
+static int
+identify_call_return_value (cp, p_hard_return, p_soft_return)
+ rtx cp;
+ rtx *p_hard_return, *p_soft_return;
+{
+ rtx insn, set, hard, soft;
+
+ /* Search forward through the "normal" call sequence to the CALL insn. */
+ insn = XEXP (cp, 0);
+ while (GET_CODE (insn) != CALL_INSN)
+ insn = NEXT_INSN (insn);
+
+ /* Assume the pattern is (set (dest) (call ...)), or that the first
+ member of a parallel is. This is the hard return register used
+ by the function. */
+ if (GET_CODE (PATTERN (insn)) == SET
+ && GET_CODE (SET_SRC (PATTERN (insn))) == CALL)
+ hard = SET_DEST (PATTERN (insn));
+ else if (GET_CODE (PATTERN (insn)) == PARALLEL
+ && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET
+ && GET_CODE (SET_SRC (XVECEXP (PATTERN (insn), 0, 0))) == CALL)
+ hard = SET_DEST (XVECEXP (PATTERN (insn), 0, 0));
+ else
+ return 0;
+
+ /* If we didn't get a single hard register (e.g. a parallel), give up. */
+ if (GET_CODE (hard) != REG)
+ return 0;
+
+ /* If there's nothing after, there's no soft return value. */
+ insn = NEXT_INSN (insn);
+ if (! insn)
+ return 0;
+
+ /* We're looking for a source of the hard return register. */
+ set = single_set (insn);
+ if (! set || SET_SRC (set) != hard)
+ return 0;
+
+ soft = SET_DEST (set);
+ insn = NEXT_INSN (insn);
+
+ /* Allow this first destination to be copied to a second register,
+ as might happen if the first register wasn't the particular pseudo
+ we'd been expecting. */
+ if (insn
+ && (set = single_set (insn)) != NULL_RTX
+ && SET_SRC (set) == soft)
+ {
+ soft = SET_DEST (set);
+ insn = NEXT_INSN (insn);
+ }
+
+ /* Don't fool with anything but pseudo registers. */
+ if (GET_CODE (soft) != REG || REGNO (soft) < FIRST_PSEUDO_REGISTER)
+ return 0;
+
+ /* This value must not be modified before the end of the sequence. */
+ if (reg_set_between_p (soft, insn, NULL_RTX))
+ return 0;
+
+ *p_hard_return = hard;
+ *p_soft_return = soft;
+
+ return 1;
+}
+
+/* If the first real insn after ORIG_INSN copies to this function's
+ return value from RETVAL, then return the insn which performs the
+ copy. Otherwise return ORIG_INSN. */
+
+static rtx
+skip_copy_to_return_value (orig_insn, hardret, softret)
+ rtx orig_insn;
+ rtx hardret, softret;
+{
+ rtx insn, set = NULL_RTX;
+
+ insn = next_nonnote_insn (orig_insn);
+ if (! insn)
+ return orig_insn;
+
+ set = single_set (insn);
+ if (! set)
+ return orig_insn;
+
+ /* The destination must be the same as the called function's return
+ value to ensure that any return value is put in the same place by the
+ current function and the function we're calling.
+
+ Further, the source must be the same as the pseudo into which the
+ called function's return value was copied. Otherwise we're returning
+ some other value. */
+
+ if (SET_DEST (set) == current_function_return_rtx
+ && REG_P (SET_DEST (set))
+ && REGNO (SET_DEST (set)) == REGNO (hardret)
+ && SET_SRC (set) == softret)
+ return insn;
+
+ /* It did not look like a copy of the return value, so return the
+ same insn we were passed. */
+ return orig_insn;
+}
+
+/* If the first real insn after ORIG_INSN is a CODE of this function's return
+ value, return insn. Otherwise return ORIG_INSN. */
+
+static rtx
+skip_use_of_return_value (orig_insn, code)
+ rtx orig_insn;
+ enum rtx_code code;
+{
+ rtx insn;
+
+ insn = next_nonnote_insn (orig_insn);
+
+ if (insn
+ && GET_CODE (insn) == INSN
+ && GET_CODE (PATTERN (insn)) == code
+ && (XEXP (PATTERN (insn), 0) == current_function_return_rtx
+ || XEXP (PATTERN (insn), 0) == const0_rtx))
+ return insn;
+
+ return orig_insn;
+}
+
+/* If the first real insn after ORIG_INSN adjusts the stack pointer
+ by a constant, return the insn with the stack pointer adjustment.
+ Otherwise return ORIG_INSN. */
+
+static rtx
+skip_stack_adjustment (orig_insn)
+ rtx orig_insn;
+{
+ rtx insn, set = NULL_RTX;
+
+ insn = next_nonnote_insn (orig_insn);
+
+ if (insn)
+ set = single_set (insn);
+
+ /* The source must be the same as the current function's return value to
+ ensure that any return value is put in the same place by the current
+ function and the function we're calling. The destination register
+ must be a pseudo. */
+ if (insn
+ && set
+ && GET_CODE (SET_SRC (set)) == PLUS
+ && XEXP (SET_SRC (set), 0) == stack_pointer_rtx
+ && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT
+ && SET_DEST (set) == stack_pointer_rtx)
+ return insn;
+
+ /* It did not look like a copy of the return value, so return the
+ same insn we were passed. */
+ return orig_insn;
+}
+
+/* If the first real insn after ORIG_INSN is a jump, return the JUMP_INSN.
+ Otherwise return ORIG_INSN. */
+
+static rtx
+skip_jump_insn (orig_insn)
+ rtx orig_insn;
+{
+ rtx insn;
+
+ insn = next_nonnote_insn (orig_insn);
+
+ if (insn
+ && GET_CODE (insn) == JUMP_INSN
+ && simplejump_p (insn))
+ return insn;
+
+ return orig_insn;
+}
+
+/* Scan the rtx X for an ADDRESSOF expressions. Return nonzero if an ADDRESSOF
+ expresion is found, else return zero. */
+
+static int
+uses_addressof (x)
+ rtx x;
+{
+ RTX_CODE code;
+ int i, j;
+ const char *fmt;
+
+ if (x == NULL_RTX)
+ return 0;
+
+ code = GET_CODE (x);
+
+ if (code == ADDRESSOF)
+ return 1;
+
+ /* Scan all subexpressions. */
+ fmt = GET_RTX_FORMAT (code);
+ for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
+ {
+ if (*fmt == 'e')
+ {
+ if (uses_addressof (XEXP (x, i)))
+ return 1;
+ }
+ else if (*fmt == 'E')
+ {
+ for (j = 0; j < XVECLEN (x, i); j++)
+ if (uses_addressof (XVECEXP (x, i, j)))
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* Scan the sequence of insns in SEQ to see if any have an ADDRESSOF
+ rtl expression. If an ADDRESSOF expression is found, return nonzero,
+ else return zero.
+
+ This function handles CALL_PLACEHOLDERs which contain multiple sequences
+ of insns. */
+
+static int
+sequence_uses_addressof (seq)
+ rtx seq;
+{
+ rtx insn;
+
+ for (insn = seq; insn; insn = NEXT_INSN (insn))
+ if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
+ {
+ /* If this is a CALL_PLACEHOLDER, then recursively call ourselves
+ with each nonempty sequence attached to the CALL_PLACEHOLDER. */
+ if (GET_CODE (insn) == CALL_INSN
+ && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
+ {
+ if (XEXP (PATTERN (insn), 0) != NULL_RTX
+ && sequence_uses_addressof (XEXP (PATTERN (insn), 0)))
+ return 1;
+ if (XEXP (PATTERN (insn), 1) != NULL_RTX
+ && sequence_uses_addressof (XEXP (PATTERN (insn), 1)))
+ return 1;
+ if (XEXP (PATTERN (insn), 2) != NULL_RTX
+ && sequence_uses_addressof (XEXP (PATTERN (insn), 2)))
+ return 1;
+ }
+ else if (uses_addressof (PATTERN (insn))
+ || (REG_NOTES (insn) && uses_addressof (REG_NOTES (insn))))
+ return 1;
+ }
+ return 0;
+}
+
+/* Remove all REG_EQUIV notes found in the insn chain. */
+
+static void
+purge_reg_equiv_notes ()
+{
+ rtx insn;
+
+ for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
+ {
+ while (1)
+ {
+ rtx note = find_reg_note (insn, REG_EQUIV, 0);
+ if (note)
+ {
+ /* Remove the note and keep looking at the notes for
+ this insn. */
+ remove_note (insn, note);
+ continue;
+ }
+ break;
+ }
+ }
+}
+
+/* Replace the CALL_PLACEHOLDER with one of its children. INSN should be
+ the CALL_PLACEHOLDER insn; USE tells which child to use. */
+
+void
+replace_call_placeholder (insn, use)
+ rtx insn;
+ sibcall_use_t use;
+{
+ if (use == sibcall_use_tail_recursion)
+ emit_insns_before (XEXP (PATTERN (insn), 2), insn);
+ else if (use == sibcall_use_sibcall)
+ emit_insns_before (XEXP (PATTERN (insn), 1), insn);
+ else if (use == sibcall_use_normal)
+ emit_insns_before (XEXP (PATTERN (insn), 0), insn);
+ else
+ abort();
+
+ /* Turn off LABEL_PRESERVE_P for the tail recursion label if it
+ exists. We only had to set it long enough to keep the jump
+ pass above from deleting it as unused. */
+ if (XEXP (PATTERN (insn), 3))
+ LABEL_PRESERVE_P (XEXP (PATTERN (insn), 3)) = 0;
+
+ /* "Delete" the placeholder insn. */
+ PUT_CODE (insn, NOTE);
+ NOTE_SOURCE_FILE (insn) = 0;
+ NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
+}
+
+
+/* Given a (possibly empty) set of potential sibling or tail recursion call
+ sites, determine if optimization is possible.
+
+ Potential sibling or tail recursion calls are marked with CALL_PLACEHOLDER
+ insns. The CALL_PLACEHOLDER insn holds chains of insns to implement a
+ normal call, sibling call or tail recursive call.
+
+ Replace the CALL_PLACEHOLDER with an appropriate insn chain. */
+
+void
+optimize_sibling_and_tail_recursive_calls ()
+{
+ rtx insn, insns;
+ basic_block alternate_exit = EXIT_BLOCK_PTR;
+ int current_function_uses_addressof;
+ int successful_sibling_call = 0;
+ int replaced_call_placeholder = 0;
+ edge e;
+
+ insns = get_insns ();
+
+ /* We do not perform these calls when flag_exceptions is true, so this
+ is probably a NOP at the current time. However, we may want to support
+ sibling and tail recursion optimizations in the future, so let's plan
+ ahead and find all the EH labels. */
+ find_exception_handler_labels ();
+
+ /* Run a jump optimization pass to clean up the CFG. We primarily want
+ this to thread jumps so that it is obvious which blocks jump to the
+ epilouge. */
+ jump_optimize_minimal (insns);
+
+ /* We need cfg information to determine which blocks are succeeded
+ only by the epilogue. */
+ find_basic_blocks (insns, max_reg_num (), 0);
+ cleanup_cfg (insns);
+
+ /* If there are no basic blocks, then there is nothing to do. */
+ if (n_basic_blocks == 0)
+ return;
+
+ /* Find the exit block.
+
+ It is possible that we have blocks which can reach the exit block
+ directly. However, most of the time a block will jump (or fall into)
+ N_BASIC_BLOCKS - 1, which in turn falls into the exit block. */
+ for (e = EXIT_BLOCK_PTR->pred;
+ e && alternate_exit == EXIT_BLOCK_PTR;
+ e = e->pred_next)
+ {
+ rtx insn;
+
+ if (e->dest != EXIT_BLOCK_PTR || e->succ_next != NULL)
+ continue;
+
+ /* Walk forwards through the last normal block and see if it
+ does nothing except fall into the exit block. */
+ for (insn = BLOCK_HEAD (n_basic_blocks - 1);
+ insn;
+ insn = NEXT_INSN (insn))
+ {
+ /* This should only happen once, at the start of this block. */
+ if (GET_CODE (insn) == CODE_LABEL)
+ continue;
+
+ if (GET_CODE (insn) == NOTE)
+ continue;
+
+ if (GET_CODE (insn) == INSN
+ && GET_CODE (PATTERN (insn)) == USE)
+ continue;
+
+ break;
+ }
+
+ /* If INSN is zero, then the search walked all the way through the
+ block without hitting anything interesting. This block is a
+ valid alternate exit block. */
+ if (insn == NULL)
+ alternate_exit = e->src;
+ }
+
+ /* If the function uses ADDRESSOF, we can't (easily) determine
+ at this point if the value will end up on the stack. */
+ current_function_uses_addressof = sequence_uses_addressof (insns);
+
+ /* Walk the insn chain and find any CALL_PLACEHOLDER insns. We need to
+ select one of the insn sequences attached to each CALL_PLACEHOLDER.
+
+ The different sequences represent different ways to implement the call,
+ ie, tail recursion, sibling call or normal call.
+
+ Since we do not create nested CALL_PLACEHOLDERs, the scan
+ continues with the insn that was after a replaced CALL_PLACEHOLDER;
+ we don't rescan the replacement insns. */
+ for (insn = insns; insn; insn = NEXT_INSN (insn))
+ {
+ if (GET_CODE (insn) == CALL_INSN
+ && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
+ {
+ int sibcall = (XEXP (PATTERN (insn), 1) != NULL_RTX);
+ int tailrecursion = (XEXP (PATTERN (insn), 2) != NULL_RTX);
+ basic_block succ_block, call_block;
+ rtx temp, hardret, softret;
+
+ /* We must be careful with stack slots which are live at
+ potential optimization sites.
+
+ ?!? This test is overly conservative and will be replaced. */
+ if (frame_offset)
+ goto failure;
+
+ /* alloca (until we have stack slot life analysis) inhibits
+ sibling call optimizations, but not tail recursion.
+
+ Similarly if we have ADDRESSOF expressions.
+
+ Similarly if we use varargs or stdarg since they implicitly
+ may take the address of an argument. */
+ if (current_function_calls_alloca || current_function_uses_addressof
+ || current_function_varargs || current_function_stdarg)
+ sibcall = 0;
+
+ call_block = BLOCK_FOR_INSN (insn);
+
+ /* If the block has more than one successor, then we can not
+ perform sibcall or tail recursion optimizations. */
+ if (call_block->succ == NULL
+ || call_block->succ->succ_next != NULL)
+ goto failure;
+
+ /* If the single successor is not the exit block, then we can not
+ perform sibcall or tail recursion optimizations.
+
+ Note that this test combined with the previous is sufficient
+ to prevent tail call optimization in the presense of active
+ exception handlers. */
+ succ_block = call_block->succ->dest;
+ if (succ_block != EXIT_BLOCK_PTR && succ_block != alternate_exit)
+ goto failure;
+
+ /* If the call was the end of the block, then we're OK. */
+ temp = insn;
+ if (temp == call_block->end)
+ goto success;
+
+ /* Skip over copying from the call's return value pseudo into
+ this function's hard return register. */
+ if (identify_call_return_value (PATTERN (insn), &hardret, &softret))
+ {
+ temp = skip_copy_to_return_value (temp, hardret, softret);
+ if (temp == call_block->end)
+ goto success;
+ }
+
+ /* Skip any stack adjustment. */
+ temp = skip_stack_adjustment (temp);
+ if (temp == call_block->end)
+ goto success;
+
+ /* Skip over a CLOBBER of the return value (as a hard reg). */
+ temp = skip_use_of_return_value (temp, CLOBBER);
+ if (temp == call_block->end)
+ goto success;
+
+ /* Skip over a USE of the return value (as a hard reg). */
+ temp = skip_use_of_return_value (temp, USE);
+ if (temp == call_block->end)
+ goto success;
+
+ /* Skip over the JUMP_INSN at the end of the block. */
+ temp = skip_jump_insn (temp);
+ if (GET_CODE (temp) == NOTE)
+ temp = next_nonnote_insn (temp);
+ if (temp == call_block->end)
+ goto success;
+
+ /* There are operations at the end of the block which we must
+ execute after returning from the function call. So this call
+ can not be optimized. */
+failure:
+ sibcall = 0, tailrecursion = 0;
+success:
+
+ /* Select a set of insns to implement the call and emit them.
+ Tail recursion is the most efficient, so select it over
+ a tail/sibling call. */
+
+ if (sibcall)
+ successful_sibling_call = 1;
+ replaced_call_placeholder = 1;
+ replace_call_placeholder (insn,
+ tailrecursion != 0
+ ? sibcall_use_tail_recursion
+ : sibcall != 0
+ ? sibcall_use_sibcall
+ : sibcall_use_normal);
+ }
+ }
+
+ /* A sibling call sequence invalidates any REG_EQUIV notes made for
+ this function's incoming arguments.
+
+ At the start of RTL generation we know the only REG_EQUIV notes
+ in the rtl chain are those for incoming arguments, so we can safely
+ flush any REG_EQUIV note.
+
+ This is (slight) overkill. We could keep track of the highest argument
+ we clobber and be more selective in removing notes, but it does not
+ seem to be worth the effort. */
+ if (successful_sibling_call)
+ purge_reg_equiv_notes ();
+
+ /* There may have been NOTE_INSN_BLOCK_{BEGIN,END} notes in the
+ CALL_PLACEHOLDER alternatives that we didn't emit. Rebuild the
+ lexical block tree to correspond to the notes that still exist. */
+ if (replaced_call_placeholder)
+ unroll_block_trees ();
+
+ /* This information will be invalid after inline expansion. Kill it now. */
+ free_basic_block_vars (0);
+}
git://gcc.gnu.org / gcc.git / commitdiff