* toplev.c (rest_of_compilation): Fix webizer pass ordering.
* cgraphunit.c (decide_is_function_needed): Fix test dealing
with functions implicitly made inline.
* cgraphunit.c (cgraph_decide_inlining_incrementally): New function.
(cgraph_finalize_function): Use it.
(cgraph_mark_inline): Allow incrmental decisions
* invoke.texi (max-inline-slope, min-inline-insns): Kill.
* params.def (PARAM_MAX_INLINE_SLOPE, PARAM_MIN_INLINE_INSNS): Kill.
* tree-inline.c (limits_allow_inlining): Kill.
(expand_call_inline): Always use unit-at-a-time path.
* decl.c (start_cleanup_fn): Set DECL_DECLARED_INLINE_P to deffer
the expansion.
* testsuite/g++.dg/opt/inline4.C: Do not use min-inline-insns
parameter.
* testsuite/gcc.dg/inline-2.c: Likewise.
From-SVN: r72721
+2003-10-20 Jan Hubicka <jh@suse.cz>
+
+ * toplev.c (rest_of_compilation): Fix webizer pass ordering.
+
+ * cgraphunit.c (decide_is_function_needed): Fix test dealing
+ with functions implicitly made inline.
+
+ * cgraphunit.c (cgraph_decide_inlining_incrementally): New function.
+ (cgraph_finalize_function): Use it.
+ (cgraph_mark_inline): Allow incrmental decisions
+ * invoke.texi (max-inline-slope, min-inline-insns): Kill.
+ * params.def (PARAM_MAX_INLINE_SLOPE, PARAM_MIN_INLINE_INSNS): Kill.
+ * tree-inline.c (limits_allow_inlining): Kill.
+ (expand_call_inline): Always use unit-at-a-time path.
+
2003-10-20 Zack Weinberg <zack@codesourcery.com>
* fixinc/inclhack.def (hpux11_snprintf): New edit.
static void cgraph_optimize_function (struct cgraph_node *);
static bool cgraph_default_inline_p (struct cgraph_node *n);
static void cgraph_analyze_function (struct cgraph_node *node);
+static void cgraph_decide_inlining_incrementally (struct cgraph_node *);
/* Statistics we collect about inlining algorithm. */
static int ncalls_inlined;
/* When declared inline, defer even the uninlinable functions.
This allows them to be eliminated when unused. */
&& !DECL_DECLARED_INLINE_P (decl)
- && (node->local.inlinable || !cgraph_default_inline_p (node))))
+ && (!node->local.inlinable || !cgraph_default_inline_p (node))))
return true;
return false;
/* If not unit at a time, then we need to create the call graph
now, so that called functions can be queued and emitted now. */
if (!flag_unit_at_a_time)
- cgraph_analyze_function (node);
+ {
+ cgraph_analyze_function (node);
+ cgraph_decide_inlining_incrementally (node);
+ }
if (decide_is_function_needed (node, decl))
cgraph_mark_needed_node (node);
to->global.insns = new_insns;
if (!called && !what->needed && !what->origin
+ && flag_unit_at_a_time
&& !DECL_EXTERNAL (what->decl))
{
if (!what->global.will_be_output)
free (inlined_callees);
}
+/* Decide on the inlining. We do so in the topological order to avoid
+ expenses on updating datastructures. */
+
+static void
+cgraph_decide_inlining_incrementally (struct cgraph_node *node)
+{
+ struct cgraph_edge *e;
+ struct cgraph_node **inlined =
+ xmalloc (sizeof (struct cgraph_node *) * cgraph_n_nodes);
+ struct cgraph_node **inlined_callees =
+ xmalloc (sizeof (struct cgraph_node *) * cgraph_n_nodes);
+ int ninlined;
+ int ninlined_callees;
+ int y;
+
+ ninlined = cgraph_inlined_into (node, inlined);
+
+ /* First of all look for always inline functions. */
+ for (e = node->callees; e; e = e->next_callee)
+ if (e->callee->local.disregard_inline_limits && !e->callee->output
+ && e->callee != node && !e->inline_call)
+ {
+ ninlined_callees = cgraph_inlined_callees (e->callee, inlined_callees);
+ cgraph_mark_inline (node, e->callee, inlined, ninlined,
+ inlined_callees, ninlined_callees);
+ for (y = 0; y < ninlined_callees; y++)
+ inlined_callees[y]->output = 0, node->aux = 0;
+ }
+
+ /* Now do the automatic inlining. */
+ for (e = node->callees; e; e = e->next_callee)
+ if (e->callee->local.inlinable && !e->callee->output
+ && e->callee != node && !e->inline_call
+ && cgraph_default_inline_p (e->callee)
+ && cgraph_check_inline_limits (node, e->callee, inlined,
+ ninlined))
+ {
+ ninlined_callees = cgraph_inlined_callees (e->callee, inlined_callees);
+ cgraph_mark_inline (node, e->callee, inlined, ninlined,
+ inlined_callees, ninlined_callees);
+ for (y = 0; y < ninlined_callees; y++)
+ inlined_callees[y]->output = 0, node->aux = 0;
+ }
+
+ /* Clear the flags set by cgraph_inlined_into. */
+ for (y = 0; y < ninlined; y++)
+ inlined[y]->output = 0, node->aux = 0;
+
+ free (inlined);
+ free (inlined_callees);
+}
+
+
/* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */
bool
(unspec:SF [(match_dup 2)
(match_operand:SF 1 "register_operand" "")]
UNSPEC_FPATAN))
- (clobber (match_dup 1))])]
+ (clobber (match_scratch:SF 3 ""))])]
"! TARGET_NO_FANCY_MATH_387 && TARGET_80387
&& flag_unsafe_math_optimizations"
{
extern void coverage_init (const char *);
extern void coverage_finish (void);
+extern void coverage_read_counts_file (void);
/* Complete the coverage information for the current function. Once
per function. */
+2003-10-20 Jan Hubicka <jh@suse.cz>
+
+ * decl.c (start_cleanup_fn): Set DECL_DECLARED_INLINE_P to deffer
+ the expansion.
+
2003-10-20 Mark Mitchell <mark@codesourcery.com>
* Make-lang.in (c++.install-info): Remove.
it is only called via a function pointer, but we avoid unnecessary
emissions this way. */
DECL_INLINE (fndecl) = 1;
+ DECL_DECLARED_INLINE_P (fndecl) = 1;
+ DECL_INTERFACE_KNOWN (fndecl) = 1;
/* Build the parameter. */
if (flag_use_cxa_atexit)
{
binaries may adversely affect runtime performance.
The default value is 200.
-@item max-inline-slope
-After exceeding the maximum number of inlined instructions by repeated
-inlining, a linear function is used to decrease the allowable size
-for single functions. The slope of that function is the negative
-reciprocal of the number specified here.
-This parameter is ignored when @option{-funit-at-a-time} is used.
-The default value is 32.
-
-@item min-inline-insns
-The repeated inlining is throttled more and more by the linear function
-after exceeding the limit. To avoid too much throttling, a minimum for
-this function is specified here to allow repeated inlining for very small
-functions even when a lot of repeated inlining already has been done.
-This parameter is ignored when @option{-funit-at-a-time} is used.
-The default value is 10.
-
@item large-function-insns
The limit specifying really large functions. For functions greater than this
limit inlining is constrained by @option{--param large-function-growth}.
extern int flag_web;
+/* Nonzero means that we defer emitting functions until they are actually
+ used. */
+extern int flag_remove_unreachable_functions;
+
/* A string that's used when a random name is required. NULL means
to make it really random. */
set_param_value ("max-inline-insns-single", value / 2);
set_param_value ("max-inline-insns-auto", value / 2);
set_param_value ("max-inline-insns-rtl", value);
- if (value / 4 < MIN_INLINE_INSNS)
- {
- if (value / 4 > 10)
- set_param_value ("min-inline-insns", value / 4);
- else
- set_param_value ("min-inline-insns", 10);
- }
break;
case OPT_finstrument_functions:
"The maximum number of instructions by repeated inlining before gcc starts to throttle inlining",
200)
-/* After the repeated inline limit has been exceeded (see
- "max-inline-insns" parameter), a linear function is used to
- decrease the size of single functions eligible for inlining.
- The slope of this linear function is given the negative
- reciprocal value (-1/x) of this parameter.
- The default value is 32.
- This linear function is used until it falls below a minimum
- value specified by the "min-inline-insns" parameter. */
-DEFPARAM (PARAM_MAX_INLINE_SLOPE,
- "max-inline-slope",
- "The slope of the linear function throttling inlining after the recursive inlining limit has been reached is given by the negative reciprocal value of this parameter",
- 32)
-
-/* When gcc has inlined so many instructions (by repeated
- inlining) that the throttling limits the inlining very much,
- inlining for very small functions is still desirable to
- achieve good runtime performance. The size of single functions
- (measured in gcc instructions) which will still be eligible for
- inlining then is given by this parameter. It defaults to 130.
- Only much later (after exceeding 128 times the recursive limit)
- inlining is cut down completely. */
-DEFPARAM (PARAM_MIN_INLINE_INSNS,
- "min-inline-insns",
- "The number of instructions in a single functions still eligible to inlining after a lot recursive inlining",
- 10)
-
/* For languages that (still) use the RTL inliner, we can specify
limits for the RTL inliner separately.
The parameter here defines the maximum number of RTL instructions
+2003-10-20 Jan Hubicka <jh@suse.cz>
+
+ * testsuite/g++.dg/opt/inline4.C: Do not use min-inline-insns
+ parameter.
+ * testsuite/gcc.dg/inline-2.c: Likewise.
+
2003-10-20 Phil Edwards <phil@codesourcery.com>
* gcc.dg/20021014-1.c: XFAIL for *-*-windiss targets.
-// { dg-options "-O2 -ftemplate-depth-20000 --param min-inline-insns=100 --param max-inline-insns=3" }
+// { dg-options "-O2 -ftemplate-depth-20000" }
template <int I>
inline void g() { g<I-1>(); return; }
int bar(void)
{
- return foo() + 1;
+ /* Call twice to avoid bypassing the limit for functions called once. */
+ return foo() + foo() + 1;
}
/* { dg-final { scan-assembler-not "jsr" { target alpha*-*-* } } } */
rest_of_handle_cfg (decl, insns);
- if (flag_web)
- rest_of_handle_web (decl, insns);
-
if (optimize > 0
|| profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
{
|| flag_unroll_loops))
rest_of_handle_loop2 (decl, insns);
+ if (flag_web)
+ rest_of_handle_web (decl, insns);
+
if (flag_rerun_cse_after_loop)
rest_of_handle_cse2 (decl, insns);
static tree expand_call_inline (tree *, int *, void *);
static void expand_calls_inline (tree *, inline_data *);
static bool inlinable_function_p (tree);
-static int limits_allow_inlining (tree, inline_data *);
static tree remap_decl (tree, inline_data *);
static tree remap_type (tree, inline_data *);
#ifndef INLINER_FOR_JAVA
return inlinable;
}
-/* We can't inline functions that are too big. Only allow a single
- function to be of MAX_INLINE_INSNS_SINGLE size. Make special
- allowance for extern inline functions, though.
-
- Return nonzero if the function FN can be inlined into the inlining
- context ID. */
-
-static int
-limits_allow_inlining (tree fn, inline_data *id)
-{
- int estimated_insns = 0;
- size_t i;
-
- /* Don't even bother if the function is not inlinable. */
- if (!inlinable_function_p (fn))
- return 0;
-
- /* Investigate the size of the function. Return at once
- if the function body size is too large. */
- if (!(*lang_hooks.tree_inlining.disregard_inline_limits) (fn))
- {
- int currfn_max_inline_insns;
-
- /* If we haven't already done so, get an estimate of the number of
- instructions that will be produces when expanding this function. */
- if (!DECL_ESTIMATED_INSNS (fn))
- DECL_ESTIMATED_INSNS (fn)
- = (*lang_hooks.tree_inlining.estimate_num_insns) (fn);
- estimated_insns = DECL_ESTIMATED_INSNS (fn);
-
- /* We may be here either because fn is declared inline or because
- we use -finline-functions. For the second case, we are more
- restrictive.
-
- FIXME: -finline-functions should imply -funit-at-a-time, it's
- about equally expensive but unit-at-a-time produces
- better code. */
- currfn_max_inline_insns = DECL_DECLARED_INLINE_P (fn) ?
- MAX_INLINE_INSNS_SINGLE : MAX_INLINE_INSNS_AUTO;
-
- /* If the function is too big to be inlined, adieu. */
- if (estimated_insns > currfn_max_inline_insns)
- return 0;
-
- /* We now know that we don't disregard the inlining limits and that
- we basically should be able to inline this function.
- We always allow inlining functions if we estimate that they are
- smaller than MIN_INLINE_INSNS. Otherwise, investigate further. */
- if (estimated_insns > MIN_INLINE_INSNS)
- {
- int sum_insns = (id ? id->inlined_insns : 0) + estimated_insns;
-
- /* In the extreme case that we have exceeded the recursive inlining
- limit by a huge factor (128), we just say no.
-
- FIXME: Should not happen in real life, but people have reported
- that it actually does!? */
- if (sum_insns > MAX_INLINE_INSNS * 128)
- return 0;
-
- /* If we did not hit the extreme limit, we use a linear function
- with slope -1/MAX_INLINE_SLOPE to exceedingly decrease the
- allowable size. */
- else if (sum_insns > MAX_INLINE_INSNS)
- {
- if (estimated_insns > currfn_max_inline_insns
- - (sum_insns - MAX_INLINE_INSNS) / MAX_INLINE_SLOPE)
- return 0;
- }
- }
- }
-
- /* Don't allow recursive inlining. */
- for (i = 0; i < VARRAY_ACTIVE_SIZE (id->fns); ++i)
- if (VARRAY_TREE (id->fns, i) == fn)
- return 0;
-
- if (DECL_INLINED_FNS (fn))
- {
- int j;
- tree inlined_fns = DECL_INLINED_FNS (fn);
-
- for (j = 0; j < TREE_VEC_LENGTH (inlined_fns); ++j)
- if (TREE_VEC_ELT (inlined_fns, j) == VARRAY_TREE (id->fns, 0))
- return 0;
- }
-
- /* Go ahead, this function can be inlined. */
- return 1;
-}
-
/* If *TP is a CALL_EXPR, replace it with its inline expansion. */
static tree
return NULL_TREE;
/* Turn forward declarations into real ones. */
- if (flag_unit_at_a_time)
- fn = cgraph_node (fn)->decl;
+ fn = cgraph_node (fn)->decl;
/* If fn is a declaration of a function in a nested scope that was
globally declared inline, we don't set its DECL_INITIAL.
/* Don't try to inline functions that are not well-suited to
inlining. */
- if ((flag_unit_at_a_time
- && (!DECL_SAVED_TREE (fn) || !cgraph_inline_p (id->current_decl, fn)))
- || (!flag_unit_at_a_time && !limits_allow_inlining (fn, id)))
+ if (!DECL_SAVED_TREE (fn) || !cgraph_inline_p (id->current_decl, fn))
{
if (warn_inline && DECL_INLINE (fn) && DECL_DECLARED_INLINE_P (fn)
&& !DECL_IN_SYSTEM_HEADER (fn))
id->inlined_insns += DECL_ESTIMATED_INSNS (fn) - 1;
/* Update callgraph if needed. */
- if (id->decl && flag_unit_at_a_time)
+ if (id->decl)
{
cgraph_remove_call (id->decl, fn);
cgraph_create_edges (id->decl, *inlined_body);
projects / gcc.git / commitdiff