[PATCH] Restore disregarding inlining limits for extern inline functions

[PATCH] Restore disregarding inlining limits for extern inline functions

[Richard Guenther]

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.

Index: tree-inline.c
===================================================================
*** tree-inline.c	(revision 127658)
--- tree-inline.c	(working copy)
*************** inlinable_function_p (tree fn)
*** 1920,1925 ****
--- 1920,1930 ----
  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;
  }
  

Re: [PATCH] Restore disregarding inlining limits for extern inline functions

[Richard Guenther]

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.

Thanks,
Richard.

> 
> Index: tree-inline.c
> ===================================================================
> *** tree-inline.c	(revision 127658)
> --- tree-inline.c	(working copy)
> *************** inlinable_function_p (tree fn)
> *** 1920,1925 ****
> --- 1920,1930 ----
>   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;
>   }
>   
> 

-- 
Richard Guenther <rguenther@suse.de>
Novell / SUSE Labs
SUSE LINUX Products GmbH - Nuernberg - AG Nuernberg - HRB 16746 - GF: Markus Rex

Re: [PATCH] Restore disregarding inlining limits for extern inline functions

[Richard Guenther]

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
      {