diff --git a/gcc/Makefile.in b/gcc/Makefile.in index d186d71c91e..5f43d9de00e 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1559,7 +1559,6 @@ OBJS = \ tree-ssa-loop.o \ tree-ssa-math-opts.o \ tree-ssa-operands.o \ - tree-ssa-phionlycprop.o \ tree-ssa-phiopt.o \ tree-ssa-phiprop.o \ tree-ssa-pre.o \ diff --git a/gcc/passes.def b/gcc/passes.def index 446a7c48276..2f01a2dd72b 100644 --- a/gcc/passes.def +++ b/gcc/passes.def @@ -222,19 +222,16 @@ along with GCC; see the file COPYING3. If not see trying to move or duplicate pass_dominator somewhere earlier. */ NEXT_PASS (pass_thread_jumps); NEXT_PASS (pass_dominator, true /* may_peel_loop_headers_p */); - /* 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 expose more degenerate PHIs in the main path and - expose more PRE/DOM optimization opportunities. */ + /* Threading can leave many const/copy propagations in the IL. + Clean them up. Failure to do so well can lead to false + positives from warnings for erroneous code. */ + NEXT_PASS (pass_copy_prop); + /* Identify paths that should never be executed in a conforming + program and isolate those paths. */ NEXT_PASS (pass_isolate_erroneous_paths); - /* The only const/copy propagation opportunities left after - DOM and erroneous path isolation should be due to degenerate PHI nodes. - So rather than run the full propagators, run a specialized pass which - only examines PHIs to discover const/copy propagation - opportunities. */ - NEXT_PASS (pass_phi_only_cprop); + /* Path isolation can leave many const/copy propagations in the IL. + Clean them up. */ + NEXT_PASS (pass_copy_prop); NEXT_PASS (pass_dse); NEXT_PASS (pass_reassoc, true /* insert_powi_p */); NEXT_PASS (pass_dce); @@ -321,13 +318,10 @@ along with GCC; see the file COPYING3. If not see NEXT_PASS (pass_strlen); NEXT_PASS (pass_thread_jumps); NEXT_PASS (pass_vrp, false /* warn_array_bounds_p */); - /* The only const/copy propagation opportunities left after - DOM and VRP should be due to degenerate PHI nodes. So rather than - run the full propagators, run a specialized pass which - only examines PHIs to discover const/copy propagation - opportunities. */ NEXT_PASS (pass_warn_restrict); - NEXT_PASS (pass_phi_only_cprop); + /* Threading can leave many const/copy propagations in the IL. + Clean them up. */ + NEXT_PASS (pass_copy_prop); NEXT_PASS (pass_dse); NEXT_PASS (pass_cd_dce); NEXT_PASS (pass_forwprop); diff --git a/gcc/testsuite/gcc.dg/pr90037.c b/gcc/testsuite/gcc.dg/pr90037.c new file mode 100644 index 00000000000..70f9ad2f83c --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr90037.c @@ -0,0 +1,161 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -Wnull-dereference" } */ + +typedef __SIZE_TYPE__ size_t; +typedef unsigned long int uintmax_t; + +struct group +{ + char *gr_name; + char *gr_passwd; + unsigned gr_gid; + char **gr_mem; +}; + +struct passwd +{ + char *pw_name; + char *pw_passwd; + + unsigned pw_uid; + unsigned pw_gid; + char *pw_gecos; + char *pw_dir; + char *pw_shell; +}; + +extern struct group *getgrnam (const char *); +extern struct group *getgrgid (unsigned); +extern void endgrent (void); +extern struct passwd *getpwnam (const char *); +extern void endpwent (void); +extern unsigned long int strtoul (const char *__restrict, + char **__restrict, int); + +char const * +parse_with_separator (char const *spec, char const *separator, + unsigned *uid, unsigned *gid, + char **username, char **groupname) +{ + static const char *E_invalid_user = "invalid user"; + static const char *E_invalid_group = "invalid group"; + static const char *E_bad_spec = "invalid spec"; + const char *error_msg; + struct passwd *pwd; + struct group *grp; + char *u; + char const *g; + char *gname = 0; + unsigned unum = *uid; + unsigned gnum = gid ? *gid : (unsigned)-1; + + error_msg = 0; + + if (username) + *username = 0; + + if (groupname) + *groupname = 0; + + u = 0; + if (separator == 0) + { + if (*spec) + u = __builtin_strdup (spec); + } + else + { + size_t ulen = separator - spec; + if (ulen != 0) + { + u = __builtin_malloc (ulen + 1); + __builtin_memcpy (u, spec, ulen + 1); + u[ulen] = '\0'; + } + } + + g = (separator == 0 || *(separator + 1) == '\0' ? 0 : separator + 1); + + if (u != 0) + { + pwd = (*u == '+' ? 0 : getpwnam (u)); + if (pwd == 0) + { + _Bool use_login_group = (separator != 0 && g == 0); + if (use_login_group) + { + error_msg = E_bad_spec; + } + else + { + unsigned long int tmp; + tmp = strtoul (u, 0, 10); + if (tmp <= (1ul << 31) && (unsigned) tmp != (unsigned) -1) + unum = tmp; + else + error_msg = E_invalid_user; + } + } + else + { + unum = pwd->pw_uid; + if (g == 0 && separator != 0) + { + char buf[128]; + gnum = pwd->pw_gid; + grp = getgrgid (gnum); + + gname = buf; + + if (grp) + gname = __builtin_strdup (grp->gr_name); + else + __builtin_snprintf (buf, sizeof(buf), "%ju", (uintmax_t)gnum); + + endgrent (); + } + } + + endpwent (); + } + + if (g != 0 && error_msg == 0) + { + grp = (*g == '+' ? 0 : getgrnam (g)); + if (grp == 0) + { + unsigned long int tmp = strtoul (g, 0, 10); + + if (tmp <= (1ul << 31) && (unsigned) tmp != (unsigned) -1) + gnum = tmp; + else + error_msg = E_invalid_group; + } + else + gnum = grp->gr_gid; + endgrent (); + gname = __builtin_strdup (g); + } + + if (error_msg == 0) + { + *uid = unum; + if (gid) + *gid = gnum; + if (username) + { + *username = u; + u = 0; + } + if (groupname) + { + *groupname = gname; + gname = 0; + } + } + + __builtin_free (u); + __builtin_free (gname); + return error_msg ? error_msg : 0; +} + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/20030710-1.c b/gcc/testsuite/gcc.dg/tree-ssa/20030710-1.c index 3dd3ba8bc17..529c79b26e3 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/20030710-1.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/20030710-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O1 -fdump-tree-phicprop1" } */ +/* { dg-options "-O1 -fdump-tree-copyprop2" } */ extern void abort (void); extern void blah (void); @@ -42,14 +42,14 @@ record_component_aliases (type) /* The call to blah should have been eliminated. If the call is not eliminated, then dominator optimizations failed and it'll be impossible to delete other unnecessary code. */ -/* { dg-final { scan-tree-dump-not "blah \\(\\)" "phicprop1" } } */ +/* { dg-final { scan-tree-dump-not "blah \\(\\)" "copyprop2" } } */ /* There should be two IF conditionals. */ -/* { dg-final { scan-tree-dump-times "if " 2 "phicprop1"} } */ +/* { dg-final { scan-tree-dump-times "if " 2 "copyprop2"} } */ /* There should be a single load of type.binfo. */ -/* { dg-final { scan-tree-dump-times "type\\.binfo" 1 "phicprop1"} } */ +/* { dg-final { scan-tree-dump-times "type\\.binfo" 1 "copyprop2"} } */ /* There should be two loads of vec.length. */ -/* { dg-final { scan-tree-dump-times "vec.length" 2 "phicprop1"} } */ +/* { dg-final { scan-tree-dump-times "vec.length" 2 "copyprop2"} } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/isolate-2.c b/gcc/testsuite/gcc.dg/tree-ssa/isolate-2.c index b993849e96d..f0153c51446 100644 --- 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 -fdelete-null-pointer-checks -fisolate-erroneous-paths-attribute -fdump-tree-isolate-paths -fdump-tree-phicprop1" } */ +/* { dg-options "-O2 -fdelete-null-pointer-checks -fisolate-erroneous-paths-attribute -fdump-tree-isolate-paths -fdump-tree-copyprop3" } */ /* { dg-skip-if "" keeps_null_pointer_checks } */ @@ -34,9 +34,9 @@ bar (void) a return statement. We test this twice, once where the NULL flows from a PHI, the second with an explicit return 0 in the IL. - We also verify that after isolation phi-cprop simplifies the + We also verify that after isolation cprop simplifies the return statement so that it returns &z directly. */ /* { dg-final { scan-tree-dump-times "__builtin_trap" 2 "isolate-paths"} } */ -/* { dg-final { scan-tree-dump-times "return &z;" 1 "phicprop1"} } */ +/* { dg-final { scan-tree-dump-times "return &z;" 1 "copyprop3"} } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/isolate-4.c b/gcc/testsuite/gcc.dg/tree-ssa/isolate-4.c index 0a88d7d47f6..dabe4793771 100644 --- 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 -fdelete-null-pointer-checks -fisolate-erroneous-paths-attribute -fdump-tree-isolate-paths -fdump-tree-phicprop1" } */ +/* { dg-options "-O2 -fdelete-null-pointer-checks -fisolate-erroneous-paths-attribute -fdump-tree-isolate-paths -fdump-tree-copyprop3" } */ /* { dg-skip-if "" keeps_null_pointer_checks } */ @@ -26,6 +26,6 @@ bar (void) We also verify that after isolation phi-cprop simplifies the return statement so that it returns &z directly. */ /* { dg-final { scan-tree-dump-times "__builtin_trap" 2 "isolate-paths"} } */ -/* { dg-final { scan-tree-dump-times "foo .&z.;" 1 "phicprop1"} } */ +/* { dg-final { scan-tree-dump-times "foo .&z.;" 1 "copyprop3"} } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr19431.c b/gcc/testsuite/gcc.dg/tree-ssa/pr19431.c index 2f656ceccbc..a1f46c7aec5 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/pr19431.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr19431.c @@ -24,4 +24,4 @@ int f(int k, int i1, int j1) return *f1; } -/* { dg-final { scan-tree-dump "\[^\r\n\]*_. = PHI \]*>" "optimized" } } */ +/* { dg-final { scan-tree-dump "\[^\r\n\]*_. = PHI <\[ij\]1_\[^,\]*, \[ij\]1_\[^>\]*>" "optimized" } } */ diff --git a/gcc/tree-ssa-phionlycprop.c b/gcc/tree-ssa-phionlycprop.c deleted file mode 100644 index f367800da41..00000000000 --- a/gcc/tree-ssa-phionlycprop.c +++ /dev/null @@ -1,580 +0,0 @@ -/* Const/Copy propagation originating from degenerate PHIs - Copyright (C) 2001-2019 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 -. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "backend.h" -#include "cfghooks.h" -#include "tree.h" -#include "gimple.h" -#include "ssa.h" -#include "fold-const.h" -#include "cfgloop.h" -#include "gimple-pretty-print.h" -#include "gimple-fold.h" -#include "tree-eh.h" -#include "gimple-iterator.h" -#include "tree-cfg.h" -#include "tree-pass.h" -#include "tree-ssa-propagate.h" - - -/* PHI-ONLY copy and constant propagation. This pass is meant to clean - up degenerate PHIs created by or exposed by jump threading. */ - -/* Given a statement STMT, which is either a PHI node or an assignment, - remove it from the IL. */ - -static void -remove_stmt_or_phi (gimple *stmt) -{ - gimple_stmt_iterator gsi = gsi_for_stmt (stmt); - - if (gimple_code (stmt) == GIMPLE_PHI) - remove_phi_node (&gsi, true); - else - { - gsi_remove (&gsi, true); - release_defs (stmt); - } -} - -/* Given a statement STMT, which is either a PHI node or an assignment, - return the "rhs" of the node, in the case of a non-degenerate - phi, NULL is returned. */ - -static tree -get_rhs_or_phi_arg (gimple *stmt) -{ - if (gimple_code (stmt) == GIMPLE_PHI) - return degenerate_phi_result (as_a (stmt)); - else if (gimple_assign_single_p (stmt)) - return gimple_assign_rhs1 (stmt); - else - gcc_unreachable (); -} - - -/* Given a statement STMT, which is either a PHI node or an assignment, - return the "lhs" of the node. */ - -static tree -get_lhs_or_phi_result (gimple *stmt) -{ - if (gimple_code (stmt) == GIMPLE_PHI) - return gimple_phi_result (stmt); - else if (is_gimple_assign (stmt)) - return gimple_assign_lhs (stmt); - else - gcc_unreachable (); -} - -/* Propagate RHS into all uses of LHS (when possible). - - RHS and LHS are derived from STMT, which is passed in solely so - that we can remove it if propagation is successful. - - When propagating into a PHI node or into a statement which turns - into a trivial copy or constant initialization, set the - appropriate bit in INTERESTING_NAMEs so that we will visit those - nodes as well in an effort to pick up secondary optimization - opportunities. - - NEED_EH_CLEANUP tracks blocks that need their EH information - cleaned up after changing EH information on a statement. */ - -static bool -propagate_rhs_into_lhs (gimple *stmt, tree lhs, tree rhs, - bitmap interesting_names, bitmap need_eh_cleanup) -{ - bool cfg_altered = false; - - /* First verify that propagation is valid. */ - if (may_propagate_copy (lhs, rhs)) - { - use_operand_p use_p; - imm_use_iterator iter; - gimple *use_stmt; - bool all = true; - - /* Dump details. */ - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, " Replacing '"); - print_generic_expr (dump_file, lhs, dump_flags); - fprintf (dump_file, "' with %s '", - (TREE_CODE (rhs) != SSA_NAME ? "constant" : "variable")); - print_generic_expr (dump_file, rhs, dump_flags); - fprintf (dump_file, "'\n"); - } - - /* Walk over every use of LHS and try to replace the use with RHS. - At this point the only reason why such a propagation would not - be successful would be if the use occurs in an ASM_EXPR. */ - FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) - { - /* Leave debug stmts alone. If we succeed in propagating - all non-debug uses, we'll drop the DEF, and propagation - into debug stmts will occur then. */ - if (gimple_debug_bind_p (use_stmt)) - continue; - - /* It's not always safe to propagate into an ASM_EXPR. */ - if (gimple_code (use_stmt) == GIMPLE_ASM - && ! may_propagate_copy_into_asm (lhs)) - { - all = false; - continue; - } - - /* It's not ok to propagate into the definition stmt of RHS. - : - # prephitmp.12_36 = PHI - g_67.1_6 = prephitmp.12_36; - goto ; - While this is strictly all dead code we do not want to - deal with this here. */ - if (TREE_CODE (rhs) == SSA_NAME - && SSA_NAME_DEF_STMT (rhs) == use_stmt) - { - all = false; - continue; - } - - /* Dump details. */ - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, " Original statement:"); - print_gimple_stmt (dump_file, use_stmt, 0, dump_flags); - } - - /* Propagate the RHS into this use of the LHS. */ - FOR_EACH_IMM_USE_ON_STMT (use_p, iter) - propagate_value (use_p, rhs); - - /* Special cases to avoid useless calls into the folding - routines, operand scanning, etc. - - Propagation into a PHI may cause the PHI to become - a degenerate, so mark the PHI as interesting. No other - actions are necessary. */ - if (gimple_code (use_stmt) == GIMPLE_PHI) - { - tree result; - - /* Dump details. */ - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, " Updated statement:"); - print_gimple_stmt (dump_file, use_stmt, 0, dump_flags); - } - - result = get_lhs_or_phi_result (use_stmt); - bitmap_set_bit (interesting_names, SSA_NAME_VERSION (result)); - continue; - } - - /* From this point onward we are propagating into a - real statement. Folding may (or may not) be possible, - we may expose new operands, expose dead EH edges, - etc. */ - /* NOTE tuples. In the tuples world, fold_stmt_inplace - cannot fold a call that simplifies to a constant, - because the GIMPLE_CALL must be replaced by a - GIMPLE_ASSIGN, and there is no way to effect such a - transformation in-place. We might want to consider - using the more general fold_stmt here. */ - { - gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt); - fold_stmt_inplace (&gsi); - } - - /* Sometimes propagation can expose new operands to the - renamer. */ - update_stmt (use_stmt); - - /* Dump details. */ - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, " Updated statement:"); - print_gimple_stmt (dump_file, use_stmt, 0, dump_flags); - } - - /* If we replaced a variable index with a constant, then - we would need to update the invariant flag for ADDR_EXPRs. */ - if (gimple_assign_single_p (use_stmt) - && TREE_CODE (gimple_assign_rhs1 (use_stmt)) == ADDR_EXPR) - recompute_tree_invariant_for_addr_expr - (gimple_assign_rhs1 (use_stmt)); - - /* If we cleaned up EH information from the statement, - mark its containing block as needing EH cleanups. */ - if (maybe_clean_or_replace_eh_stmt (use_stmt, use_stmt)) - { - bitmap_set_bit (need_eh_cleanup, gimple_bb (use_stmt)->index); - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, " Flagged to clear EH edges.\n"); - } - - /* Propagation may expose new trivial copy/constant propagation - opportunities. */ - if (gimple_assign_single_p (use_stmt) - && TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME - && (TREE_CODE (gimple_assign_rhs1 (use_stmt)) == SSA_NAME - || is_gimple_min_invariant (gimple_assign_rhs1 (use_stmt)))) - { - tree result = get_lhs_or_phi_result (use_stmt); - bitmap_set_bit (interesting_names, SSA_NAME_VERSION (result)); - } - - /* Propagation into these nodes may make certain edges in - the CFG unexecutable. We want to identify them as PHI nodes - at the destination of those unexecutable edges may become - degenerates. */ - else if (gimple_code (use_stmt) == GIMPLE_COND - || gimple_code (use_stmt) == GIMPLE_SWITCH - || gimple_code (use_stmt) == GIMPLE_GOTO) - { - tree val; - - if (gimple_code (use_stmt) == GIMPLE_COND) - val = fold_binary_loc (gimple_location (use_stmt), - gimple_cond_code (use_stmt), - boolean_type_node, - gimple_cond_lhs (use_stmt), - gimple_cond_rhs (use_stmt)); - else if (gimple_code (use_stmt) == GIMPLE_SWITCH) - val = gimple_switch_index (as_a (use_stmt)); - else - val = gimple_goto_dest (use_stmt); - - if (val && is_gimple_min_invariant (val)) - { - basic_block bb = gimple_bb (use_stmt); - edge te = find_taken_edge (bb, val); - if (!te) - continue; - - edge_iterator ei; - edge e; - gimple_stmt_iterator gsi; - gphi_iterator psi; - - /* Remove all outgoing edges except TE. */ - for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei));) - { - if (e != te) - { - /* Mark all the PHI nodes at the destination of - the unexecutable edge as interesting. */ - for (psi = gsi_start_phis (e->dest); - !gsi_end_p (psi); - gsi_next (&psi)) - { - gphi *phi = psi.phi (); - - tree result = gimple_phi_result (phi); - int version = SSA_NAME_VERSION (result); - - bitmap_set_bit (interesting_names, version); - } - - te->probability += e->probability; - - remove_edge (e); - cfg_altered = true; - } - else - ei_next (&ei); - } - - gsi = gsi_last_bb (gimple_bb (use_stmt)); - gsi_remove (&gsi, true); - - /* And fixup the flags on the single remaining edge. */ - te->flags &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE); - te->flags &= ~EDGE_ABNORMAL; - te->flags |= EDGE_FALLTHRU; - } - } - } - - /* Ensure there is nothing else to do. */ - gcc_assert (!all || has_zero_uses (lhs)); - - /* If we were able to propagate away all uses of LHS, then - we can remove STMT. */ - if (all) - remove_stmt_or_phi (stmt); - } - return cfg_altered; -} - -/* STMT is either a PHI node (potentially a degenerate PHI node) or - a statement that is a trivial copy or constant initialization. - - Attempt to eliminate STMT by propagating its RHS into all uses of - its LHS. This may in turn set new bits in INTERESTING_NAMES - for nodes we want to revisit later. - - All exit paths should clear INTERESTING_NAMES for the result - of STMT. - - NEED_EH_CLEANUP tracks blocks that need their EH information - cleaned up after changing EH information on a statement. It is - not set or queried here, but passed along to children. */ - -static bool -eliminate_const_or_copy (gimple *stmt, bitmap interesting_names, - bitmap need_eh_cleanup) -{ - tree lhs = get_lhs_or_phi_result (stmt); - tree rhs; - int version = SSA_NAME_VERSION (lhs); - bool cfg_altered = false; - - /* If the LHS of this statement or PHI has no uses, then we can - just eliminate it. This can occur if, for example, the PHI - was created by block duplication due to threading and its only - use was in the conditional at the end of the block which was - deleted. */ - if (has_zero_uses (lhs)) - { - bitmap_clear_bit (interesting_names, version); - remove_stmt_or_phi (stmt); - return cfg_altered; - } - - /* Get the RHS of the assignment or PHI node if the PHI is a - degenerate. */ - rhs = get_rhs_or_phi_arg (stmt); - if (!rhs) - { - bitmap_clear_bit (interesting_names, version); - return cfg_altered; - } - - if (!virtual_operand_p (lhs)) - cfg_altered = propagate_rhs_into_lhs (stmt, lhs, rhs, - interesting_names, need_eh_cleanup); - else - { - gimple *use_stmt; - imm_use_iterator iter; - use_operand_p use_p; - /* For virtual operands we have to propagate into all uses as - otherwise we will create overlapping life-ranges. */ - FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) - FOR_EACH_IMM_USE_ON_STMT (use_p, iter) - SET_USE (use_p, rhs); - if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs)) - SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs) = 1; - remove_stmt_or_phi (stmt); - } - - /* Note that STMT may well have been deleted by now, so do - not access it, instead use the saved version # to clear - T's entry in the worklist. */ - bitmap_clear_bit (interesting_names, version); - return cfg_altered; -} - -/* The first phase in degenerate PHI elimination. - - Eliminate the degenerate PHIs in BB, then recurse on the - dominator children of BB. - - INTERESTING_NAMES tracks SSA_NAMEs that we may want to revisit - in the future. It is not set or queried here, but passed along - to children. - - NEED_EH_CLEANUP tracks blocks that need their EH information - cleaned up after changing EH information on a statement. It is - not set or queried here, but passed along to children. */ - -static bool -eliminate_degenerate_phis_1 (basic_block bb, bitmap interesting_names, - bitmap need_eh_cleanup) -{ - gphi_iterator gsi; - basic_block son; - bool cfg_altered = false; - - for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);) - { - gphi *phi = gsi.phi (); - /* We might end up removing PHI so advance the iterator now. */ - gsi_next (&gsi); - cfg_altered |= eliminate_const_or_copy (phi, interesting_names, - need_eh_cleanup); - } - - /* Recurse into the dominator children of BB. */ - for (son = first_dom_son (CDI_DOMINATORS, bb); - son; - son = next_dom_son (CDI_DOMINATORS, son)) - cfg_altered |= eliminate_degenerate_phis_1 (son, interesting_names, - need_eh_cleanup); - - return cfg_altered; -} - - -/* A very simple pass to eliminate degenerate PHI nodes from the - IL. This is meant to be fast enough to be able to be run several - times in the optimization pipeline. - - Certain optimizations, particularly those which duplicate blocks - or remove edges from the CFG can create or expose PHIs which are - trivial copies or constant initializations. - - While we could pick up these optimizations in DOM or with the - combination of copy-prop and CCP, those solutions are far too - heavy-weight for our needs. - - This implementation has two phases so that we can efficiently - eliminate the first order degenerate PHIs and second order - degenerate PHIs. - - The first phase performs a dominator walk to identify and eliminate - the vast majority of the degenerate PHIs. When a degenerate PHI - is identified and eliminated any affected statements or PHIs - are put on a worklist. - - The second phase eliminates degenerate PHIs and trivial copies - or constant initializations using the worklist. This is how we - pick up the secondary optimization opportunities with minimal - cost. */ - -namespace { - -const pass_data pass_data_phi_only_cprop = -{ - GIMPLE_PASS, /* type */ - "phicprop", /* name */ - OPTGROUP_NONE, /* optinfo_flags */ - TV_TREE_PHI_CPROP, /* tv_id */ - ( PROP_cfg | PROP_ssa ), /* properties_required */ - 0, /* properties_provided */ - 0, /* properties_destroyed */ - 0, /* todo_flags_start */ - ( TODO_cleanup_cfg | TODO_update_ssa ), /* todo_flags_finish */ -}; - -class pass_phi_only_cprop : public gimple_opt_pass -{ -public: - pass_phi_only_cprop (gcc::context *ctxt) - : gimple_opt_pass (pass_data_phi_only_cprop, ctxt) - {} - - /* opt_pass methods: */ - opt_pass * clone () { return new pass_phi_only_cprop (m_ctxt); } - virtual bool gate (function *) { return flag_tree_dom != 0; } - virtual unsigned int execute (function *); - -}; // class pass_phi_only_cprop - -unsigned int -pass_phi_only_cprop::execute (function *fun) -{ - bool cfg_altered = false; - - /* Bitmap of blocks which need EH information updated. We cannot - update it on-the-fly as doing so invalidates the dominator tree. */ - auto_bitmap need_eh_cleanup; - - /* INTERESTING_NAMES is effectively our worklist, indexed by - SSA_NAME_VERSION. - - A set bit indicates that the statement or PHI node which - defines the SSA_NAME should be (re)examined to determine if - it has become a degenerate PHI or trivial const/copy propagation - opportunity. - - Experiments have show we generally get better compilation - time behavior with bitmaps rather than sbitmaps. */ - auto_bitmap interesting_names; - auto_bitmap interesting_names1; - - calculate_dominance_info (CDI_DOMINATORS); - cfg_altered = false; - - /* First phase. Eliminate degenerate PHIs via a dominator - walk of the CFG. - - Experiments have indicated that we generally get better - compile-time behavior by visiting blocks in the first - phase in dominator order. Presumably this is because walking - in dominator order leaves fewer PHIs for later examination - by the worklist phase. */ - cfg_altered = eliminate_degenerate_phis_1 (ENTRY_BLOCK_PTR_FOR_FN (fun), - interesting_names, - need_eh_cleanup); - - /* Second phase. Eliminate second order degenerate PHIs as well - as trivial copies or constant initializations identified by - the first phase or this phase. Basically we keep iterating - until our set of INTERESTING_NAMEs is empty. */ - while (!bitmap_empty_p (interesting_names)) - { - unsigned int i; - bitmap_iterator bi; - - /* EXECUTE_IF_SET_IN_BITMAP does not like its bitmap - changed during the loop. Copy it to another bitmap and - use that. */ - bitmap_copy (interesting_names1, interesting_names); - - EXECUTE_IF_SET_IN_BITMAP (interesting_names1, 0, i, bi) - { - tree name = ssa_name (i); - - /* Ignore SSA_NAMEs that have been released because - their defining statement was deleted (unreachable). */ - if (name) - cfg_altered - |= eliminate_const_or_copy (SSA_NAME_DEF_STMT (ssa_name (i)), - interesting_names, need_eh_cleanup); - } - } - - if (cfg_altered) - { - free_dominance_info (CDI_DOMINATORS); - /* If we changed the CFG schedule loops for fixup by cfgcleanup. */ - loops_state_set (LOOPS_NEED_FIXUP); - } - - /* Propagation of const and copies may make some EH edges dead. Purge - such edges from the CFG as needed. */ - if (!bitmap_empty_p (need_eh_cleanup)) - gimple_purge_all_dead_eh_edges (need_eh_cleanup); - - return 0; -} - -} // anon namespace - -gimple_opt_pass * -make_pass_phi_only_cprop (gcc::context *ctxt) -{ - return new pass_phi_only_cprop (ctxt); -}