* common.opt: Split up -fisolate-erroneous-paths into

	-fisolate-erroneous-paths-dereference and
	-fisolate-erroneous-paths-attribute.
	* invoke.texi: Corresponding changes.
	* gimple.c (infer_nonnull_range):  Add and use new arguments
	to control what kind of statements can be used to infer a
	non-null range.
	* gimple.h (infer_nonnull_range): Update prototype.
	* tree-vrp.c (infer_value_range): Corresponding changes.
	* opts.c (default_options_table): Update due to option split.
	* gimple-ssa-isolate-paths.c: Fix trailing whitespace.
	(find_implicit_erroneous_behaviour): Pass additional arguments
	to infer_nonnull_range.
	(find_explicit_erroneous_behaviour): Similarly.
	(gate_isolate_erroneous_paths): Check both of the new
	options.

testsuite/

	* gcc.dg/pr38984.c: Use -fno-isolate-erroneous-paths-dereference.
	* gcc.dg/tree-ssa/isolate-2.c: Explicitly turn on
	-fisolate-erroneous-paths-attribute.
	* gcc.dg/tree-ssa/isolate-4.c: Likewise.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@205689 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6c5d257ec82550e00ca76db8704892abdb7321fe..d2c0211dc7b4c7e7ae2222d0faa2490eeda85085 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -45,6 +45,25 @@
        (PROB_VERY_UNLIKELY, PROB_ALWAYS, PROB_VERY_LIKELY,
        PROB_LIKELY, PROB_UNLIKELY): Don't define here.
 
+2013-12-04  Jeff Law  <law@redhat.com>
+
+       * common.opt: Split up -fisolate-erroneous-paths into
+       -fisolate-erroneous-paths-dereference and
+       -fisolate-erroneous-paths-attribute.
+       * invoke.texi: Corresponding changes.
+       * gimple.c (infer_nonnull_range):  Add and use new arguments
+       to control what kind of statements can be used to infer a
+       non-null range.
+       * gimple.h (infer_nonnull_range): Update prototype.
+       * tree-vrp.c (infer_value_range): Corresponding changes.
+       * opts.c (default_options_table): Update due to option split.
+       * gimple-ssa-isolate-paths.c: Fix trailing whitespace.
+       (find_implicit_erroneous_behaviour): Pass additional arguments
+       to infer_nonnull_range.
+       (find_explicit_erroneous_behaviour): Similarly.
+       (gate_isolate_erroneous_paths): Check both of the new
+       options.
+       
 2013-12-04  Jeff Law  <law@redhat.com>
 
        * expr.c (expand_assignment): Update comments.

diff --git a/gcc/common.opt b/gcc/common.opt
index 9ece68324672c816096cda94402b63c5556bf2fb..0cd1fddd4adf4c5b654cd12806814624924608e6 100644 (file)
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -2112,11 +2112,18 @@ foptimize-strlen
 Common Report Var(flag_optimize_strlen) Optimization
 Enable string length optimizations on trees
 
-fisolate-erroneous-paths
-Common Report Var(flag_isolate_erroneous_paths) Optimization
-Detect paths which trigger erroneous or undefined behaviour.  Isolate those
-paths from the main control flow and turn the statement with erroneous or
-undefined behaviour into a trap.
+fisolate-erroneous-paths-dereference
+Common Report Var(flag_isolate_erroneous_paths_dereference) Optimization
+Detect paths which trigger erroneous or undefined behaviour due to
+dereferencing a NULL pointer.  Isolate those paths from the main control
+flow and turn the statement with erroneous or undefined behaviour into a trap.
+
+fisolate-erroneous-paths-attribute
+Common Report Var(flag_isolate_erroneous_paths_attribute) Optimization
+Detect paths which trigger erroneous or undefined behaviour due a NULL value
+being used in a way which is forbidden by a returns_nonnull or nonnull
+attribute.  Isolate those paths from the main control flow and turn the
+statement with erroneous or undefined behaviour into a trap. 
 
 ftree-loop-distribution
 Common Report Var(flag_tree_loop_distribution) Optimization

diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index b30e889764d406379f9819114090b8fe6710d7b0..704d4744dfd808e529cfd4be0e9f19c66e8907e6 100644 (file)
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -378,7 +378,7 @@ Objective-C and Objective-C++ Dialects}.
 -fira-region=@var{region} -fira-hoist-pressure @gol
 -fira-loop-pressure -fno-ira-share-save-slots @gol
 -fno-ira-share-spill-slots -fira-verbose=@var{n} @gol
--fisolate-erroneous-paths
+-fisolate-erroneous-paths-dereference -fisolate-erroneous-paths-attribute
 -fivopts -fkeep-inline-functions -fkeep-static-consts -flive-range-shrinkage @gol
 -floop-block -floop-interchange -floop-strip-mine -floop-nest-optimize @gol
 -floop-parallelize-all -flto -flto-compression-level @gol
@@ -6848,7 +6848,7 @@ also turns on the following optimization flags:
 -finline-small-functions @gol
 -findirect-inlining @gol
 -fipa-sra @gol
--fisolate-erroneous-paths @gol
+-fisolate-erroneous-paths-dereference @gol
 -foptimize-sibling-calls @gol
 -fpartial-inlining @gol
 -fpeephole2 @gol
@@ -7742,10 +7742,17 @@ it may significantly increase code size
 (see @option{--param ipcp-unit-growth=@var{value}}).
 This flag is enabled by default at @option{-O3}.
 
-@item -fisolate-erroneous-paths
-Detect paths which trigger erroneous or undefined behaviour.  Isolate those
-paths from the main control flow and turn the statement with erroneous or
-undefined behaviour into a trap.
+@item -fisolate-erroneous-paths-dereference
+Detect paths which trigger erroneous or undefined behaviour due to
+dereferencing a NULL pointer.  Isolate those paths from the main control
+flow and turn the statement with erroneous or undefined behaviour into a trap.
+
+@item -fisolate-erroneous-paths-attribute
+Detect paths which trigger erroneous or undefined behaviour due a NULL value
+being used in a way which is forbidden by a @code{returns_nonnull} or @code{nonnull}
+attribute.  Isolate those paths from the main control flow and turn the
+statement with erroneous or undefined behaviour into a trap.  This is not
+currently enabled, but may be enabled by @code{-O2} in the future.
 
 @item -ftree-sink
 @opindex ftree-sink

diff --git a/gcc/gimple-ssa-isolate-paths.c b/gcc/gimple-ssa-isolate-paths.c
index 440d2ed86d95c3672e92b0c31404c248380c1fcc..052bf3fbf944c0e5c48f0e8dbf3ad07a6078d620 100644 (file)
--- a/gcc/gimple-ssa-isolate-paths.c
+++ b/gcc/gimple-ssa-isolate-paths.c
@@ -48,7 +48,7 @@ along with GCC; see the file COPYING3.  If not see
 static bool cfg_altered;
 
 /* Callback for walk_stmt_load_store_ops.
- 
+
    Return TRUE if OP will dereference the tree stored in DATA, FALSE
    otherwise.
 
@@ -144,7 +144,6 @@ isolate_path (basic_block bb, basic_block duplicate,
   gimple_stmt_iterator si, si2;
   edge_iterator ei;
   edge e2;
-  
 
   /* First duplicate BB if we have not done so already and remove all
      the duplicate's outgoing edges as duplicate is going to unconditionally
@@ -171,7 +170,7 @@ isolate_path (basic_block bb, basic_block duplicate,
      the statement which triggers undefined behaviour.  If found, then
      transform the statement into a trap and delete everything after the
      statement.  If not found, then this particular instance was subsumed by
-     an earlier instance of undefined behaviour and there's nothing to do. 
+     an earlier instance of undefined behaviour and there's nothing to do.
 
      This is made more complicated by the fact that we have STMT, which is in
      BB rather than in DUPLICATE.  So we set up two iterators, one for each
@@ -180,7 +179,7 @@ isolate_path (basic_block bb, basic_block duplicate,
 
      When we find STMT the second iterator should point to STMT's equivalent in
      duplicate.  If DUPLICATE ends before STMT is found in BB, then there's
-     nothing to do. 
+     nothing to do.
 
      Ignore labels and debug statements.  */
   si = gsi_start_nondebug_after_labels_bb (bb);
@@ -247,7 +246,7 @@ find_implicit_erroneous_behaviour (void)
            continue;
 
          /* PHI produces a pointer result.  See if any of the PHI's
-            arguments are NULL. 
+            arguments are NULL.
 
             When we remove an edge, we want to reprocess the current
             index, hence the ugly way we update I for each iteration.  */
@@ -259,7 +258,7 @@ find_implicit_erroneous_behaviour (void)
              tree op = gimple_phi_arg_def (phi, i);
 
              next_i = i + 1;
-       
+
              if (!integer_zerop (op))
                continue;
 
@@ -277,7 +276,10 @@ find_implicit_erroneous_behaviour (void)
                  if (gimple_bb (use_stmt) != bb)
                    continue;
 
-                 if (infer_nonnull_range (use_stmt, lhs))
+                 if (infer_nonnull_range (use_stmt, lhs,
+                                          flag_isolate_erroneous_paths_dereference,
+                                          flag_isolate_erroneous_paths_attribute))
+
                    {
                      duplicate = isolate_path (bb, duplicate,
                                                e, use_stmt, lhs);
@@ -294,7 +296,7 @@ find_implicit_erroneous_behaviour (void)
 }
 
 /* Look for statements which exhibit erroneous behaviour.  For example
-   a NULL pointer dereference. 
+   a NULL pointer dereference.
 
    When found, optimize the block containing the erroneous behaviour.  */
 static void
@@ -327,7 +329,9 @@ find_explicit_erroneous_behaviour (void)
          /* By passing null_pointer_node, we can use infer_nonnull_range
             to detect explicit NULL pointer dereferences and other uses
             where a non-NULL value is required.  */
-         if (infer_nonnull_range (stmt, null_pointer_node))
+         if (infer_nonnull_range (stmt, null_pointer_node,
+                                  flag_isolate_erroneous_paths_dereference,
+                                  flag_isolate_erroneous_paths_attribute))
            {
              insert_trap_and_remove_trailing_statements (&si,
                                                          null_pointer_node);
@@ -361,7 +365,7 @@ find_explicit_erroneous_behaviour (void)
    unconditional trap and eliminate the outgoing edges from the statement's
    basic block.  This may expose secondary optimization opportunities.
 
-   In the latter case, we isolate the path(s) with the NULL PHI 
+   In the latter case, we isolate the path(s) with the NULL PHI
    feeding the dereference.  We can then replace the offending statement
    and eliminate the outgoing edges in the duplicate.  Again, this may
    expose secondary optimization opportunities.
@@ -398,7 +402,7 @@ gimple_ssa_isolate_erroneous_paths (void)
 
   free_original_copy_tables ();
 
-  /* We scramble the CFG and loop structures a bit, clean up 
+  /* We scramble the CFG and loop structures a bit, clean up
      appropriately.  We really should incrementally update the
      loop structures, in theory it shouldn't be that hard.  */
   if (cfg_altered)
@@ -416,7 +420,8 @@ gate_isolate_erroneous_paths (void)
 {
   /* If we do not have a suitable builtin function for the trap statement,
      then do not perform the optimization.  */
-  return (flag_isolate_erroneous_paths != 0);
+  return (flag_isolate_erroneous_paths_dereference != 0
+         || flag_isolate_erroneous_paths_attribute != 0);
 }
 
 namespace {

diff --git a/gcc/gimple.c b/gcc/gimple.c
index 7bc87bc34ee8442e5b1bfb321c8bc8d04621ac2e..f11362a6b169bf7e8b99f4a62c851ca17a6b143f 100644 (file)
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -2502,10 +2502,16 @@ check_loadstore (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data)
   return false;
 }
 
-/* If OP can be inferred to be non-zero after STMT executes, return true.  */
+/* If OP can be inferred to be non-NULL after STMT executes, return true.
+
+   DEREFERENCE is TRUE if we can use a pointer dereference to infer a
+   non-NULL range, FALSE otherwise.
+
+   ATTRIBUTE is TRUE if we can use attributes to infer a non-NULL range
+   for function arguments and return values.  FALSE otherwise.  */
 
 bool
-infer_nonnull_range (gimple stmt, tree op)
+infer_nonnull_range (gimple stmt, tree op, bool dereference, bool attribute)
 {
   /* We can only assume that a pointer dereference will yield
      non-NULL if -fdelete-null-pointer-checks is enabled.  */
@@ -2514,11 +2520,13 @@ infer_nonnull_range (gimple stmt, tree op)
       || gimple_code (stmt) == GIMPLE_ASM)
     return false;
 
-  if (walk_stmt_load_store_ops (stmt, (void *)op,
-                               check_loadstore, check_loadstore))
+  if (dereference
+      && walk_stmt_load_store_ops (stmt, (void *)op,
+                                  check_loadstore, check_loadstore))
     return true;
 
-  if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
+  if (attribute
+      && is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
     {
       tree fntype = gimple_call_fntype (stmt);
       tree attrs = TYPE_ATTRIBUTES (fntype);
@@ -2557,7 +2565,8 @@ infer_nonnull_range (gimple stmt, tree op)
 
   /* If this function is marked as returning non-null, then we can
      infer OP is non-null if it is used in the return statement.  */
-  if (gimple_code (stmt) == GIMPLE_RETURN
+  if (attribute
+      && gimple_code (stmt) == GIMPLE_RETURN
       && gimple_return_retval (stmt)
       && operand_equal_p (gimple_return_retval (stmt), op, 0)
       && lookup_attribute ("returns_nonnull",

diff --git a/gcc/gimple.h b/gcc/gimple.h
index a97a5e8b2d4301a17f0ebe85fd1c5e6a201d8195..c9d9a190a8b8b5bb52fc5baaa8073a83193abd38 100644 (file)
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -1259,7 +1259,7 @@ extern bool gimple_call_builtin_p (gimple, enum built_in_function);
 extern bool gimple_asm_clobbers_memory_p (const_gimple);
 extern void dump_decl_set (FILE *, bitmap);
 extern bool nonfreeing_call_p (gimple);
-extern bool infer_nonnull_range (gimple, tree);
+extern bool infer_nonnull_range (gimple, tree, bool, bool);
 extern void sort_case_labels (vec<tree> );
 extern void preprocess_case_label_vec_for_gimple (vec<tree> , tree, tree *);
 extern void gimple_seq_set_location (gimple_seq , location_t);

diff --git a/gcc/opts.c b/gcc/opts.c
index 7e61cbce7f86fd3556c7b4931fb71ecfb3add8c2..4cb2cdf4eff3bd68bee6aa97830a2f9b2701ca46 100644 (file)
--- a/gcc/opts.c
+++ b/gcc/opts.c
@@ -494,7 +494,7 @@ static const struct default_options default_options_table[] =
     { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_foptimize_strlen, NULL, 1 },
     { OPT_LEVELS_2_PLUS, OPT_fhoist_adjacent_loads, NULL, 1 },
     { OPT_LEVELS_2_PLUS, OPT_fipa_sem_equality, NULL, 1 },
-    { OPT_LEVELS_2_PLUS, OPT_fisolate_erroneous_paths, NULL, 1 },
+    { OPT_LEVELS_2_PLUS, OPT_fisolate_erroneous_paths_dereference, NULL, 1 },
 
     /* -O3 optimizations.  */
     { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 7779db737db5ab22a1dd5fc1daf166b6d391bba7..8b8426526ac2453f807d1ee59c7c020997a18ecc 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,10 @@
+2013-12-04  Jeff Law  <law@redhat.com>
+
+       * gcc.dg/pr38984.c: Use -fno-isolate-erroneous-paths-dereference.
+       * gcc.dg/tree-ssa/isolate-2.c: Explicitly turn on
+       -fisolate-erroneous-paths-attribute.
+       * gcc.dg/tree-ssa/isolate-4.c: Likewise.
+
 2013-12-04  Joseph Myers  <joseph@codesourcery.com>
 
        PR c/52023

diff --git a/gcc/testsuite/gcc.dg/pr38984.c b/gcc/testsuite/gcc.dg/pr38984.c
index 0c031805ea80fa5a16d434a3fa2666d42a973cfc..3ccb0e492fccc004e4372d6f7dbacf16f88f2e61 100644 (file)
--- a/gcc/testsuite/gcc.dg/pr38984.c
+++ b/gcc/testsuite/gcc.dg/pr38984.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */
-/* { dg-options "-O2 -fno-delete-null-pointer-checks -fdump-tree-optimized -fno-isolate-erroneous-paths" }
+/* { dg-options "-O2 -fno-delete-null-pointer-checks -fdump-tree-optimized -fno-isolate-erroneous-paths-dereference" }
  * */
 
 int f(int *p)

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/isolate-2.c b/gcc/testsuite/gcc.dg/tree-ssa/isolate-2.c
index 290b44c5bd430787defa356b97e9600c2cf8e6b2..bfcaa2b01daf8b889bc013c6efd8293e430f59ba 100644 (file)
--- a/gcc/testsuite/gcc.dg/tree-ssa/isolate-2.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/isolate-2.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */ 
-/* { dg-options "-O2 -fdump-tree-isolate-paths -fdump-tree-phicprop1" } */
+/* { dg-options "-O2 -fisolate-erroneous-paths-attribute -fdump-tree-isolate-paths -fdump-tree-phicprop1" } */
 
 
 int z;

diff --git a/gcc/testsuite/gcc.dg/tree-ssa/isolate-4.c b/gcc/testsuite/gcc.dg/tree-ssa/isolate-4.c
index 6937d25580ad02b88ba3a96dd4cc9cd1c0c49eca..c9c074df62b39129b606552ff20988c2962b1d20 100644 (file)
--- a/gcc/testsuite/gcc.dg/tree-ssa/isolate-4.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/isolate-4.c
@@ -1,5 +1,5 @@
 /* { dg-do compile } */ 
-/* { dg-options "-O2 -fdump-tree-isolate-paths -fdump-tree-phicprop1" } */
+/* { dg-options "-O2 -fisolate-erroneous-paths-attribute -fdump-tree-isolate-paths -fdump-tree-phicprop1" } */
 
 
 extern void foo(void *) __attribute__ ((__nonnull__ (1)));

diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index d98b7764b400c9c9e4e3aa0b5b7cdd8ee91d08dd..d9da99673cfb3f5c961eeea0f77c97e70fafeb27 100644 (file)
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -4541,7 +4541,7 @@ infer_value_range (gimple stmt, tree op, enum tree_code *comp_code_p, tree *val_
   if (stmt_ends_bb_p (stmt) && EDGE_COUNT (gimple_bb (stmt)->succs) == 0)
     return false;
 
-  if (infer_nonnull_range (stmt, op))
+  if (infer_nonnull_range (stmt, op, true, true))
     {
       *val_p = build_int_cst (TREE_TYPE (op), 0);
       *comp_code_p = NE_EXPR;