tree.h (DID_INLINE_FUNC): Remove macro.

2003-08-05  Steven Bosscher  <steven@gcc.gnu.org>

	* tree.h (DID_INLINE_FUNC): Remove macro.
	(DECL_DECLARED_INLINE_P): Move from c-tree.h and cp/cp-tree.h,
	add tree check for FUNCTION_DECL.
	(DECL_ESTIMATED_INSNS): Move from c-common.h and java/java-tree.h.
	(struct tree_decl): Rename inlined_function_flag to
	declared_inline_flag.
	* c-common.h (c_lang_decl): Remove.
	(DECL_ESTIMATED_INSNS): Remove.
	* c-tree.h (struct lang_decl): Don't include c_lang_decl.
	(DECL_DECLARED_INLINE_P): Remove.
	* c-decl.c (grokdeclarator): Update comment.  With -finline-functions,
	do not reset DECL_DECLARED_INLINE_P.  Don't use DID_INLINE_FUNC.
	(finish_function): Make uninlinable a bool.  Fixup call to
	tree_inlinable_function_p() and fix some code style issues.
	* cgraph.h (disgread_inline_limits): Fix spelling: `disregard'.
	* cgraph.c (dump_cgraph): Likewise.
	* cgraphunit.c (cgraph_decide_inlining): Likewise
	(cgraph_finalize_compilation_unit): Likewise.
	Also update call to tree_inlinable_function_p().
	(cgraph_default_inline_p): Don't use DID_INLINE_FUNC.  Instead
	look at DECL_DECLARED_INLINE and reverse logic.
	* print-tree.c (print_node): Likewise.
	* toplev.c (rest_of_handle_inlining): Don't use DID_INLINE_FUNC.
	* tree-inline.h (tree_inlinable_function_p): Make a bool.  Update
	prototype.
	* tree-inline.c (inlinable_function_p): Split up in this function to
	check for basic inlining inhibiting conditions, and new
	limits_allow_inlining() function.  Warn if inlining is impossible
	because the inline candidate calls alloca or uses sjlj exceptions.
	(limits_allow_inlining): this new function to check if the inlining
	limits are satisfied.  Throttle from currfn_max_inline_insns, not from
	MAX_INLINE_INSNS_SINGLE.  The latter only makes sense if
	MAX_INLINE_INSNS_AUTO and MAX_INLINE_INSNS_SINGLE are equal.
	Update prototypes.
	(tree_inlinable_function_p): Make a bool.  Update call to
	inlinable_function_p
	(expand_call_inline): Use limits_allow_inlining() when not in
	unit-at-a-time mode to decide on inlining.  Don't use DID_INLINE_FUNC,
	instead see if the function was declared `inline'.

cp/
	* cp-tree.h (struct lang_decl): Don't include c_lang_decl.
	(DECL_DECLARED_INLINE_P): Remove.
	* decl2.c (import_export_decl): Only look at DECL_DECLARED_INLINE_P
	if decl is a FUNCTION_DECL.  This never made sense, but now it is
	required to avoid a tree check failure.
	* decl.c (grokfndecl): Don't touch DID_INLINE_FUNC.
	* optimize.c (maybe_clone_body): Likewise.

java/
	* java-tree.h (DECL_ESTIMATED_INSNS): Remove.

From-SVN: r70174

1 files changed, 13 insertions, 13 deletions

diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 5e37235..b75c717 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -189,12 +189,12 @@ cgraph_finalize_compilation_unit (void)
       /* First kill forward declaration so reverse inlining works properly.  */
       cgraph_create_edges (decl, DECL_SAVED_TREE (decl));
 
-      node->local.inlinable = tree_inlinable_function_p (decl, 1);
+      node->local.inlinable = tree_inlinable_function_p (decl);
       DECL_ESTIMATED_INSNS (decl)
         = (*lang_hooks.tree_inlining.estimate_num_insns) (decl);
       node->local.self_insns = DECL_ESTIMATED_INSNS (decl);
       if (node->local.inlinable)
-	node->local.disgread_inline_limits
+	node->local.disregard_inline_limits
 	  = (*lang_hooks.tree_inlining.disregard_inline_limits) (decl);
 
       for (edge = node->callees; edge; edge = edge->next_callee)
@@ -321,7 +321,7 @@ cgraph_postorder (struct cgraph_node **order)
   struct cgraph_edge *edge, last;
 
   struct cgraph_node **stack =
-    xcalloc (sizeof (struct cgraph_node *), cgraph_n_nodes);
+    xcalloc (cgraph_n_nodes, sizeof (struct cgraph_node *));
 
   /* We have to deal with cycles nicely, so use a depth first traversal
      output algorithm.  Ignore the fact that some functions won't need
@@ -735,10 +735,10 @@ cgraph_default_inline_p (struct cgraph_node *n)
 {
   if (!DECL_INLINE (n->decl) || !DECL_SAVED_TREE (n->decl))
     return false;
-  if (DID_INLINE_FUNC (n->decl))
-    return n->global.insns < MAX_INLINE_INSNS_AUTO;
-  else
+  if (DECL_DECLARED_INLINE_P (n->decl))
     return n->global.insns < MAX_INLINE_INSNS_SINGLE;
+  else
+    return n->global.insns < MAX_INLINE_INSNS_AUTO;
 }
 
 /* We use greedy algorithm for inlining of small functions:
@@ -756,7 +756,7 @@ cgraph_decide_inlining_of_small_functions (struct cgraph_node **inlined,
   struct cgraph_node *node;
   fibheap_t heap = fibheap_new ();
   struct fibnode **heap_node =
-    xcalloc (sizeof (struct fibnode *), cgraph_max_uid);
+    xcalloc (cgraph_max_uid, sizeof (struct fibnode *));
   int ninlined, ninlined_callees;
   int max_insns = ((HOST_WIDEST_INT) initial_insns
 		   * (100 + PARAM_VALUE (PARAM_INLINE_UNIT_GROWTH)) / 100);
@@ -873,11 +873,11 @@ cgraph_decide_inlining (void)
   struct cgraph_node *node;
   int nnodes;
   struct cgraph_node **order =
-    xcalloc (sizeof (struct cgraph_node *), cgraph_n_nodes);
+    xcalloc (cgraph_n_nodes, sizeof (struct cgraph_node *));
   struct cgraph_node **inlined =
-    xcalloc (sizeof (struct cgraph_node *), cgraph_n_nodes);
+    xcalloc (cgraph_n_nodes, sizeof (struct cgraph_node *));
   struct cgraph_node **inlined_callees =
-    xcalloc (sizeof (struct cgraph_node *), cgraph_n_nodes);
+    xcalloc (cgraph_n_nodes, sizeof (struct cgraph_node *));
   int ninlined;
   int ninlined_callees;
   int i, y;
@@ -917,7 +917,7 @@ cgraph_decide_inlining (void)
       node = order[i];
 
       for (e = node->callees; e; e = e->next_callee)
-	if (e->callee->local.disgread_inline_limits)
+	if (e->callee->local.disregard_inline_limits)
 	  break;
       if (!e)
 	continue;
@@ -928,7 +928,7 @@ cgraph_decide_inlining (void)
       ninlined = cgraph_inlined_into (order[i], inlined);
       for (; e; e = e->next_callee)
 	{
-	  if (e->inline_call || !e->callee->local.disgread_inline_limits)
+	  if (e->inline_call || !e->callee->local.disregard_inline_limits)
 	    continue;
 	  if (e->callee->output || e->callee == node)
 	    continue;
@@ -1038,7 +1038,7 @@ cgraph_expand_functions (void)
 {
   struct cgraph_node *node;
   struct cgraph_node **order =
-    xcalloc (sizeof (struct cgraph_node *), cgraph_n_nodes);
+    xcalloc (cgraph_n_nodes, sizeof (struct cgraph_node *));
   int order_pos = 0;
   int i;