* Re: [PATCH] Restore disregarding inlining limits for extern inline functions
2007-08-26 16:33 ` Richard Guenther
@ 2007-08-27 9:54 ` Richard Guenther
0 siblings, 0 replies; 3+ messages in thread
From: Richard Guenther @ 2007-08-27 9:54 UTC (permalink / raw)
To: gcc-patches
On Sun, 26 Aug 2007, Richard Guenther wrote:
> On Tue, 21 Aug 2007, Richard Guenther wrote:
>
> >
> > As $subject says.
> >
> > Bootstrapped and tested on x86_64-unknown-linux-gnu. I'll apply this
> > tomorrow if nobody objects.
> >
> > Thanks,
> > Richard.
> >
> > 2007-08-21 Richard Guenther <rguenther@suse.de>
> >
> > * tree-inline.c (inlinable_function_p): Restore disregarding
> > inline limits for GNU extern inline functions.
>
> Unfortunately this seems to cause quite some C++ compile-time
> regressions. Does anyone know which C++ construct leads to both
> DECL_DECLARED_INLINE_P and DECL_EXTERNAL set (just to have a testcase)?
>
> I suppose the only solution is to either revert the patch, or in the
> C frontend set some other flag for the GNU extern inline case. Any
> ideas on what to best use here? There are bits in struct function
> left, also one bit in the decl itself.
I am testing the following patch. (If it makes us less nervous we
can spare more bits for function_code, like for example 14)
Richard.
2007-08-27 Richard Guenther <rguenther@suse.de>
* tree.h (DECL_DISREGARD_INLINE_LIMITS): New.
(struct tree_function_decl): Make function_code a bitfield.
Add disregard_inline_limits flag.
* cgraphunit.c (cgraph_process_new_functions): Check
DECL_DISREGARD_INLINE_LIMITS instead of disregard_inline_limits_p.
(cgraph_preserve_function_body_p): Likewise.
* ipa-inline.c (compute_inline_parameters): Likewise.
* c-decl.c (finish_decl): Set DECL_DISREGARD_INLINE_LIMITS
for GNU C extern inline functions.
* tree-inline.c (disregard_inline_limits_p): Remove.
* tree-inline.h (disregard_inline_limits_p): Likewise.
* c-common.c (handle_always_inline_attribute): Set
DECL_DISREGARD_INLINE_LIMITS.
Index: tree.h
===================================================================
*** tree.h.orig 2007-08-27 11:25:41.000000000 +0200
--- tree.h 2007-08-27 11:46:50.000000000 +0200
*************** struct tree_decl_non_common GTY(())
*** 3273,3278 ****
--- 3273,3281 ----
#define DECL_DECLARED_INLINE_P(NODE) \
(FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag)
+ #define DECL_DISREGARD_INLINE_LIMITS(NODE) \
+ (FUNCTION_DECL_CHECK (NODE)->function_decl.disregard_inline_limits)
+
/* For FUNCTION_DECL, this holds a pointer to a structure ("struct function")
that describes the status of this function. */
#define DECL_STRUCT_FUNCTION(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.f)
*************** struct tree_function_decl GTY(())
*** 3299,3325 ****
{
struct tree_decl_non_common common;
/* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
! DECL_FUNCTION_CODE. Otherwise unused. */
! enum built_in_function function_code;
unsigned static_ctor_flag : 1;
unsigned static_dtor_flag : 1;
unsigned uninlinable : 1;
unsigned possibly_inlined : 1;
unsigned novops_flag : 1;
unsigned returns_twice_flag : 1;
unsigned malloc_flag : 1;
unsigned pure_flag : 1;
-
unsigned declared_inline_flag : 1;
unsigned regdecl_flag : 1;
unsigned inline_flag : 1;
unsigned no_instrument_function_entry_exit : 1;
unsigned no_limit_stack : 1;
! ENUM_BITFIELD(built_in_class) built_in_class : 2;
! struct function *f;
};
/* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */
--- 3302,3334 ----
{
struct tree_decl_non_common common;
+ struct function *f;
+
/* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
! DECL_FUNCTION_CODE. Otherwise unused.
! ??? The bitfield needs to be able to hold all target function
! codes as well. */
! ENUM_BITFIELD(built_in_function) function_code : 10;
! ENUM_BITFIELD(built_in_class) built_in_class : 2;
unsigned static_ctor_flag : 1;
unsigned static_dtor_flag : 1;
unsigned uninlinable : 1;
unsigned possibly_inlined : 1;
+
unsigned novops_flag : 1;
unsigned returns_twice_flag : 1;
unsigned malloc_flag : 1;
unsigned pure_flag : 1;
unsigned declared_inline_flag : 1;
unsigned regdecl_flag : 1;
unsigned inline_flag : 1;
unsigned no_instrument_function_entry_exit : 1;
+
unsigned no_limit_stack : 1;
! unsigned disregard_inline_limits : 1;
! /* 6 bits left */
};
/* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */
Index: cgraphunit.c
===================================================================
*** cgraphunit.c.orig 2007-08-27 11:25:41.000000000 +0200
--- cgraphunit.c 2007-08-27 11:26:56.000000000 +0200
*************** cgraph_process_new_functions (void)
*** 381,387 ****
node->local.self_insns = estimate_num_insns (fndecl,
&eni_inlining_weights);
node->local.disregard_inline_limits
! |= disregard_inline_limits_p (fndecl);
/* Inlining characteristics are maintained by the
cgraph_mark_inline. */
node->global.insns = node->local.self_insns;
--- 381,387 ----
node->local.self_insns = estimate_num_insns (fndecl,
&eni_inlining_weights);
node->local.disregard_inline_limits
! |= DECL_DISREGARD_INLINE_LIMITS (fndecl);
/* Inlining characteristics are maintained by the
cgraph_mark_inline. */
node->global.insns = node->local.self_insns;
*************** cgraph_preserve_function_body_p (tree de
*** 1252,1258 ****
struct cgraph_node *node;
if (!cgraph_global_info_ready)
return (flag_really_no_inline
! ? disregard_inline_limits_p (decl)
: DECL_INLINE (decl));
/* Look if there is any clone around. */
for (node = cgraph_node (decl); node; node = node->next_clone)
--- 1252,1258 ----
struct cgraph_node *node;
if (!cgraph_global_info_ready)
return (flag_really_no_inline
! ? DECL_DISREGARD_INLINE_LIMITS (decl)
: DECL_INLINE (decl));
/* Look if there is any clone around. */
for (node = cgraph_node (decl); node; node = node->next_clone)
Index: ipa-inline.c
===================================================================
*** ipa-inline.c.orig 2007-08-27 11:25:41.000000000 +0200
--- ipa-inline.c 2007-08-27 11:26:56.000000000 +0200
*************** compute_inline_parameters (void)
*** 1529,1535 ****
&eni_inlining_weights);
if (node->local.inlinable && !node->local.disregard_inline_limits)
node->local.disregard_inline_limits
! = disregard_inline_limits_p (current_function_decl);
if (flag_really_no_inline && !node->local.disregard_inline_limits)
node->local.inlinable = 0;
/* Inlining characteristics are maintained by the cgraph_mark_inline. */
--- 1529,1535 ----
&eni_inlining_weights);
if (node->local.inlinable && !node->local.disregard_inline_limits)
node->local.disregard_inline_limits
! = DECL_DISREGARD_INLINE_LIMITS (current_function_decl);
if (flag_really_no_inline && !node->local.disregard_inline_limits)
node->local.inlinable = 0;
/* Inlining characteristics are maintained by the cgraph_mark_inline. */
Index: c-decl.c
===================================================================
*** c-decl.c.orig 2007-08-27 11:25:41.000000000 +0200
--- c-decl.c 2007-08-27 11:26:56.000000000 +0200
*************** finish_decl (tree decl, tree init, tree
*** 3517,3522 ****
--- 3517,3528 ----
/* If #pragma weak was used, mark the decl weak now. */
maybe_apply_pragma_weak (decl);
+ /* For GNU C extern inline functions disregard inline limits. */
+ if (TREE_CODE (decl) == FUNCTION_DECL
+ && DECL_EXTERNAL (decl)
+ && DECL_DECLARED_INLINE_P (decl))
+ DECL_DISREGARD_INLINE_LIMITS (decl) = 1;
+
/* Output the assembler code and/or RTL code for variables and functions,
unless the type is an undefined structure or union.
If not, it will get done when the type is completed. */
Index: tree-inline.c
===================================================================
*** tree-inline.c.orig 2007-08-27 11:25:41.000000000 +0200
--- tree-inline.c 2007-08-27 11:26:56.000000000 +0200
*************** inlinable_function_p (tree fn)
*** 1936,1955 ****
return inlinable;
}
- /* Return true if we shall disregard inlining limits for the function
- FN during inlining. */
-
- bool
- disregard_inline_limits_p (tree fn)
- {
- /* GNU extern inline functions are supposed to be cheap. */
- if (DECL_DECLARED_INLINE_P (fn)
- && DECL_EXTERNAL (fn))
- return true;
-
- return lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL_TREE;
- }
-
/* Estimate the cost of a memory move. Use machine dependent
word size and take possible memcpy call into account. */
--- 1936,1941 ----
Index: tree-inline.h
===================================================================
*** tree-inline.h.orig 2007-08-27 11:25:41.000000000 +0200
--- tree-inline.h 2007-08-27 11:26:56.000000000 +0200
*************** extern void insert_decl_map (copy_body_d
*** 130,136 ****
unsigned int optimize_inline_calls (tree);
bool tree_inlinable_function_p (tree);
- bool disregard_inline_limits_p (tree);
tree copy_tree_r (tree *, int *, void *);
void clone_body (tree, tree, void *);
void save_body (tree, tree *, tree *);
--- 130,135 ----
Index: c-common.c
===================================================================
*** c-common.c.orig 2007-08-27 11:25:41.000000000 +0200
--- c-common.c 2007-08-27 11:26:56.000000000 +0200
*************** handle_always_inline_attribute (tree *no
*** 4864,4871 ****
{
if (TREE_CODE (*node) == FUNCTION_DECL)
{
! /* Do nothing else, just set the attribute. We'll get at
! it later with lookup_attribute. */
}
else
{
--- 4864,4872 ----
{
if (TREE_CODE (*node) == FUNCTION_DECL)
{
! /* Set the attribute and mark it for disregarding inline
! limits. */
! DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
}
else
{
^ permalink raw reply [flat|nested] 3+ messages in thread