cgraph.c (dump_cgraph_node): Add replace output flag by process.

	* cgraph.c (dump_cgraph_node): Add replace output flag by process.
	* cgraph.h (cgraph_node): Likewise.
	* cgraphunit.c (cgraph_process_new_functions): Set process flag.
	(cgraph_reset_node): Use process flag.
	(cgraph_mark_functions_to_output): Likewise.
	(cgraph_expand_function): Likewise.
	(cgraph_expand_all_functions): Likewise.
	(cgraph_output_in_order): Likewise.
	* dwarf2out.c (reference_to_unused): Likewise.
	* passes.c do_per_function_toporder): Likewise.

From-SVN: r145178

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index db8837c9797ab9271036b357cf12208d8810425f..f6adff60e5c93dc2a4ce8153c14f30a7e86f41c1 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,16 @@
+2009-03-28  Jan Hubicka  <jh@suse.cz>
+
+       * cgraph.c (dump_cgraph_node): Add replace output flag by process.
+       * cgraph.h (cgraph_node): Likewise.
+       * cgraphunit.c (cgraph_process_new_functions): Set process flag.
+       (cgraph_reset_node): Use process flag.
+       (cgraph_mark_functions_to_output): Likewise.
+       (cgraph_expand_function): Likewise.
+       (cgraph_expand_all_functions): Likewise.
+       (cgraph_output_in_order): Likewise.
+       * dwarf2out.c (reference_to_unused): Likewise.
+       * passes.c do_per_function_toporder): Likewise.
+
 2009-03-28  Jan Hubicka  <jh@suse.cz>
 
        Bring from lto-branch:

diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index d17d6a9c00d6ed0b977e07d2d110042ebf709d83..8eb0381d2bea1600d502626f1cf8028850d18b64 100644 (file)
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -1168,8 +1168,8 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node)
     fprintf (f, " reachable");
   if (gimple_has_body_p (node->decl))
     fprintf (f, " body");
-  if (node->output)
-    fprintf (f, " output");
+  if (node->process)
+    fprintf (f, " process");
   if (node->local.local)
     fprintf (f, " local");
   if (node->local.externally_visible)

diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index d2d310aa29ffd0c4154a5a2d28f5091915cb552a..0e01a659419adc6dea22a4c308ece7ea8042d315 100644 (file)
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -178,8 +178,8 @@ struct cgraph_node GTY((chain_next ("%h.next"), chain_prev ("%h.previous")))
   /* Set once the function has been instantiated and its callee
      lists created.  */
   unsigned analyzed : 1;
-  /* Set when function is scheduled to be assembled.  */
-  unsigned output : 1;
+  /* Set when function is scheduled to be processed by local passes.  */
+  unsigned process : 1;
   /* Set for aliases once they got through assemble_alias.  */
   unsigned alias : 1;
 

diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index d098db4de9aa77673f3d806c15cb8e5ea16e2977..9f6a50ddcbea5b519deb5915b955d237c00388cf 100644 (file)
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -426,7 +426,7 @@ cgraph_process_new_functions (void)
        case CGRAPH_STATE_EXPANSION:
          /* Functions created during expansion shall be compiled
             directly.  */
-         node->output = 0;
+         node->process = 0;
          cgraph_expand_function (node);
          break;
 
@@ -452,12 +452,12 @@ cgraph_process_new_functions (void)
 static void
 cgraph_reset_node (struct cgraph_node *node)
 {
-  /* If node->output is set, then we have already begun whole-unit analysis.
+  /* If node->process is set, then we have already begun whole-unit analysis.
      This is *not* testing for whether we've already emitted the function.
      That case can be sort-of legitimately seen with real function redefinition
      errors.  I would argue that the front end should never present us with
      such a case, but don't enforce that for now.  */
-  gcc_assert (!node->output);
+  gcc_assert (!node->process);
 
   /* Reset our data structures so we can analyze the function again.  */
   memset (&node->local, 0, sizeof (node->local));
@@ -990,7 +990,7 @@ cgraph_mark_functions_to_output (void)
       tree decl = node->decl;
       struct cgraph_edge *e;
 
-      gcc_assert (!node->output);
+      gcc_assert (!node->process);
 
       for (e = node->callers; e; e = e->next_caller)
        if (e->inline_failed)
@@ -1005,7 +1005,7 @@ cgraph_mark_functions_to_output (void)
              || (e && node->reachable))
          && !TREE_ASM_WRITTEN (decl)
          && !DECL_EXTERNAL (decl))
-       node->output = 1;
+       node->process = 1;
       else
        {
          /* We should've reclaimed all functions that are not needed.  */
@@ -1038,6 +1038,7 @@ cgraph_expand_function (struct cgraph_node *node)
   gcc_assert (!node->global.inlined_to);
 
   announce_function (decl);
+  node->process = 0;
 
   gcc_assert (node->lowered);
 
@@ -1093,16 +1094,16 @@ cgraph_expand_all_functions (void)
   /* Garbage collector may remove inline clones we eliminate during
      optimization.  So we must be sure to not reference them.  */
   for (i = 0; i < order_pos; i++)
-    if (order[i]->output)
+    if (order[i]->process)
       order[new_order_pos++] = order[i];
 
   for (i = new_order_pos - 1; i >= 0; i--)
     {
       node = order[i];
-      if (node->output)
+      if (node->process)
        {
          gcc_assert (node->reachable);
-         node->output = 0;
+         node->process = 0;
          cgraph_expand_function (node);
        }
     }
@@ -1151,7 +1152,7 @@ cgraph_output_in_order (void)
 
   for (pf = cgraph_nodes; pf; pf = pf->next)
     {
-      if (pf->output)
+      if (pf->process)
        {
          i = pf->order;
          gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
@@ -1191,7 +1192,7 @@ cgraph_output_in_order (void)
       switch (nodes[i].kind)
        {
        case ORDER_FUNCTION:
-         nodes[i].u.f->output = 0;
+         nodes[i].u.f->process = 0;
          cgraph_expand_function (nodes[i].u.f);
          break;
 

diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 1c82f9c09ff2d66963d9bf487a4b2ff69109592c..9bab2a42934d1283461933eb627a212019ada2d2 100644 (file)
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -11319,7 +11319,7 @@ reference_to_unused (tree * tp, int * walk_subtrees,
           && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
     {
       struct cgraph_node *node = cgraph_node (*tp);
-      if (!node->output)
+      if (node->process || TREE_ASM_WRITTEN (*tp))
        return *tp;
     }
   else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))

diff --git a/gcc/passes.c b/gcc/passes.c
index 4358b8202e6820d9fe7c13a0f3d63a9b160eba04..b77b518ccf8f22222734981770de3a93b7ad264f 100644 (file)
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -877,12 +877,15 @@ do_per_function_toporder (void (*callback) (void *data), void *data)
       gcc_assert (!order);
       order = GGC_NEWVEC (struct cgraph_node *, cgraph_n_nodes);
       nnodes = cgraph_postorder (order);
+      for (i = nnodes - 1; i >= 0; i--)
+        order[i]->process = 1;
       for (i = nnodes - 1; i >= 0; i--)
        {
          struct cgraph_node *node = order[i];
 
          /* Allow possibly removed nodes to be garbage collected.  */
          order[i] = NULL;
+         node->process = 0;
          if (node->analyzed && (node->needed || node->reachable))
            {
              push_cfun (DECL_STRUCT_FUNCTION (node->decl));