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
+Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
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, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "target.h"
#include "cgraph.h"
#include "except.h"
+#include "dbgcnt.h"
/* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
#define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
int, int *);
static rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type,
enum machine_mode, int, va_list);
-static int special_function_p (tree, int);
+static int special_function_p (const_tree, int);
static int check_sibcall_argument_overlap_1 (rtx);
static int check_sibcall_argument_overlap (rtx, struct arg_data *, int);
space from the stack such as alloca. */
static int
-special_function_p (tree fndecl, int flags)
+special_function_p (const_tree fndecl, int flags)
{
if (fndecl && DECL_NAME (fndecl)
&& IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 17
/* Return nonzero when FNDECL represents a call to setjmp. */
int
-setjmp_call_p (tree fndecl)
+setjmp_call_p (const_tree fndecl)
{
return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
}
/* Return true when exp contains alloca call. */
bool
-alloca_call_p (tree exp)
+alloca_call_p (const_tree exp)
{
if (TREE_CODE (exp) == CALL_EXPR
&& TREE_CODE (CALL_EXPR_FN (exp)) == ADDR_EXPR
/* Detect flags (function attributes) from the function decl or type node. */
int
-flags_from_decl_or_type (tree exp)
+flags_from_decl_or_type (const_tree exp)
{
int flags = 0;
- tree type = exp;
+ const_tree type = exp;
if (DECL_P (exp))
{
/* Detect flags from a CALL_EXPR. */
int
-call_expr_flags (tree t)
+call_expr_flags (const_tree t)
{
int flags;
tree decl = get_callee_fndecl (t);
else
copy = assign_temp (type, 0, 1, 0);
- store_expr (args[i].tree_value, copy, 0);
+ store_expr (args[i].tree_value, copy, 0, false);
if (callee_copies)
*ecf_flags &= ~(ECF_CONST | ECF_LIBCALL_BLOCK);
= size_binop (MAX_EXPR, args_size->var,
ssize_int (reg_parm_stack_space));
-#ifndef OUTGOING_REG_PARM_STACK_SPACE
/* The area corresponding to register parameters is not to count in
the size of the block we need. So make the adjustment. */
- args_size->var
- = size_binop (MINUS_EXPR, args_size->var,
- ssize_int (reg_parm_stack_space));
-#endif
+ if (!OUTGOING_REG_PARM_STACK_SPACE)
+ args_size->var
+ = size_binop (MINUS_EXPR, args_size->var,
+ ssize_int (reg_parm_stack_space));
}
}
else
args_size->constant = MAX (args_size->constant,
reg_parm_stack_space);
-#ifndef OUTGOING_REG_PARM_STACK_SPACE
- args_size->constant -= reg_parm_stack_space;
-#endif
+ if (!OUTGOING_REG_PARM_STACK_SPACE)
+ args_size->constant -= reg_parm_stack_space;
}
return unadjusted_args_size;
}
/* If this is a libcall, then precompute all arguments so that we do not
get extraneous instructions emitted as part of the libcall sequence. */
- if ((flags & ECF_LIBCALL_BLOCK) == 0)
+
+ /* If we preallocated the stack space, and some arguments must be passed
+ on the stack, then we must precompute any parameter which contains a
+ function call which will store arguments on the stack.
+ Otherwise, evaluating the parameter may clobber previous parameters
+ which have already been stored into the stack. (we have code to avoid
+ such case by saving the outgoing stack arguments, but it results in
+ worse code) */
+ if ((flags & ECF_LIBCALL_BLOCK) == 0 && !ACCUMULATE_OUTGOING_ARGS)
return;
for (i = 0; i < num_actuals; i++)
{
enum machine_mode mode;
+ if ((flags & ECF_LIBCALL_BLOCK) == 0
+ && TREE_CODE (args[i].tree_value) != CALL_EXPR)
+ continue;
+
/* If this is an addressable type, we cannot pre-evaluate it. */
gcc_assert (!TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)));
{
/* If this is the first use of the function, see if we need to
make an external definition for it. */
- if (! TREE_USED (fndecl))
+ if (!TREE_USED (fndecl) && fndecl != current_function_decl)
{
assemble_external (fndecl);
TREE_USED (fndecl) = 1;
return true;
}
+/* If X is a likely-spilled register value, copy it to a pseudo
+ register and return that register. Return X otherwise. */
+
+static rtx
+avoid_likely_spilled_reg (rtx x)
+{
+ rtx new;
+
+ if (REG_P (x)
+ && HARD_REGISTER_P (x)
+ && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (REGNO (x))))
+ {
+ /* Make sure that we generate a REG rather than a CONCAT.
+ Moves into CONCATs can need nontrivial instructions,
+ and the whole point of this function is to avoid
+ using the hard register directly in such a situation. */
+ generating_concat_p = 0;
+ new = gen_reg_rtx (GET_MODE (x));
+ generating_concat_p = 1;
+ emit_move_insn (new, x);
+ return new;
+ }
+ return x;
+}
+
/* Generate all the code for a CALL_EXPR exp
and return an rtx for its value.
Store the value in TARGET (specified as an rtx) if convenient.
reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
#endif
-#ifndef OUTGOING_REG_PARM_STACK_SPACE
- if (reg_parm_stack_space > 0 && PUSH_ARGS)
+ if (!OUTGOING_REG_PARM_STACK_SPACE && reg_parm_stack_space > 0 && PUSH_ARGS)
must_preallocate = 1;
-#endif
/* Set up a place to return a structure. */
if (currently_expanding_call++ != 0
|| !flag_optimize_sibling_calls
|| args_size.var
- || lookup_stmt_eh_region (exp) >= 0)
+ || lookup_stmt_eh_region (exp) >= 0
+ || dbg_cnt (tail_call) == false)
try_tail_call = 0;
/* Rest of purposes for tail call optimizations to fail. */
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;
-#endif
+ if (!OUTGOING_REG_PARM_STACK_SPACE)
+ needed += reg_parm_stack_space;
#ifdef ARGS_GROW_DOWNWARD
highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
an argument. */
if (stack_arg_under_construction)
{
-#ifndef OUTGOING_REG_PARM_STACK_SPACE
- rtx push_size = GEN_INT (reg_parm_stack_space
- + adjusted_args_size.constant);
-#else
- rtx push_size = GEN_INT (adjusted_args_size.constant);
-#endif
+ rtx push_size
+ = GEN_INT (adjusted_args_size.constant
+ + (OUTGOING_REG_PARM_STACK_SPACE ? 0
+ : reg_parm_stack_space));
if (old_stack_level == 0)
{
emit_stack_save (SAVE_BLOCK, &old_stack_level,
/* If register arguments require space on the stack and stack space
was not preallocated, allocate stack space here for arguments
passed in registers. */
-#ifdef OUTGOING_REG_PARM_STACK_SPACE
- if (!ACCUMULATE_OUTGOING_ARGS
+ if (OUTGOING_REG_PARM_STACK_SPACE && !ACCUMULATE_OUTGOING_ARGS
&& 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. */
valreg = temp;
}
- /* 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. */
+ /* For calls to `setjmp', etc., inform
+ function.c:setjmp_warnings that it should complain if
+ nonvolatile values are live. For functions that cannot
+ return, inform flow that control does not fall through. */
if ((flags & ECF_NORETURN) || pass == 0)
{
/* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
reg to a plain register. */
- if (REG_P (valreg)
- && HARD_REGISTER_P (valreg)
- && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (REGNO (valreg)))
- && !(REG_P (target) && !HARD_REGISTER_P (target)))
- valreg = copy_to_reg (valreg);
+ if (!REG_P (target) || HARD_REGISTER_P (target))
+ valreg = avoid_likely_spilled_reg (valreg);
/* If TARGET is a MEM in the argument area, and we have
saved part of the argument area, then we can't store
sibcall_failure = 1;
}
else
- target = copy_to_reg (valreg);
+ target = copy_to_reg (avoid_likely_spilled_reg (valreg));
if (targetm.calls.promote_function_return(funtype))
{
/* There are never REG_EQUIV notes for the incoming arguments
after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
if (NOTE_P (insn)
- && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
+ && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
break;
note = find_reg_note (insn, REG_EQUIV, 0);
args_size.constant = MAX (args_size.constant,
reg_parm_stack_space);
-#ifndef OUTGOING_REG_PARM_STACK_SPACE
- args_size.constant -= reg_parm_stack_space;
-#endif
+ if (!OUTGOING_REG_PARM_STACK_SPACE)
+ args_size.constant -= reg_parm_stack_space;
if (args_size.constant > current_function_outgoing_args_size)
current_function_outgoing_args_size = args_size.constant;
needed = args_size.constant;
-#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;
-#endif
+ if (!OUTGOING_REG_PARM_STACK_SPACE)
+ needed += reg_parm_stack_space;
#ifdef ARGS_GROW_DOWNWARD
highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
if (reg != 0 && GET_CODE (reg) == PARALLEL)
use_group_regs (&call_fusage, reg);
else if (reg != 0)
- use_reg (&call_fusage, reg);
+ {
+ int partial = argvec[count].partial;
+ if (partial)
+ {
+ int nregs;
+ gcc_assert (partial % UNITS_PER_WORD == 0);
+ nregs = partial / UNITS_PER_WORD;
+ use_regs (&call_fusage, REGNO (reg), nregs);
+ }
+ else
+ use_reg (&call_fusage, reg);
+ }
}
/* Pass the function the address in which to return a structure value. */
valreg,
old_inhibit_defer_pop + 1, call_fusage, flags, & args_so_far);
- /* 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. */
+ /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
+ that it should complain if nonvolatile values are live. For
+ functions that cannot return, inform flow that control does not
+ fall through. */
if (flags & ECF_NORETURN)
{
/* expand_call should ensure this. */
gcc_assert (!arg->locate.offset.var
+ && arg->locate.size.var == 0
&& GET_CODE (size_rtx) == CONST_INT);
if (arg->locate.offset.constant > i)
}
else if (arg->locate.offset.constant < i)
{
- if (i < arg->locate.offset.constant + INTVAL (size_rtx))
+ /* Use arg->locate.size.constant instead of size_rtx
+ because we only care about the part of the argument
+ on the stack. */
+ if (i < (arg->locate.offset.constant
+ + arg->locate.size.constant))
+ sibcall_failure = 1;
+ }
+ else
+ {
+ /* Even though they appear to be at the same location,
+ if part of the outgoing argument is in registers,
+ they aren't really at the same location. Check for
+ this by making sure that the incoming size is the
+ same as the outgoing size. */
+ if (arg->locate.size.constant != INTVAL (size_rtx))
sibcall_failure = 1;
}
}
bool
must_pass_in_stack_var_size (enum machine_mode mode ATTRIBUTE_UNUSED,
- tree type)
+ const_tree type)
{
if (!type)
return false;
/* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
bool
-must_pass_in_stack_var_size_or_pad (enum machine_mode mode, tree type)
+must_pass_in_stack_var_size_or_pad (enum machine_mode mode, const_tree type)
{
if (!type)
return false;
OSDN Git Service
