This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [RFC] Isolate & simplify paths with undefined behaviour


On Fri, Oct 18, 2013 at 7:12 PM, Jeff Law <law@redhat.com> wrote:
>
>
> Back in 2011 I wrote code to detect cases when traversing a particular path
> could be proven to trigger undefined behaviour (such as a null pointer
> dereference).  That original patch would find the control dependent edges
> leading to the dereference and eliminate those edges. The result being those
> paths with undefined behaviour simply vanished.
>
> The problem with that implementation is there could have been observable
> side effects on those paths prior to triggering the undefined behaviour.
>
> At that time I speculated we could isolate the path (via block copying) with
> undefined behaviour.  On the duplicate path we'd replace the undefined
> behaviour with a trap and remove only the outgoing edges. That would still
> preserve any visible side effects on the undefined path up to the undefined
> behaviour and we still often get to simplify the main path, though not as
> much as the original version from 2011.
>
> That's precisely what this patch does.  When we have a PHI which feeds a
> memory dereference in the same block as the PHI and one (or more) of the PHI
> args is NULL we duplicate the block, redirect incoming edges with the NULL
> PHI args to the duplicate and change the statement with the memory
> dereference to a trap.
>
> You can certainly ask is this actually helpful.  In my experience, yes.  I'm
> regularly seeing stuff like
>
> x2 = PHI (x1, x1, 0, 0);
> *x2
>
> When we isolate the paths with NULL incoming values, we're left with
> x2 = PHI (x1, x1)
>
> And we can propagate x1 into uses of x2.  The block now has just one pred
> and the current block can sometimes be merged into that single pred.  I've
> seen the combination of those two then lead to identification additional
> common subexpressions.
>
> You might also ask how often such paths show up.  In a bootstrap about a
> week ago, this triggered ~3500 times.
>
> The code tries to be reasonably smart and re-use an existing duplicate when
> there's multiple NULL values in a PHI node.  That triggers often enough to
> be worth the marginal amount of book keeping.
>
> The code doesn't yet handle the case where there's multiple dereferences in
> the block.  There's no guarantee the first dereference will be the first one
> we find on the immediate use list.  It's on my TODO list.
>
>
> There's no reason this same framework couldn't be used to do the same thing
> for an out of bounds array access.  Similarly, it wouldn't be hard to issue
> a warning when these transformations are applied.
>
> Posting at this time to get some feedback.  Planning a formal RFA prior to
> close of 4.9 stage1.
>
> And, of course, this bootstrapps and regression tests.  20030711-3 is
> clearly optimized further with this patch, but I'll cobble together some
> more testcases next week.
>
>
> I'm not familiar with the options stuff, so if someone could look at that
> more closely, I'd appreciate it.  Similarly for  the bits to create a new
> pass structure.
>
>
> Thoughts, comments, flames?

I wonder why this isn't part of the regular jump-threading code - after
all the opportunity is to thead to __builtin_unreachable () ;)  Otherwise
the question is always where you'd place this pass and whether it
enables jump threading or CSE opportunities (that at least it does).

Richard.

>
>
>
>
>
>         * Makefile.in (OBJS): Add tree-ssa-isolate-paths.
>         * common.opt (-ftree-isolate-paths): Add option and documentation.
>         * opts.c (default_options_table): Add OPT_ftree_isolate_paths.
>         * passes.def: Add path isolation pass.
>         * timevar.def (TV_TREE_SSA_ISOLATE_PATHS): New timevar.
>         * tree-pass.h (make_isolate_paths): Declare.
>         * tree-ssa-isolate-paths.c: New file.
>
>         * gcc.dg/pr38984.c: Add -fno-tree-isolate-paths.
>         * gcc.dg/tree-ssa/20030711-3.c: Update expected output.
>
>         * testsuite/libmudflap.c/fail20-frag.c: Add -fno-tree-isolate-paths.
>
>
> diff --git a/gcc/Makefile.in b/gcc/Makefile.in
> index ba39ac9..e7c18bc 100644
> --- a/gcc/Makefile.in
> +++ b/gcc/Makefile.in
> @@ -1412,6 +1412,7 @@ OBJS = \
>         tree-ssa-dse.o \
>         tree-ssa-forwprop.o \
>         tree-ssa-ifcombine.o \
> +       tree-ssa-isolate-paths.o \
>         tree-ssa-live.o \
>         tree-ssa-loop-ch.o \
>         tree-ssa-loop-im.o \
> diff --git a/gcc/common.opt b/gcc/common.opt
> index 1f11fcd..1fd1bcc 100644
> --- a/gcc/common.opt
> +++ b/gcc/common.opt
> @@ -2104,6 +2104,12 @@ foptimize-strlen
>  Common Report Var(flag_optimize_strlen) Optimization
>  Enable string length optimizations on trees
>
> +ftree-isolate-paths
> +Common Report Var(flag_tree_isolate_paths) Init(1) Optimization
> +Detect paths which trigger undefined behaviour.  Isolate those paths from
> +the main control flow and turn the statement with undefined behaviour into
> +a trap.
> +
>  ftree-loop-distribution
>  Common Report Var(flag_tree_loop_distribution) Optimization
>  Enable loop distribution on trees
> diff --git a/gcc/opts.c b/gcc/opts.c
> index 728d36d..b6ed0c2 100644
> --- a/gcc/opts.c
> +++ b/gcc/opts.c
> @@ -453,6 +453,7 @@ static const struct default_options
> default_options_table[] =
>      { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
>      { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
>      { OPT_LEVELS_1_PLUS, OPT_fcompare_elim, NULL, 1 },
> +    { OPT_LEVELS_1_PLUS, OPT_ftree_isolate_paths, NULL, 1 },
>      { OPT_LEVELS_1_PLUS, OPT_ftree_slsr, NULL, 1 },
>
>      /* -O2 optimizations.  */
> diff --git a/gcc/passes.def b/gcc/passes.def
> index 84eb3f3..1f2c810 100644
> --- a/gcc/passes.def
> +++ b/gcc/passes.def
> @@ -173,6 +173,13 @@ along with GCC; see the file COPYING3.  If not see
>          only examines PHIs to discover const/copy propagation
>          opportunities.  */
>        NEXT_PASS (pass_phi_only_cprop);
> +      /* At this point the majority of const/copy propagations
> +        are exposed.  Go ahead and identify paths that should never
> +        be executed in a conforming program and isolate those paths.
> +
> +        This will simplify the CFG in the main path and provide PRE
> +        DOM and other passes additional opportunities to optimize.  */
> +      NEXT_PASS (pass_isolate_paths);
>        NEXT_PASS (pass_dse);
>        NEXT_PASS (pass_reassoc);
>        NEXT_PASS (pass_dce);
> diff --git a/gcc/testsuite/gcc.dg/pr38984.c b/gcc/testsuite/gcc.dg/pr38984.c
> index 11f1e7f..196ca39 100644
> --- 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"
> }
> +/* { dg-options "-O2 -fno-delete-null-pointer-checks -fdump-tree-optimized
> -fno-tree-isolate-paths" }
>   * */
>
>  int f(int *p)
> diff --git a/gcc/testsuite/gcc.dg/tree-ssa/20030711-3.c
> b/gcc/testsuite/gcc.dg/tree-ssa/20030711-3.c
> index ec04e17..bcd5681 100644
> --- a/gcc/testsuite/gcc.dg/tree-ssa/20030711-3.c
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/20030711-3.c
> @@ -52,10 +52,10 @@ get_alias_set (t)
>  /* There should be one load of decl.rtl.  */
>  /* { dg-final { scan-tree-dump-times "decl\\.rtl" 1 "dom2"} } */
>
> -/* There should be two loads of rtmem.  */
> -/* { dg-final { scan-tree-dump-times "rtmem" 2 "dom2"} } */
> +/* There should be one load of rtmem.  */
> +/* { dg-final { scan-tree-dump-times "rtmem" 1 "dom2"} } */
>
> -/* There should be one load of alias.  */
> -/* { dg-final { scan-tree-dump-times "->alias" 1 "dom2"} } */
> +/* There should be no load of alias.  */
> +/* { dg-final { scan-tree-dump-not "->alias" "dom2"} } */
>
>  /* { dg-final { cleanup-tree-dump "dom2" } } */
> diff --git a/gcc/timevar.def b/gcc/timevar.def
> index 5a880a8..119bd95 100644
> --- a/gcc/timevar.def
> +++ b/gcc/timevar.def
> @@ -144,6 +144,7 @@ DEFTIMEVAR (TV_TREE_SSA_INCREMENTAL  , "tree SSA
> incremental")
>  DEFTIMEVAR (TV_TREE_OPS                     , "tree operand scan")
>  DEFTIMEVAR (TV_TREE_SSA_DOMINATOR_OPTS   , "dominator optimization")
>  DEFTIMEVAR (TV_TREE_SRA              , "tree SRA")
> +DEFTIMEVAR (TV_TREE_SSA_ISOLATE_PATHS    , "tree SSA isolate paths")
>  DEFTIMEVAR (TV_TREE_CCP                     , "tree CCP")
>  DEFTIMEVAR (TV_TREE_PHI_CPROP       , "tree PHI const/copy prop")
>  DEFTIMEVAR (TV_TREE_SPLIT_EDGES      , "tree split crit edges")
> diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h
> index e72fe9a..30a3afd 100644
> --- a/gcc/tree-pass.h
> +++ b/gcc/tree-pass.h
> @@ -427,6 +427,7 @@ extern gimple_opt_pass *make_pass_sink_code
> (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_fre (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_check_data_deps (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_copy_prop (gcc::context *ctxt);
> +extern gimple_opt_pass *make_pass_isolate_paths (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_vrp (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_uncprop (gcc::context *ctxt);
>  extern gimple_opt_pass *make_pass_return_slot (gcc::context *ctxt);
> diff --git a/libmudflap/testsuite/libmudflap.c/fail20-frag.c
> b/libmudflap/testsuite/libmudflap.c/fail20-frag.c
> index 0dd8bb7..54200cc 100644
> --- a/libmudflap/testsuite/libmudflap.c/fail20-frag.c
> +++ b/libmudflap/testsuite/libmudflap.c/fail20-frag.c
> @@ -11,3 +11,4 @@ return 0;
>  /* { dg-output "Nearby object 1.*" } */
>  /* { dg-output "mudflap object.*.NULL.*" } */
>  /* { dg-do run { xfail *-*-* } } */
> +/* { dg-options "-lmudflap -fmudflap -fno-tree-isolate-paths" } */
> *** /dev/null   Mon Sep 30 09:08:45 2013
> --- tree-ssa-isolate-paths.c    Thu Oct 17 15:38:23 2013
> ***************
> *** 0 ****
> --- 1,399 ----
> + /* Detect paths through the CFG which can never be executed in a
> conforming
> +    program and isolate them.
> +
> +    Copyright (C) 2013
> +    Free Software Foundation, Inc.
> +
> + This file is part of GCC.
> +
> + GCC is free software; you can redistribute it and/or modify
> + it under the terms of the GNU General Public License as published by
> + the Free Software Foundation; either version 3, or (at your option)
> + any later version.
> +
> + GCC is distributed in the hope that it will be useful,
> + but WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + GNU General Public License for more details.
> +
> + You should have received a copy of the GNU General Public License
> + along with GCC; see the file COPYING3.  If not see
> + <http://www.gnu.org/licenses/>.  */
> +
> + #include "config.h"
> + #include "system.h"
> + #include "coretypes.h"
> + #include "tm.h"
> + #include "tree.h"
> + #include "flags.h"
> + #include "tm_p.h"
> + #include "basic-block.h"
> + #include "output.h"
> + #include "function.h"
> + #include "tree-pretty-print.h"
> + #include "gimple-pretty-print.h"
> + #include "timevar.h"
> + #include "tree-dump.h"
> + #include "tree-flow.h"
> + #include "tree-pass.h"
> + #include "tree-ssa.h"
> + #include "tree-ssa-propagate.h"
> + #include "langhooks.h"
> + #include "cfgloop.h"
> +
> +
> + /* Note if we've optimized anything and thus want to run CFG cleanups
> +    when this pass is complete.  Obviously if this pass does nothing, then
> +    CFG cleanups would be a waste of time.  */
> + bool cfg_altered;
> +
> + /* BB when reached via incoming edge E will exhibit undefined behaviour
> +    at STMT.  Isolate and optimize the path which exhibits undefined
> +    behaviour.
> +
> +    Isolation is simple.  Duplicate BB and redirect E to BB'.
> +
> +    Optimization is simple as well.  Replace STMT in BB' with an
> +    unconditional trap and remove all outgoing edges from BB'.
> +
> +    DUPLICATE is a pre-existing duplicate, use it as BB' if it exists.
> +
> +    Return BB'.  */
> +
> + basic_block
> + isolate_path (basic_block bb, basic_block duplicate, edge e, gimple stmt)
> + {
> +   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
> +      trap.  Removing the outgoing edges is both an optimization and
> ensures
> +      we don't need to do any PHI node updates.  */
> +   if (!duplicate)
> +     {
> +       duplicate = duplicate_block (bb, NULL, NULL);
> +       for (ei = ei_start (duplicate->succs); (e2 = ei_safe_edge (ei)); )
> +       remove_edge (e2);
> +     }
> +
> +   /* Complete the isolation step by redirecting E to reach DUPLICATE.  */
> +   e2 = redirect_edge_and_branch (e, duplicate);
> +   flush_pending_stmts (e2);
> +
> +
> +   /* There may be more than one statement in DUPLICATE which exhibits
> +      undefined behaviour.  Ultimately we want the first such statement in
> +      DUPLCIATE so that we're able to delete as much code as possible.
> +
> +      So each time we discover undefined behaviour in DUPLICATE, search for
> +      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.
> +
> +      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
> block and
> +      walk forward looking for STMT in BB, advancing each iterator at each
> step.
> +
> +      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.
> +
> +      Ignore labels and debug statements.  */
> +   for (si = gsi_start_nondebug_bb (bb), si2 = gsi_start_nondebug_bb
> (duplicate);
> +        !gsi_end_p (si) && !gsi_end_p (si2);
> +        gsi_next_nondebug (&si), gsi_next_nondebug (&si2))
> +     {
> +       while (gimple_code (gsi_stmt (si)) == GIMPLE_LABEL)
> +       gsi_next_nondebug (&si);
> +       while (gimple_code (gsi_stmt (si2)) == GIMPLE_LABEL)
> +       gsi_next_nondebug (&si2);
> +       if (gsi_stmt (si) == stmt)
> +       break;
> +     }
> +
> +   /* This would be an indicator that we never found STMT in BB, which
> should
> +      never happen.  */
> +   gcc_assert (!gsi_end_p (si));
> +
> +   /* If we did not run to the end of DUPLICATE, then SI points to STMT and
> +      SI2 points to the duplicate of STMT in DUPLICATE.  */
> +   if (!gsi_end_p (si2))
> +     {
> +       /* SI2 is the iterator in the duplicate block and it now points
> +        to our victim statement.  */
> +       gimple_seq seq = NULL;
> +       tree t = build_call_expr_loc (0,
> +                                   builtin_decl_explicit (BUILT_IN_TRAP),
> 0);
> +       gimplify_and_add (t, &seq);
> +       gsi_insert_before (&si2, seq, GSI_SAME_STMT);
> +
> +       /* Now delete all remaining statements in this block.  */
> +       for (; !gsi_end_p (si2);)
> +       gsi_remove (&si2, true);
> +     }
> +
> +   return duplicate;
> + }
> +
> + /* Search the function for statements which, if executed, would cause
> +    the program to fault such as a dereference of a NULL pointer.
> +
> +    Such a program can't be valid if such a statement was to execute
> +    according to ISO standards.
> +
> +    We detect explicit NULL pointer dereferences as well as those implied
> +    by a PHI argument having a NULL value which unconditionally flows into
> +    a dereference in the same block as the PHI.
> +
> +    In the former case we replace the offending statement with an
> +    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
> +    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.
> +
> +    A warning for both cases may be advisable as well.
> +
> +    Other statically detectable violations of the ISO standard could be
> +    handled in a similar way, such as out-of-bounds array indexing.  */
> +
> + static unsigned int
> + tree_ssa_isolate_paths (void)
> + {
> +   basic_block bb;
> +
> +   initialize_original_copy_tables ();
> +
> +   /* Search all the blocks for edges which, if traversed, will
> +      result in undefined behaviour.  */
> +   cfg_altered = false;
> +   FOR_EACH_BB (bb)
> +     {
> +       gimple_stmt_iterator si;
> +
> +       /* First look for a PHI which sets a pointer to NULL and which
> +        is then dereferenced within BB.  This is somewhat overly
> +        conservative, but probably catches most of the interesting
> +        cases.   */
> +       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
> +       {
> +         gimple phi = gsi_stmt (si);
> +         tree lhs = gimple_phi_result (phi);
> +
> +         /* If the result is not a pointer, then there is no need to
> +            examine the arguments.  */
> +         if (!POINTER_TYPE_P (TREE_TYPE (lhs)))
> +           continue;
> +
> +         /* PHI produces a pointer result.  See if any of the PHI's
> +            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.  */
> +         basic_block duplicate = NULL;
> +         for (unsigned i = 0, next_i = 0; i < gimple_phi_num_args (phi); i
> = next_i)
> +           {
> +             tree op = gimple_phi_arg_def (phi, i);
> +
> +             next_i = i + 1;
> +             if (operand_equal_p (op, integer_zero_node, 0))
> +               {
> +                 gimple use_stmt;
> +                 imm_use_iterator iter;
> +
> +                 /* We've got a NULL PHI argument.  Now see if the
> +                    PHI's result is dereferenced within BB.  */
> +                 FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
> +                   {
> +                     unsigned int j;
> +                     bool removed_edge = false;
> +
> +                     /* We only care about uses in BB which are
> assignements
> +                        with memory operands.
> +
> +                        We could see if any uses are as function arguments
> +                        when the callee has marked the argument as being
> +                        non-null.  */
> +                     if (gimple_bb (use_stmt) != bb
> +                         || !gimple_has_mem_ops (use_stmt)
> +                         || gimple_code (use_stmt) != GIMPLE_ASSIGN)
> +                       continue;
> +
> +                     /* Look at each operand for a memory reference using
> +                        LHS.  */
> +                     for (j = 0; j < gimple_num_ops (use_stmt); j++)
> +                       {
> +                         tree op = gimple_op (use_stmt, j);
> +
> +                         if (op == NULL)
> +                           continue;
> +
> +                         while (handled_component_p (op))
> +                           op = TREE_OPERAND (op, 0);
> +
> +                         if ((TREE_CODE (op) == MEM_REF
> +                              || TREE_CODE (op) == INDIRECT_REF)
> +                             && TREE_OPERAND (op, 0) == lhs)
> +                           {
> +                             edge e = gimple_phi_arg_edge (phi, i);
> +                             duplicate = isolate_path (bb, duplicate,
> +                                                       e, use_stmt);
> +
> +                             /* When we remove an incoming edge, we need to
> +                                reprocess the Ith element.  */
> +                             next_i = i;
> +
> +                             removed_edge = true;
> +                             cfg_altered = true;
> +                             break;
> +                           }
> +                       }
> +
> +                     /* We really want to process other immediate uses
> here.
> +                        There may be another immediate use of LHS in this
> +                        block prior to the one we just turned into a trap.
> +
> +                        However, for now, we ignore other immediate uses.
> */
> +                     if (removed_edge)
> +                       BREAK_FROM_IMM_USE_STMT (iter);
> +                   }
> +               }
> +           }
> +       }
> +
> +       /* Now look at the statements in the block and see if any of
> +        them explicitly dereference a NULL pointer.  Believe it or
> +        not, this does happen from time to time.  */
> +       bool found = false;
> +       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
> +       {
> +         gimple stmt = gsi_stmt (si);
> +         unsigned int i;
> +
> +         /* We only care about assignments with memory operands.
> +
> +            Again, we could see if any uses are as function arguments
> +            when the callee has marked the argument as being non-null.  */
> +         if (!gimple_has_mem_ops (stmt)
> +             || gimple_code (stmt) != GIMPLE_ASSIGN)
> +           continue;
> +
> +         /* Look at each operand for a memory reference using an explicit
> +            NULL pointer.  */
> +         for (i = 0; i < gimple_num_ops (stmt); i++)
> +           {
> +             tree op = gimple_op (stmt, i);
> +
> +             if (op == NULL)
> +               continue;
> +
> +             while (handled_component_p (op))
> +               op = TREE_OPERAND (op, 0);
> +
> +             if (TREE_CODE (op) == MEM_REF || TREE_CODE (op) ==
> INDIRECT_REF)
> +               {
> +                 tree op0 = TREE_OPERAND (op, 0);
> +                 /* If the operand is NULL, then this block will trigger
> undefined
> +                    behaviour at runtime if we reach STMT.  */
> +                 if (operand_equal_p (op0, integer_zero_node, 0))
> +                   {
> +                     /* First insert a TRAP before this statement.  */
> +                     gimple_seq seq = NULL;
> +                     tree t
> +                       = build_call_expr_loc (0,builtin_decl_explicit
> (BUILT_IN_TRAP), 0);
> +                     gimplify_and_add (t, &seq);
> +                     gsi_insert_before (&si, seq, GSI_SAME_STMT);
> +
> +                     /* Now delete all remaining statements in this block.
> */
> +                     for (gimple_stmt_iterator si2 = si; !gsi_end_p (si2);)
> +                       gsi_remove (&si2, true);
> +
> +                     /* And finally, remove all outgoing edges from BB.  */
> +                     edge e;
> +                     for (edge_iterator ei = ei_start (bb->succs);
> +                          (e = ei_safe_edge (ei)); )
> +                       remove_edge (e);
> +
> +                     /* Ignore any more operands on this statement and
> +                        continue the statement iterator (which should
> +                        terminate its loop immediately.  */
> +                     found = true;
> +                     cfg_altered = true;
> +                     break;
> +                   }
> +               }
> +           }
> +
> +         if (found)
> +           break;
> +       }
> +     }
> +   free_original_copy_tables ();
> +
> +   /* 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)
> +     {
> +       free_dominance_info (CDI_DOMINATORS);
> +       free_dominance_info (CDI_POST_DOMINATORS);
> +       loops_state_set (LOOPS_NEED_FIXUP);
> +       return TODO_cleanup_cfg | TODO_update_ssa;
> +     }
> +   return 0;
> + }
> +
> + static bool
> + gate_isolate_paths (void)
> + {
> +   /* If we do not have a suitable builtin function for the trap statement,
> +      then do not perform the optimization.  */
> +   return (flag_tree_isolate_paths != 0
> +         && builtin_decl_explicit (BUILT_IN_TRAP) != NULL);
> +
> + }
> +
> + namespace {
> + const pass_data pass_data_isolate_paths =
> + {
> +   GIMPLE_PASS, /* type */
> +   "isolatepaths", /* name */
> +   OPTGROUP_NONE, /* optinfo_flags */
> +   true, /* has_gate */
> +   true, /* has_execute */
> +   TV_TREE_SSA_ISOLATE_PATHS, /* tv_id */
> +   ( PROP_cfg | PROP_ssa ), /* properties_required */
> +   0, /* properties_provided */
> +   0, /* properties_destroyed */
> +   0, /* todo_flags_start */
> +   TODO_verify_ssa, /* todo_flags_finish */
> + };
> +
> + class pass_isolate_paths : public gimple_opt_pass
> + {
> + public:
> +   pass_isolate_paths (gcc::context *ctxt)
> +     : gimple_opt_pass (pass_data_isolate_paths, ctxt)
> +   {}
> +
> +   /* opt_pass methods: */
> +   opt_pass * clone () { return new pass_isolate_paths (m_ctxt); }
> +   bool gate () { return gate_isolate_paths (); }
> +   unsigned int execute () { return tree_ssa_isolate_paths (); }
> +
> + }; // class pass_uncprop
> + }
> +
> + gimple_opt_pass *
> + make_pass_isolate_paths (gcc::context *ctxt)
> + {
> +   return new pass_isolate_paths (ctxt);
> + }
> +
> +
>


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]