Fix handling of clobbers in ipa-modref.c

	* ipa-modref.c (analyze_stmt): Do not skip clobbers in early pass.
	* ipa-pure-const.c (analyze_stmt): Update comment.

diff --git a/gcc/ipa-modref.c b/gcc/ipa-modref.c
index 73a7900883a5020d49a1162bc672f1237386866b..728c6c1523dbc03e0049e7addea7041165165c2e 100644 (file)
--- a/gcc/ipa-modref.c
+++ b/gcc/ipa-modref.c
@@ -676,13 +676,16 @@ static bool
 analyze_stmt (modref_summary *summary, gimple *stmt, bool ipa,
              vec <gimple *> *recursive_calls)
 {
-  /* There is no need to record clobbers.  */
-  if (gimple_clobber_p (stmt))
+  /* In general we can not ignore clobbers because they are barries for code
+     motion, however after inlining it is safe to do becuase local optimization
+     passes do not consider clobbers from other functions.
+     Similar logic is in ipa-pure-consts.  */
+  if ((ipa || cfun->after_inlining) && gimple_clobber_p (stmt))
     return true;
+
   /* Analyze all loads and stores in STMT.  */
   walk_stmt_load_store_ops (stmt, summary,
                            analyze_load, analyze_store);
-  /* or call analyze_load_ipa, analyze_store_ipa */
 
   switch (gimple_code (stmt))
    {
@@ -705,7 +708,7 @@ analyze_stmt (modref_summary *summary, gimple *stmt, bool ipa,
    }
 }
 
-/* Analyze function F.  IPA indicates whether we're running in tree mode (false)
+/* Analyze function F.  IPA indicates whether we're running in local mode (false)
    or the IPA mode (true).  */
 
 static void

diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c
index bdbccd010dcc48f0d97faa64a8bf3aa3c6f7d4d4..1af3206056e493b9a35ce793e6944c1f40fd1689 100644 (file)
--- a/gcc/ipa-pure-const.c
+++ b/gcc/ipa-pure-const.c
@@ -742,6 +742,8 @@ check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa)
   /* Do consider clobber as side effects before IPA, so we rather inline
      C++ destructors and keep clobber semantics than eliminate them.
 
+     Similar logic is in ipa-modref.
+
      TODO: We may get smarter during early optimizations on these and let
      functions containing only clobbers to be optimized more.  This is a common
      case of C++ destructors.  */