2006-02-08 Paolo Bonzini <bonzini@gnu.org>

[pf3gnuchains/gcc-fork.git] / gcc / passes.c

diff --git a/gcc/passes.c b/gcc/passes.c
index 8234ba1..5e02695 100644 (file)
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -304,10 +304,12 @@ struct tree_opt_pass *all_passes, *all_ipa_passes, *all_lowering_passes;
    enabled or not.  */
 
 static void
    enabled or not.  */
 
 static void

-register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int n)
+register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int properties)

 {
   char *dot_name, *flag_name, *glob_name;
 {
   char *dot_name, *flag_name, *glob_name;

+  const char *prefix;

   char num[10];
   char num[10];

+  int flags;

 
   /* See below in next_pass_1.  */
   num[0] = '\0';
 
   /* See below in next_pass_1.  */
   num[0] = '\0';


@@ -317,52 +319,34 @@ register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int n)
 
   dot_name = concat (".", pass->name, num, NULL);
   if (ipa)
 
   dot_name = concat (".", pass->name, num, NULL);
   if (ipa)

-    {
-      flag_name = concat ("ipa-", pass->name, num, NULL);
-      glob_name = concat ("ipa-", pass->name, NULL);
-      /* First IPA dump is cgraph that is dumped via separate channels.  */
-      pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
-                                                TDF_IPA, n + 1, 0);
-    }
-  else if (pass->properties_provided & PROP_trees)
-    {
-      flag_name = concat ("tree-", pass->name, num, NULL);
-      glob_name = concat ("tree-", pass->name, NULL);
-      pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
-                                                TDF_TREE, n + TDI_tree_all, 0);
-    }
+    prefix = "ipa-", flags = TDF_IPA;
+  else if (properties & PROP_trees)
+    prefix = "tree-", flags = TDF_TREE;

   else
   else

-    {
-      flag_name = concat ("rtl-", pass->name, num, NULL);
-      glob_name = concat ("rtl-", pass->name, NULL);
-      pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
-                                                TDF_RTL, n, pass->letter);
-    }
+    prefix = "rtl-", flags = TDF_RTL;
+
+  flag_name = concat (prefix, pass->name, num, NULL);
+  glob_name = concat (prefix, pass->name, NULL);
+  pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
+                                            flags, pass->letter);

 }
 
 }
 

+/* Recursive worker function for register_dump_files.  */
+

 static int 
 static int 

-register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
+register_dump_files_1 (struct tree_opt_pass *pass, bool ipa, int properties)

 {
 {

-  static int n = 0;

   do
     {
   do
     {

-      int new_properties;
-      int pass_number;
+      int new_properties = (properties | pass->properties_provided)
+                          & ~pass->properties_destroyed;

 
 

-      pass->properties_required = properties;
-      new_properties =
-        (properties | pass->properties_provided) & ~pass->properties_destroyed;
-
-      /* Reset the counter when we reach RTL-based passes.  */
-      if ((new_properties ^ pass->properties_required) & PROP_rtl)
-        n = 0;
-
-      pass_number = n;

       if (pass->name)
       if (pass->name)

-        n++;
+        register_one_dump_file (pass, ipa, new_properties);

 
       if (pass->sub)
 
       if (pass->sub)

-        new_properties = register_dump_files (pass->sub, false, new_properties);
+        new_properties = register_dump_files_1 (pass->sub, false,
+                                               new_properties);

 
       /* If we have a gate, combine the properties that we could have with
          and without the pass being examined.  */
 
       /* If we have a gate, combine the properties that we could have with
          and without the pass being examined.  */


@@ -371,10 +355,6 @@ register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
       else
         properties = new_properties;
 
       else
         properties = new_properties;
 

-      pass->properties_provided = properties;
-      if (pass->name)
-        register_one_dump_file (pass, ipa, pass_number);
-

       pass = pass->next;
     }
   while (pass);
       pass = pass->next;
     }
   while (pass);


@@ -382,13 +362,25 @@ register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
   return properties;
 }
 
   return properties;
 }
 

+/* Register the dump files for the pipeline starting at PASS.  IPA is
+   true if the pass is inter-procedural, and PROPERTIES reflects the
+   properties that are guarenteed to be available at the beginning of
+   the pipeline.  */
+
+static void 
+register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
+{
+  pass->properties_required |= properties;
+  pass->todo_flags_start |= TODO_set_props;
+  register_dump_files_1 (pass, ipa, properties);
+}
+

 /* Add a pass to the pass list. Duplicate the pass if it's already
    in the list.  */
 
 static struct tree_opt_pass **
 next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
 {
 /* Add a pass to the pass list. Duplicate the pass if it's already
    in the list.  */
 
 static struct tree_opt_pass **
 next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
 {

-

   /* A nonzero static_pass_number indicates that the
      pass is already in the list.  */
   if (pass->static_pass_number)
   /* A nonzero static_pass_number indicates that the
      pass is already in the list.  */
   if (pass->static_pass_number)


@@ -699,23 +691,32 @@ init_optimization_passes (void)
 #undef NEXT_PASS
 
   /* Register the passes with the tree dump code.  */
 #undef NEXT_PASS
 
   /* Register the passes with the tree dump code.  */

-  register_dump_files (all_ipa_passes, true, PROP_gimple_leh | PROP_cfg);
+  register_dump_files (all_ipa_passes, true,
+                      PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
+                      | PROP_cfg);

   register_dump_files (all_lowering_passes, false, PROP_gimple_any);
   register_dump_files (all_lowering_passes, false, PROP_gimple_any);

-  register_dump_files (all_passes, false, PROP_gimple_leh | PROP_cfg);
+  register_dump_files (all_passes, false,
+                      PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
+                      | PROP_cfg);

 }
 
 static unsigned int last_verified;
 }
 
 static unsigned int last_verified;

+static unsigned int curr_properties;
+

 static void
 static void

-execute_todo (struct tree_opt_pass *pass, unsigned int flags, bool use_required)
+execute_todo (unsigned int flags)

 {
 {

-  int properties 
-    = use_required ? pass->properties_required : pass->properties_provided;
-

 #if defined ENABLE_CHECKING
   if (need_ssa_update_p ())
     gcc_assert (flags & TODO_update_ssa_any);
 #endif
 
 #if defined ENABLE_CHECKING
   if (need_ssa_update_p ())
     gcc_assert (flags & TODO_update_ssa_any);
 #endif
 

+  if (curr_properties & PROP_ssa)
+    flags |= TODO_verify_ssa;
+  flags &= ~last_verified;
+  if (!flags)
+    return;
+

   /* Always cleanup the CFG before doing anything else.  */
   if (flags & TODO_cleanup_cfg)
     {
   /* Always cleanup the CFG before doing anything else.  */
   if (flags & TODO_cleanup_cfg)
     {


@@ -738,6 +739,7 @@ execute_todo (struct tree_opt_pass *pass, unsigned int flags, bool use_required)
     {
       unsigned update_flags = flags & TODO_update_ssa_any;
       update_ssa (update_flags);
     {
       unsigned update_flags = flags & TODO_update_ssa_any;
       update_ssa (update_flags);

+      last_verified &= ~TODO_verify_ssa;

     }
 
   if (flags & TODO_remove_unused_locals)
     }
 
   if (flags & TODO_remove_unused_locals)


@@ -746,19 +748,19 @@ execute_todo (struct tree_opt_pass *pass, unsigned int flags, bool use_required)
   if ((flags & TODO_dump_func)
       && dump_file && current_function_decl)
     {
   if ((flags & TODO_dump_func)
       && dump_file && current_function_decl)
     {

-      if (properties & PROP_trees)
+      if (curr_properties & PROP_trees)

         dump_function_to_file (current_function_decl,
                                dump_file, dump_flags);
       else
        {
          if (dump_flags & TDF_SLIM)
            print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
         dump_function_to_file (current_function_decl,
                                dump_file, dump_flags);
       else
        {
          if (dump_flags & TDF_SLIM)
            print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);

-         else if (properties & PROP_cfg)
+         else if (curr_properties & PROP_cfg)

            print_rtl_with_bb (dump_file, get_insns ());
           else
            print_rtl (dump_file, get_insns ());
 
            print_rtl_with_bb (dump_file, get_insns ());
           else
            print_rtl (dump_file, get_insns ());
 

-         if (properties & PROP_cfg
+         if (curr_properties & PROP_cfg

              && graph_dump_format != no_graph
              && (dump_flags & TDF_GRAPH))
            print_rtl_graph_with_bb (dump_file_name, get_insns ());
              && graph_dump_format != no_graph
              && (dump_flags & TDF_GRAPH))
            print_rtl_graph_with_bb (dump_file_name, get_insns ());


@@ -783,8 +785,7 @@ execute_todo (struct tree_opt_pass *pass, unsigned int flags, bool use_required)
     }
 
 #if defined ENABLE_CHECKING
     }
 
 #if defined ENABLE_CHECKING

-  if ((pass->properties_required & PROP_ssa)
-      && !(pass->properties_destroyed & PROP_ssa))
+  if (flags & TODO_verify_ssa)

     verify_ssa (true);
   if (flags & TODO_verify_flow)
     verify_flow_info ();
     verify_ssa (true);
   if (flags & TODO_verify_flow)
     verify_flow_info ();


@@ -793,30 +794,36 @@ execute_todo (struct tree_opt_pass *pass, unsigned int flags, bool use_required)
   if (flags & TODO_verify_loops)
     verify_loop_closed_ssa ();
 #endif
   if (flags & TODO_verify_loops)
     verify_loop_closed_ssa ();
 #endif

+
+  last_verified = flags & TODO_verify_all;

 }
 
 static bool
 execute_one_pass (struct tree_opt_pass *pass)
 {
 }
 
 static bool
 execute_one_pass (struct tree_opt_pass *pass)
 {

-  unsigned int todo; 
+  bool initializing_dump;

 
   /* See if we're supposed to run this pass.  */
   if (pass->gate && !pass->gate ())
     return false;
 
 
   /* See if we're supposed to run this pass.  */
   if (pass->gate && !pass->gate ())
     return false;
 

+  if (pass->todo_flags_start & TODO_set_props)
+    curr_properties = pass->properties_required;
+

   /* Note that the folders should only create gimple expressions.
      This is a hack until the new folder is ready.  */
   /* Note that the folders should only create gimple expressions.
      This is a hack until the new folder is ready.  */

-  in_gimple_form = (pass->properties_provided & PROP_trees) != 0;
+  in_gimple_form = (curr_properties & PROP_trees) != 0;

 
   /* Run pre-pass verification.  */
 
   /* Run pre-pass verification.  */

-  todo = pass->todo_flags_start & ~last_verified;
-  if (todo)
-    execute_todo (pass, todo, true);
+  execute_todo (pass->todo_flags_start);
+
+  gcc_assert ((curr_properties & pass->properties_required)
+             == pass->properties_required);

 
   /* If a dump file name is present, open it if enabled.  */
   if (pass->static_pass_number != -1)
     {
 
   /* If a dump file name is present, open it if enabled.  */
   if (pass->static_pass_number != -1)
     {

-      bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
+      initializing_dump = !dump_initialized_p (pass->static_pass_number);

       dump_file_name = get_dump_file_name (pass->static_pass_number);
       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
       if (dump_file && current_function_decl)
       dump_file_name = get_dump_file_name (pass->static_pass_number);
       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
       if (dump_file && current_function_decl)


@@ -832,18 +839,9 @@ execute_one_pass (struct tree_opt_pass *pass)
             ? " (unlikely executed)"
             : "");
        }
             ? " (unlikely executed)"
             : "");
        }

-
-      if (initializing_dump
-         && dump_file
-         && graph_dump_format != no_graph
-         && (pass->properties_provided & (PROP_cfg | PROP_rtl))
-             == (PROP_cfg | PROP_rtl))
-       {
-         get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
-         dump_flags |= TDF_GRAPH;
-         clean_graph_dump_file (dump_file_name);
-       }

     }
     }

+  else
+    initializing_dump = false;

 
   /* If a timevar is present, start it.  */
   if (pass->tv_id)
 
   /* If a timevar is present, start it.  */
   if (pass->tv_id)


@@ -851,17 +849,30 @@ execute_one_pass (struct tree_opt_pass *pass)
 
   /* Do it!  */
   if (pass->execute)
 
   /* Do it!  */
   if (pass->execute)

-    pass->execute ();
+    {
+      pass->execute ();
+      last_verified = 0;
+    }

 
   /* Stop timevar.  */
   if (pass->tv_id)
     timevar_pop (pass->tv_id);
 
 
   /* Stop timevar.  */
   if (pass->tv_id)
     timevar_pop (pass->tv_id);
 

+  curr_properties = (curr_properties | pass->properties_provided)
+                   & ~pass->properties_destroyed;
+
+  if (initializing_dump
+      && dump_file
+      && graph_dump_format != no_graph
+      && (curr_properties & (PROP_cfg | PROP_rtl)) == (PROP_cfg | PROP_rtl))
+    {
+      get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
+      dump_flags |= TDF_GRAPH;
+      clean_graph_dump_file (dump_file_name);
+    }
+

   /* Run post-pass cleanup and verification.  */
   /* Run post-pass cleanup and verification.  */

-  todo = pass->todo_flags_finish;
-  last_verified = todo & TODO_verify_all;
-  if (todo)
-    execute_todo (pass, todo, false);
+  execute_todo (pass->todo_flags_finish);

 
   /* Flush and close dump file.  */
   if (dump_file_name)
 
   /* Flush and close dump file.  */
   if (dump_file_name)