ipa-chkp.c: New.

[thirdparty/gcc.git] / gcc / tree-ssa-dce.c

diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index 68655b84d1f1e9ad990f718252cc7ea9e782fcac..923a0341fad582b971f2fea75276cdb9acb9f31a 100644 (file)
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -84,6 +84,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "flags.h"
 #include "cfgloop.h"
 #include "tree-scalar-evolution.h"
+#include "tree-chkp.h"
 
 static struct stmt_stats
 {
@@ -792,7 +793,21 @@ propagate_necessity (bool aggressive)
                  && (DECL_FUNCTION_CODE (def_callee) == BUILT_IN_ALIGNED_ALLOC
                      || DECL_FUNCTION_CODE (def_callee) == BUILT_IN_MALLOC
                      || DECL_FUNCTION_CODE (def_callee) == BUILT_IN_CALLOC))
-               continue;
+               {
+                 gimple bounds_def_stmt;
+                 tree bounds;
+
+                 /* For instrumented calls we should also check used
+                    bounds are returned by the same allocation call.  */
+                 if (!gimple_call_with_bounds_p (stmt)
+                     || ((bounds = gimple_call_arg (stmt, 1))
+                         && TREE_CODE (bounds) == SSA_NAME
+                         && (bounds_def_stmt = SSA_NAME_DEF_STMT (bounds))
+                         && chkp_gimple_call_builtin_p (bounds_def_stmt,
+                                                        BUILT_IN_CHKP_BNDRET)
+                         && gimple_call_arg (bounds_def_stmt, 0) == ptr))
+                   continue;
+               }
            }
 
          FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
@@ -1219,6 +1234,23 @@ eliminate_unnecessary_stmts (void)
                      && !gimple_plf (def_stmt, STMT_NECESSARY))
                    gimple_set_plf (stmt, STMT_NECESSARY, false);
                }
+             /* We did not propagate necessity for free calls fed
+                by allocation function to allow unnecessary
+                alloc-free sequence elimination.  For instrumented
+                calls it also means we did not mark bounds producer
+                as necessary and it is time to do it in case free
+                call is not removed.  */
+             if (gimple_call_with_bounds_p (stmt))
+               {
+                 gimple bounds_def_stmt;
+                 tree bounds = gimple_call_arg (stmt, 1);
+                 gcc_assert (TREE_CODE (bounds) == SSA_NAME);
+                 bounds_def_stmt = SSA_NAME_DEF_STMT (bounds);
+                 if (bounds_def_stmt
+                     && !gimple_plf (bounds_def_stmt, STMT_NECESSARY))
+                   gimple_set_plf (bounds_def_stmt, STMT_NECESSARY,
+                                   gimple_plf (stmt, STMT_NECESSARY));
+               }
            }
 
          /* If GSI is not necessary then remove it.  */
@@ -1249,7 +1281,9 @@ eliminate_unnecessary_stmts (void)
                          && DECL_FUNCTION_CODE (call) != BUILT_IN_CALLOC
                          && DECL_FUNCTION_CODE (call) != BUILT_IN_ALLOCA
                          && (DECL_FUNCTION_CODE (call)
-                             != BUILT_IN_ALLOCA_WITH_ALIGN))))
+                             != BUILT_IN_ALLOCA_WITH_ALIGN)))
+                 /* Avoid doing so for bndret calls for the same reason.  */
+                 && !chkp_gimple_call_builtin_p (stmt, BUILT_IN_CHKP_BNDRET))
                {
                  something_changed = true;
                  if (dump_file && (dump_flags & TDF_DETAILS))