763 lines
22 KiB
C
763 lines
22 KiB
C
/* Generic sibling call optimization support
|
||
Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
|
||
|
||
This file is part of GCC.
|
||
|
||
GCC 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.
|
||
|
||
GCC 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 GCC; 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"
|
||
|
||
/* In case alternate_exit_block contains copy from pseudo, to return value,
|
||
record the pseudo here. In such case the pseudo must be set to function
|
||
return in the sibcall sequence. */
|
||
static rtx return_value_pseudo;
|
||
|
||
static int identify_call_return_value PARAMS ((rtx, rtx *, rtx *));
|
||
static rtx skip_copy_to_return_value PARAMS ((rtx));
|
||
static rtx skip_use_of_return_value PARAMS ((rtx, enum rtx_code));
|
||
static rtx skip_stack_adjustment PARAMS ((rtx));
|
||
static rtx skip_pic_restore PARAMS ((rtx));
|
||
static rtx skip_jump_insn PARAMS ((rtx));
|
||
static int call_ends_block_p PARAMS ((rtx, rtx));
|
||
static int uses_addressof PARAMS ((rtx));
|
||
static int sequence_uses_addressof PARAMS ((rtx));
|
||
static void purge_reg_equiv_notes PARAMS ((void));
|
||
static void purge_mem_unchanging_flag PARAMS ((rtx));
|
||
static rtx skip_unreturned_value PARAMS ((rtx));
|
||
|
||
/* 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;
|
||
|
||
insn = XEXP (cp, 0);
|
||
/* Search backward through the "normal" call sequence to the CALL insn. */
|
||
while (NEXT_INSN (insn))
|
||
insn = NEXT_INSN (insn);
|
||
while (GET_CODE (insn) != CALL_INSN)
|
||
insn = PREV_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;
|
||
|
||
/* Stack adjustment done after call may appear here. */
|
||
insn = skip_stack_adjustment (insn);
|
||
if (! insn)
|
||
return 0;
|
||
|
||
/* Restore of GP register may appear here. */
|
||
insn = skip_pic_restore (insn);
|
||
if (! insn)
|
||
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)
|
||
rtx orig_insn;
|
||
{
|
||
rtx insn, set = NULL_RTX;
|
||
rtx hardret, softret;
|
||
|
||
/* If there is no return value, we have nothing to do. */
|
||
if (! identify_call_return_value (PATTERN (orig_insn), &hardret, &softret))
|
||
return orig_insn;
|
||
|
||
insn = next_nonnote_insn (orig_insn);
|
||
if (! insn)
|
||
return orig_insn;
|
||
|
||
set = single_set (insn);
|
||
if (! set)
|
||
return orig_insn;
|
||
|
||
if (return_value_pseudo)
|
||
{
|
||
if (SET_DEST (set) == return_value_pseudo
|
||
&& SET_SRC (set) == softret)
|
||
return insn;
|
||
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. */
|
||
|
||
#ifndef OUTGOING_REGNO
|
||
#define OUTGOING_REGNO(N) (N)
|
||
#endif
|
||
|
||
if (SET_DEST (set) == current_function_return_rtx
|
||
&& REG_P (SET_DEST (set))
|
||
&& OUTGOING_REGNO (REGNO (SET_DEST (set))) == REGNO (hardret)
|
||
&& SET_SRC (set) == softret)
|
||
return insn;
|
||
|
||
/* Recognize the situation when the called function's return value
|
||
is copied in two steps: first into an intermediate pseudo, then
|
||
the into the calling functions return value register. */
|
||
|
||
if (REG_P (SET_DEST (set))
|
||
&& SET_SRC (set) == softret)
|
||
{
|
||
rtx x = SET_DEST (set);
|
||
|
||
insn = next_nonnote_insn (insn);
|
||
if (! insn)
|
||
return orig_insn;
|
||
|
||
set = single_set (insn);
|
||
if (! set)
|
||
return orig_insn;
|
||
|
||
if (SET_DEST (set) == current_function_return_rtx
|
||
&& REG_P (SET_DEST (set))
|
||
&& OUTGOING_REGNO (REGNO (SET_DEST (set))) == REGNO (hardret)
|
||
&& SET_SRC (set) == x)
|
||
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;
|
||
}
|
||
|
||
/* In case function does not return value, we get clobber of pseudo followed
|
||
by set to hard return value. */
|
||
static rtx
|
||
skip_unreturned_value (orig_insn)
|
||
rtx orig_insn;
|
||
{
|
||
rtx insn = next_nonnote_insn (orig_insn);
|
||
|
||
/* Skip possible clobber of pseudo return register. */
|
||
if (insn
|
||
&& GET_CODE (insn) == INSN
|
||
&& GET_CODE (PATTERN (insn)) == CLOBBER
|
||
&& REG_P (XEXP (PATTERN (insn), 0))
|
||
&& (REGNO (XEXP (PATTERN (insn), 0)) >= FIRST_PSEUDO_REGISTER))
|
||
{
|
||
rtx set_insn = next_nonnote_insn (insn);
|
||
rtx set;
|
||
if (!set_insn)
|
||
return insn;
|
||
set = single_set (set_insn);
|
||
if (!set
|
||
|| SET_SRC (set) != XEXP (PATTERN (insn), 0)
|
||
|| SET_DEST (set) != current_function_return_rtx)
|
||
return insn;
|
||
return set_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);
|
||
|
||
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;
|
||
|
||
return orig_insn;
|
||
}
|
||
|
||
/* If the first real insn after ORIG_INSN sets the pic register,
|
||
return it. Otherwise return ORIG_INSN. */
|
||
|
||
static rtx
|
||
skip_pic_restore (orig_insn)
|
||
rtx orig_insn;
|
||
{
|
||
rtx insn, set = NULL_RTX;
|
||
|
||
insn = next_nonnote_insn (orig_insn);
|
||
|
||
if (insn)
|
||
set = single_set (insn);
|
||
|
||
if (insn && set && SET_DEST (set) == pic_offset_table_rtx)
|
||
return insn;
|
||
|
||
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
|
||
&& any_uncondjump_p (insn))
|
||
return insn;
|
||
|
||
return orig_insn;
|
||
}
|
||
|
||
/* Using the above functions, see if INSN, skipping any of the above,
|
||
goes all the way to END, the end of a basic block. Return 1 if so. */
|
||
|
||
static int
|
||
call_ends_block_p (insn, end)
|
||
rtx insn;
|
||
rtx end;
|
||
{
|
||
rtx new_insn;
|
||
/* END might be a note, so get the last nonnote insn of the block. */
|
||
end = next_nonnote_insn (PREV_INSN (end));
|
||
|
||
/* If the call was the end of the block, then we're OK. */
|
||
if (insn == end)
|
||
return 1;
|
||
|
||
/* Skip over copying from the call's return value pseudo into
|
||
this function's hard return register and if that's the end
|
||
of the block, we're OK. */
|
||
new_insn = skip_copy_to_return_value (insn);
|
||
|
||
/* In case we return value in pseudo, we must set the pseudo to
|
||
return value of called function, otherwise we are returning
|
||
something else. */
|
||
if (return_value_pseudo && insn == new_insn)
|
||
return 0;
|
||
insn = new_insn;
|
||
|
||
if (insn == end)
|
||
return 1;
|
||
|
||
/* Skip any stack adjustment. */
|
||
insn = skip_stack_adjustment (insn);
|
||
if (insn == end)
|
||
return 1;
|
||
|
||
/* Skip over a CLOBBER of the return value as a hard reg. */
|
||
insn = skip_use_of_return_value (insn, CLOBBER);
|
||
if (insn == end)
|
||
return 1;
|
||
|
||
/* Skip over a CLOBBER of the return value as a hard reg. */
|
||
insn = skip_unreturned_value (insn);
|
||
if (insn == end)
|
||
return 1;
|
||
|
||
/* Skip over a USE of the return value (as a hard reg). */
|
||
insn = skip_use_of_return_value (insn, USE);
|
||
if (insn == end)
|
||
return 1;
|
||
|
||
/* Skip over a JUMP_INSN at the end of the block. If that doesn't end the
|
||
block, the original CALL_INSN didn't. */
|
||
insn = skip_jump_insn (insn);
|
||
return insn == end;
|
||
}
|
||
|
||
/* Scan the rtx X for ADDRESSOF expressions or
|
||
current_function_internal_arg_pointer registers.
|
||
Return nonzero if an ADDRESSOF or current_function_internal_arg_pointer
|
||
is found outside of some MEM expression, 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 || x == current_function_internal_arg_pointer)
|
||
return 1;
|
||
|
||
if (code == MEM)
|
||
return 0;
|
||
|
||
/* 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 or current_function_internal_arg_pointer occurrences
|
||
not enclosed within a MEM. If an ADDRESSOF expression or
|
||
current_function_internal_arg_pointer is found, return nonzero, otherwise
|
||
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 (INSN_P (insn))
|
||
{
|
||
/* 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;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Clear RTX_UNCHANGING_P flag of incoming argument MEMs. */
|
||
|
||
static void
|
||
purge_mem_unchanging_flag (x)
|
||
rtx x;
|
||
{
|
||
RTX_CODE code;
|
||
int i, j;
|
||
const char *fmt;
|
||
|
||
if (x == NULL_RTX)
|
||
return;
|
||
|
||
code = GET_CODE (x);
|
||
|
||
if (code == MEM)
|
||
{
|
||
if (RTX_UNCHANGING_P (x)
|
||
&& (XEXP (x, 0) == current_function_internal_arg_pointer
|
||
|| (GET_CODE (XEXP (x, 0)) == PLUS
|
||
&& XEXP (XEXP (x, 0), 0) ==
|
||
current_function_internal_arg_pointer
|
||
&& GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)))
|
||
RTX_UNCHANGING_P (x) = 0;
|
||
return;
|
||
}
|
||
|
||
/* Scan all subexpressions. */
|
||
fmt = GET_RTX_FORMAT (code);
|
||
for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
|
||
{
|
||
if (*fmt == 'e')
|
||
purge_mem_unchanging_flag (XEXP (x, i));
|
||
else if (*fmt == 'E')
|
||
for (j = 0; j < XVECLEN (x, i); j++)
|
||
purge_mem_unchanging_flag (XVECEXP (x, i, j));
|
||
}
|
||
}
|
||
|
||
/* 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. */
|
||
remove_insn (insn);
|
||
}
|
||
|
||
/* 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 ();
|
||
|
||
rebuild_jump_labels (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 (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
|
||
|
||
/* If there are no basic blocks, then there is nothing to do. */
|
||
if (n_basic_blocks == 0)
|
||
return;
|
||
|
||
return_value_pseudo = NULL_RTX;
|
||
|
||
/* 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))
|
||
{
|
||
rtx set;
|
||
/* 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;
|
||
|
||
/* Exit block also may contain copy from pseudo containing
|
||
return value to hard register. */
|
||
if (GET_CODE (insn) == INSN
|
||
&& (set = single_set (insn))
|
||
&& SET_DEST (set) == current_function_return_rtx
|
||
&& REG_P (SET_SRC (set))
|
||
&& !return_value_pseudo)
|
||
{
|
||
return_value_pseudo = SET_SRC (set);
|
||
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;
|
||
else
|
||
return_value_pseudo = NULL;
|
||
}
|
||
|
||
/* 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 call_block = BLOCK_FOR_INSN (insn);
|
||
|
||
/* alloca (until we have stack slot life analysis) inhibits
|
||
sibling call optimizations, but not tail recursion.
|
||
Similarly if we use varargs or stdarg since they implicitly
|
||
may take the address of an argument. */
|
||
if (current_function_calls_alloca
|
||
|| current_function_varargs || current_function_stdarg)
|
||
sibcall = 0;
|
||
|
||
/* See if there are any reasons we can't perform either sibling or
|
||
tail call optimizations. We must be careful with stack slots
|
||
which are live at potential optimization sites. ??? The first
|
||
test is overly conservative and should be replaced. */
|
||
if (frame_offset
|
||
/* Can't take address of local var if used by recursive call. */
|
||
|| current_function_uses_addressof
|
||
/* Any function that calls setjmp might have longjmp called from
|
||
any called function. ??? We really should represent this
|
||
properly in the CFG so that this needn't be special cased. */
|
||
|| current_function_calls_setjmp
|
||
/* Can't if more than one successor or single successor is not
|
||
exit block. These two tests prevent tail call optimization
|
||
in the presense of active exception handlers. */
|
||
|| call_block->succ == NULL
|
||
|| call_block->succ->succ_next != NULL
|
||
|| (call_block->succ->dest != EXIT_BLOCK_PTR
|
||
&& call_block->succ->dest != alternate_exit)
|
||
/* If this call doesn't end the block, there are operations at
|
||
the end of the block which we must execute after returning. */
|
||
|| ! call_ends_block_p (insn, call_block->end))
|
||
sibcall = 0, tailrecursion = 0;
|
||
|
||
/* 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);
|
||
}
|
||
}
|
||
|
||
if (successful_sibling_call)
|
||
{
|
||
rtx insn;
|
||
|
||
/* 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. */
|
||
purge_reg_equiv_notes ();
|
||
|
||
/* A sibling call sequence also may invalidate RTX_UNCHANGING_P
|
||
flag of some incoming arguments MEM RTLs, because it can write into
|
||
those slots. We clear all those bits now.
|
||
|
||
This is (slight) overkill, we could keep track of which arguments
|
||
we actually write into. */
|
||
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
|
||
{
|
||
if (INSN_P (insn))
|
||
purge_mem_unchanging_flag (PATTERN (insn));
|
||
}
|
||
}
|
||
|
||
/* 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)
|
||
reorder_blocks ();
|
||
|
||
/* This information will be invalid after inline expansion. Kill it now. */
|
||
free_basic_block_vars (0);
|
||
}
|