+2003-03-02 Kurt Garloff <garloff@suse.de>
+
+ * params.def: Introduce parameter max-inline-insns-rtl for
+ a separate limit for the RTL inliner.
+ * params.h: Likewise.
+ * integrate.c (function_cannot_inline_p): Use it.
+ * toplev.c (decode_f_option): Set multiple parameters
+ controlling inlining with -finline-limit.
+ * params.def: Fix orthographic and typographic errors.
+ * doc/invoke.texi: Document parameters controlling inlining
+ and the way -finline-limit sets multiple of them.
+
+ * tree.h (struct tree_decl): Introduce inlined_function_flag,
+ recording whether the function became eligible for inlining
+ by a compiler flag rather than the declaration.
+ Provide DID_INLINE_FUNC macro to access it.
+ * c-decl.c (grokdeclarator): Set DID_INLINE_FUNC.
+ * cp/decl.c (grokfndecl): Likewise.
+ * toplev.c (rest_of_compilation): Likewise.
+ * cp/optimize (maybe_clone_body): Copy DID_INLINE_FUNC.
+ * print-tree.c (print_node): Report it.
+ * params.def: Introduce new max-inline-insns-auto limit.
+ * params.h: Likewise.
+ * tree-inline.c (inlinable_function_p): Apply it to functions
+ with DID_INLINE_FUNC set.
+ * toplev.c (decode_f_option): Initialize it from -finline-limit
+ value.
+ * doc/invoke.texi: Document new parameter.
+
2003-03-02 Geoffrey Keating <geoffk@apple.com>
* fix-header.c (read_scan_file): Don't reference simplify_path.
needed, and let dwarf2 know that the function is inlinable. */
else if (flag_inline_trees == 2 && initialized)
{
+ if (!DECL_INLINE (decl))
+ DID_INLINE_FUNC (decl) = 1;
DECL_INLINE (decl) = 1;
DECL_DECLARED_INLINE_P (decl) = 0;
}
DECL_NOT_REALLY_EXTERN (decl) = 1;
}
+ DID_INLINE_FUNC (decl) = 0;
/* If the declaration was declared inline, mark it as such. */
if (inlinep)
DECL_DECLARED_INLINE_P (decl) = 1;
/* We inline functions that are explicitly declared inline, or, when
the user explicitly asks us to, all functions. */
- if (DECL_DECLARED_INLINE_P (decl) || flag_inline_trees == 2)
+ if (DECL_DECLARED_INLINE_P (decl))
DECL_INLINE (decl) = 1;
+ if (flag_inline_trees == 2 && !DECL_INLINE (decl))
+ {
+ DID_INLINE_FUNC (decl) = 1;
+ DECL_INLINE (decl) = 1;
+ }
DECL_EXTERNAL (decl) = 1;
if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
DECL_DECLARED_INLINE_P (fndecl) = 1;
+ DID_INLINE_FUNC (fndecl) = 0;
if (flag_default_inline)
DECL_INLINE (fndecl) = 1;
/* Update CLONE's source position information to match FN's. */
DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (fn);
DECL_INLINE (clone) = DECL_INLINE (fn);
+ DID_INLINE_FUNC (clone) = DID_INLINE_FUNC (fn);
DECL_DECLARED_INLINE_P (clone) = DECL_DECLARED_INLINE_P (fn);
DECL_COMDAT (clone) = DECL_COMDAT (fn);
DECL_WEAK (clone) = DECL_WEAK (fn);
means slower programs). This option is particularly useful for programs that
use inlining heavily such as those based on recursive templates with C++.
+Inlining is actually controlled by a number of parameters, which may be
+specified individually by using @option{--param @var{name}=@var{value}}.
+The @option{-finline-limit=@var{n}} option sets some of these parameters
+as follows:
+
+@table @gcctabopt
+ @item max-inline-insns
+ is set to @var{n}.
+ @item max-inline-insns-single
+ is set to @var{n}/2.
+ @item max-inline-insns-single-auto
+ is set to @var{n}/2.
+ @item min-inline-insns
+ is set to 130 or @var{n}/4, whichever is smaller.
+ @item max-inline-insns-rtl
+ is set to @var{n}.
+@end table
+
+Using @option{-finline-limit=600} thus results in the default settings
+for these parameters. See below for a documentation of the individual
+parameters controlling inlining.
+
@emph{Note:} pseudo instruction represents, in this particular context, an
abstract measurement of function's size. In no way, it represents a count
of assembly instructions and as such its exact meaning might change from one
with few branches or calls can create excessively large lists which
needlessly consume memory and resources.
+@item max-inline-insns-single
+Several parameters control the tree inliner used in gcc.
+This number sets the maximum number of instructions (counted in gcc's
+internal representation) in a single function that the tree inliner
+will consider for inlining. This only affects functions declared
+inline and methods implemented in a class declaration (C++).
+The default value is 300.
+
+@item max-inline-insns-auto
+When you use @option{-finline-functions} (included in @option{-O3}),
+a lot of functions that would otherwise not be considered for inlining
+by the compiler will be investigated. To those functions, a different
+(more restrictive) limit compared to functions declared inline can
+be applied.
+The default value is 300.
+
@item max-inline-insns
-If an function contains more than this many instructions, it
-will not be inlined. This option is precisely equivalent to
-@option{-finline-limit}.
+The tree inliner does decrease the allowable size for single functions
+to be inlined after we already inlined the number of instructions
+given here by repeated inlining. This number should be a factor of
+two or more larger than the single function limit.
+Higher numbers result in better runtime performance, but incur higher
+compile-time resource (CPU time, memory) requirements and result in
+larger binaries. Very high values are not advisable, as too large
+binaries may adversely affect runtime performance.
+The default value is 600.
+
+@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.
+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.
+The default value is 130.
+
+@item max-inline-insns-rtl
+For languages that use the RTL inliner (this happens at a later stage
+than tree inlining), you can set the maximum allowable size (counted
+in RTL instructions) for the RTL inliner with this parameter.
+The default value is 600.
+
@item max-unrolled-insns
The maximum number of instructions that a loop should have if that loop
tree last = tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
/* For functions marked as inline increase the maximum size to
- MAX_INLINE_INSNS (-finline-limit-<n>). For regular functions
- use the limit given by INTEGRATE_THRESHOLD. */
+ MAX_INLINE_INSNS_RTL (--param max-inline-insn-rtl=<n>). For
+ regular functions use the limit given by INTEGRATE_THRESHOLD.
+ Note that the RTL inliner is not used by the languages that use
+ the tree inliner (C, C++). */
int max_insns = (DECL_INLINE (fndecl))
- ? (MAX_INLINE_INSNS
+ ? (MAX_INLINE_INSNS_RTL
+ 8 * list_length (DECL_ARGUMENTS (fndecl)))
: INTEGRATE_THRESHOLD (fndecl);
gets decreased. */
DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE,
"max-inline-insns-single",
- "The maximum number of instructions in a single function eliglible for inlining",
+ "The maximum number of instructions in a single function eligible for inlining",
300)
-/* The repeated inlining limit. After this number of instructions
+/* The single function inlining limit for functions that are
+ inlined by virtue of -finline-functions (-O3).
+ This limit should be chosen to be below or equal to the limit
+ that is applied to functions marked inlined (or defined in the
+ class declaration in C++) given by the "max-inline-insns-single"
+ parameter.
+ The default value is 300. */
+DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO,
+ "max-inline-insns-auto",
+ "The maximum number of instructions when automatically inlining",
+ 300)
+
+/* The repeated inlining limit. After this number of instructions
(in the internal gcc representation, not real machine instructions)
got inlined by repeated inlining, gcc starts to decrease the maximum
number of inlinable instructions in the tree inliner.
could otherwise become very high.
It is recommended to set this value to twice the value of the single
function limit (set by the "max-inline-insns-single" parameter) or
- higher. The default value is 600.
+ higher. The default value is 600.
Higher values mean that more inlining is done, resulting in
better performance of the code, at the expense of higher
compile-time resource (time, memory) requirements and larger
- binaries.
- This parameters also controls the maximum size of functions considered
- for inlining in the RTL inliner. */
+ binaries. */
DEFPARAM (PARAM_MAX_INLINE_INSNS,
"max-inline-insns",
- "The maximuem number of instructions by repeated inlining before gcc starts to throttle inlining",
+ "The maximum number of instructions by repeated inlining before gcc starts to throttle inlining",
600)
/* After the repeated inline limit has been exceeded (see
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 vlue is 32.
+ 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,
/* 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
+ 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.
+ 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,
"The number of instructions in a single functions still eligible to inlining after a lot recursive inlining",
130)
+/* 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
+ a function may have to be eligible for inlining in the RTL inliner.
+ The default value is 600. */
+DEFPARAM (PARAM_MAX_INLINE_INSNS_RTL,
+ "max-inline-insns-rtl",
+ "The maximum number of instructions for the RTL inliner",
+ 600)
+
/* The maximum number of instructions to consider when looking for an
instruction to fill a delay slot. If more than this arbitrary
number of instructions is searched, the time savings from filling
PARAM_VALUE (PARAM_MAX_INLINE_SLOPE)
#define MIN_INLINE_INSNS \
PARAM_VALUE (PARAM_MIN_INLINE_INSNS)
+#define MAX_INLINE_INSNS_AUTO \
+ PARAM_VALUE (PARAM_MAX_INLINE_INSNS_AUTO)
+#define MAX_INLINE_INSNS_RTL \
+ PARAM_VALUE (PARAM_MAX_INLINE_INSNS_RTL)
#define MAX_DELAY_SLOT_INSN_SEARCH \
PARAM_VALUE (PARAM_MAX_DELAY_SLOT_INSN_SEARCH)
#define MAX_DELAY_SLOT_LIVE_SEARCH \
if (TREE_CODE (node) == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node))
fputs (" suppress-debug", file);
- if (TREE_CODE (node) == FUNCTION_DECL && DECL_INLINE (node))
+ if (TREE_CODE (node) == FUNCTION_DECL && DID_INLINE_FUNC (node))
+ fputs (" autoinline", file);
+ else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INLINE (node))
fputs (" inline", file);
if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN (node))
fputs (" built-in", file);
goto exit_rest_of_compilation;
}
}
- else
- /* ??? Note that this has the effect of making it look
- like "inline" was specified for a function if we choose
- to inline it. This isn't quite right, but it's
- probably not worth the trouble to fix. */
+ else {
+ /* ??? Note that we used to just make it look like if
+ the "inline" keyword was specified when we decide
+ to inline it (because of -finline-functions).
+ garloff@suse.de, 2002-04-24: Add another flag to
+ actually record this piece of information. */
+ if (!DECL_INLINE (decl))
+ DID_INLINE_FUNC (decl) = 1;
inlinable = DECL_INLINE (decl) = 1;
+ }
}
insns = get_insns ();
read_integral_parameter (option_value, arg - 2,
MAX_INLINE_INSNS);
set_param_value ("max-inline-insns", val);
+ set_param_value ("max-inline-insns-single", val/2);
+ set_param_value ("max-inline-insns-auto", val/2);
+ set_param_value ("max-inline-insns-rtl", val);
+ if (val/4 < MIN_INLINE_INSNS)
+ {
+ if (val/4 > 10)
+ set_param_value ("min-inline-insns", val/4);
+ else
+ set_param_value ("min-inline-insns", 10);
+ }
}
else if ((option_value = skip_leading_substring (arg, "tls-model=")))
{
{
int inlinable;
int currfn_insns;
+ int max_inline_insns_single = MAX_INLINE_INSNS_SINGLE;
/* If we've already decided this function shouldn't be inlined,
there's no need to check again. */
/* Assume it is not inlinable. */
inlinable = 0;
-
+
+ /* We may be here either because fn is declared inline or because
+ we use -finline-functions. For the second case, we are more
+ restrictive. */
+ if (DID_INLINE_FUNC (fn))
+ max_inline_insns_single = MAX_INLINE_INSNS_AUTO;
+
/* The number of instructions (estimated) of current function. */
currfn_insns = DECL_NUM_STMTS (fn) * INSNS_PER_STMT;
function to be of MAX_INLINE_INSNS_SINGLE size. Make special
allowance for extern inline functions, though. */
else if (! (*lang_hooks.tree_inlining.disregard_inline_limits) (fn)
- && currfn_insns > MAX_INLINE_INSNS_SINGLE)
+ && currfn_insns > max_inline_insns_single)
;
/* We can't inline functions that call __builtin_longjmp at all.
The non-local goto machenery really requires the destination
where it is called. */
#define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inline_flag)
+/* Nonzero in a FUNCTION_DECL means this function has been found inlinable
+ only by virtue of -finline-functions */
+#define DID_INLINE_FUNC(NODE) \
+ (FUNCTION_DECL_CHECK (NODE)->decl.inlined_function_flag)
+
/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
#define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.uninlinable)
unsigned user_align : 1;
unsigned uninlinable : 1;
unsigned thread_local_flag : 1;
- /* Two unused bits. */
+ unsigned inlined_function_flag : 1;
+ /* One unused bit. */
unsigned lang_flag_0 : 1;
unsigned lang_flag_1 : 1;
projects / gcc.git / commitdiff