diff options
| -rw-r--r-- | gcc/ChangeLog | 19 | ||||
| -rw-r--r-- | gcc/gimple-fold.c | 1 | ||||
| -rw-r--r-- | gcc/gimple-fold.h | 22 | ||||
| -rw-r--r-- | gcc/gimple.h | 18 | ||||
| -rw-r--r-- | gcc/sese.c | 1 | ||||
| -rw-r--r-- | gcc/tree-flow.h | 13 | ||||
| -rw-r--r-- | gcc/tree-scalar-evolution.c | 1 | ||||
| -rw-r--r-- | gcc/tree-ssa-ccp.c | 1 | ||||
| -rw-r--r-- | gcc/tree-ssa-copy.c | 214 | ||||
| -rw-r--r-- | gcc/tree-ssa-pre.c | 1 | ||||
| -rw-r--r-- | gcc/tree-ssa-propagate.c | 215 | ||||
| -rw-r--r-- | gcc/tree-ssa-propagate.h | 23 | ||||
| -rw-r--r-- | gcc/tree-ssa-sccvn.c | 1 | ||||
| -rw-r--r-- | gcc/tree-vrp.c | 1 |
14 files changed, 270 insertions, 261 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 87b789a..d2e7573 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,22 @@ +2013-10-02 Andrew MacLeod <amacleod@redhat.com> + + * tree-flow.h: Remove some prototypes. + * gimple-fold.h: Add prototypes from gimple.h and tree-flow.h. + * tree-ssa-propagate.h: Relocate prototypes from tree-flow.h. + * tree-ssa-copy.c (may_propagate*, propagate_value, replace_exp, + propagate_tree_value*): Move from here to... + * tree-ssa-propagate.c (may_propagate*, propagate_value, replace_exp, + propagate_tree_value*): Relocate here. + * tree-ssa-propagate.h: Relocate prototypes from tree-flow.h. + * gimple.h: Include gimple-fold.h, move prototypes into gimple-fold.h. + * gimple-fold.c: Remove gimple-fold.h from include list. + * tree-vrp.c: Remove gimple-fold.h from include list. + * tree-ssa-sccvn.c: Remove gimple-fold.h from include list. + * tree-ssa-ccp.c: Remove gimple-fold.h from include list. + * tree-scalar-evolution.c: Add tree-ssa-propagate.h to include list. + * tree-ssa-pre.c: Add tree-ssa-propagate.h to include list. + * sese.c: Add tree-ssa-propagate.h to include list. + 2013-10-02 Richard Biener <rguenther@suse.de> * tree-loop-distribution.c: Include tree-vectorizer.h for diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index dd2aed7..9892c86 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -29,7 +29,6 @@ along with GCC; see the file COPYING3. If not see #include "tree-ssa.h" #include "tree-ssa-propagate.h" #include "target.h" -#include "gimple-fold.h" #include "ipa-utils.h" #include "gimple-pretty-print.h" diff --git a/gcc/gimple-fold.h b/gcc/gimple-fold.h index fb0502a..9b818fc 100644 --- a/gcc/gimple-fold.h +++ b/gcc/gimple-fold.h @@ -22,10 +22,22 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_GIMPLE_FOLD_H #define GCC_GIMPLE_FOLD_H -tree fold_const_aggregate_ref_1 (tree, tree (*) (tree)); -tree fold_const_aggregate_ref (tree); - -tree gimple_fold_stmt_to_constant_1 (gimple, tree (*) (tree)); -tree gimple_fold_stmt_to_constant (gimple, tree (*) (tree)); +extern tree canonicalize_constructor_val (tree, tree); +extern tree get_symbol_constant_value (tree); +extern void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree); +extern tree gimple_fold_builtin (gimple); +extern tree gimple_extract_devirt_binfo_from_cst (tree, tree); +extern bool fold_stmt (gimple_stmt_iterator *); +extern bool fold_stmt_inplace (gimple_stmt_iterator *); +extern tree maybe_fold_and_comparisons (enum tree_code, tree, tree, + enum tree_code, tree, tree); +extern tree maybe_fold_or_comparisons (enum tree_code, tree, tree, + enum tree_code, tree, tree); +extern tree gimple_fold_stmt_to_constant_1 (gimple, tree (*) (tree)); +extern tree gimple_fold_stmt_to_constant (gimple, tree (*) (tree)); +extern tree fold_const_aggregate_ref_1 (tree, tree (*) (tree)); +extern tree fold_const_aggregate_ref (tree); +extern tree gimple_get_virt_method_for_binfo (HOST_WIDE_INT, tree); +extern bool gimple_val_nonnegative_real_p (tree); #endif /* GCC_GIMPLE_FOLD_H */ diff --git a/gcc/gimple.h b/gcc/gimple.h index 2d324e6..3ac59af 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -30,6 +30,7 @@ along with GCC; see the file COPYING3. If not see #include "tree.h" #include "tree-ssa-alias.h" #include "internal-fn.h" +#include "gimple-fold.h" typedef gimple gimple_seq_node; @@ -833,8 +834,6 @@ unsigned get_gimple_rhs_num_ops (enum tree_code); #define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO) gimple gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL); const char *gimple_decl_printable_name (tree, int); -tree gimple_get_virt_method_for_binfo (HOST_WIDE_INT, tree); -tree gimple_extract_devirt_binfo_from_cst (tree, tree); /* Returns true iff T is a scalar register variable. */ extern bool is_gimple_reg (tree); @@ -5421,21 +5420,6 @@ gimple_alloc_kind (enum gimple_code code) extern void dump_gimple_statistics (void); -/* In gimple-fold.c. */ -void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree); -tree gimple_fold_builtin (gimple); -bool fold_stmt (gimple_stmt_iterator *); -bool fold_stmt_inplace (gimple_stmt_iterator *); -tree get_symbol_constant_value (tree); -tree canonicalize_constructor_val (tree, tree); -extern tree maybe_fold_and_comparisons (enum tree_code, tree, tree, - enum tree_code, tree, tree); -extern tree maybe_fold_or_comparisons (enum tree_code, tree, tree, - enum tree_code, tree, tree); - -bool gimple_val_nonnegative_real_p (tree); - - /* Set the location of all statements in SEQ to LOC. */ static inline void @@ -33,6 +33,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-pass.h" #include "value-prof.h" #include "sese.h" +#include "tree-ssa-propagate.h" /* Print to stderr the element ELT. */ diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h index d3a4e33..bbd1a15 100644 --- a/gcc/tree-flow.h +++ b/gcc/tree-flow.h @@ -244,10 +244,6 @@ extern basic_block move_sese_region_to_fn (struct function *, basic_block, void remove_edge_and_dominated_blocks (edge); bool tree_node_can_be_shared (tree); -/* In tree-ssa-ccp.c */ -tree fold_const_aggregate_ref (tree); -tree gimple_fold_stmt_to_constant (gimple, tree (*)(tree)); - /* In tree-ssa-dom.c */ extern void dump_dominator_optimization_stats (FILE *); extern void debug_dominator_optimization_stats (void); @@ -255,15 +251,6 @@ int loop_depth_of_name (tree); tree degenerate_phi_result (gimple); bool simple_iv_increment_p (gimple); -/* In tree-ssa-copy.c */ -extern void propagate_value (use_operand_p, tree); -extern void propagate_tree_value (tree *, tree); -extern void propagate_tree_value_into_stmt (gimple_stmt_iterator *, tree); -extern void replace_exp (use_operand_p, tree); -extern bool may_propagate_copy (tree, tree); -extern bool may_propagate_copy_into_stmt (gimple, tree); -extern bool may_propagate_copy_into_asm (tree); - /* In tree-ssa-loop-ch.c */ bool do_while_loop_p (struct loop *); diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c index f85353c..16d9d7d 100644 --- a/gcc/tree-scalar-evolution.c +++ b/gcc/tree-scalar-evolution.c @@ -265,6 +265,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-scalar-evolution.h" #include "dumpfile.h" #include "params.h" +#include "tree-ssa-propagate.h" static tree analyze_scalar_evolution_1 (struct loop *, tree, tree); static tree analyze_scalar_evolution_for_address_of (struct loop *loop, diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c index fe21c07..15df8da 100644 --- a/gcc/tree-ssa-ccp.c +++ b/gcc/tree-ssa-ccp.c @@ -127,7 +127,6 @@ along with GCC; see the file COPYING3. If not see #include "target.h" #include "diagnostic-core.h" #include "dbgcnt.h" -#include "gimple-fold.h" #include "params.h" #include "hash-table.h" diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c index 5ab5389..c85749d 100644 --- a/gcc/tree-ssa-copy.c +++ b/gcc/tree-ssa-copy.c @@ -50,220 +50,6 @@ along with GCC; see the file COPYING3. If not see replacements of one SSA_NAME with a different SSA_NAME to use the APIs defined in this file. */ -/* Return true if we may propagate ORIG into DEST, false otherwise. */ - -bool -may_propagate_copy (tree dest, tree orig) -{ - tree type_d = TREE_TYPE (dest); - tree type_o = TREE_TYPE (orig); - - /* If ORIG flows in from an abnormal edge, it cannot be propagated. */ - if (TREE_CODE (orig) == SSA_NAME - && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (orig) - /* If it is the default definition and an automatic variable then - we can though and it is important that we do to avoid - uninitialized regular copies. */ - && !(SSA_NAME_IS_DEFAULT_DEF (orig) - && (SSA_NAME_VAR (orig) == NULL_TREE - || TREE_CODE (SSA_NAME_VAR (orig)) == VAR_DECL))) - return false; - - /* If DEST is an SSA_NAME that flows from an abnormal edge, then it - cannot be replaced. */ - if (TREE_CODE (dest) == SSA_NAME - && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (dest)) - return false; - - /* Do not copy between types for which we *do* need a conversion. */ - if (!useless_type_conversion_p (type_d, type_o)) - return false; - - /* Generally propagating virtual operands is not ok as that may - create overlapping life-ranges. */ - if (TREE_CODE (dest) == SSA_NAME && virtual_operand_p (dest)) - return false; - - /* Anything else is OK. */ - return true; -} - -/* Like may_propagate_copy, but use as the destination expression - the principal expression (typically, the RHS) contained in - statement DEST. This is more efficient when working with the - gimple tuples representation. */ - -bool -may_propagate_copy_into_stmt (gimple dest, tree orig) -{ - tree type_d; - tree type_o; - - /* If the statement is a switch or a single-rhs assignment, - then the expression to be replaced by the propagation may - be an SSA_NAME. Fortunately, there is an explicit tree - for the expression, so we delegate to may_propagate_copy. */ - - if (gimple_assign_single_p (dest)) - return may_propagate_copy (gimple_assign_rhs1 (dest), orig); - else if (gimple_code (dest) == GIMPLE_SWITCH) - return may_propagate_copy (gimple_switch_index (dest), orig); - - /* In other cases, the expression is not materialized, so there - is no destination to pass to may_propagate_copy. On the other - hand, the expression cannot be an SSA_NAME, so the analysis - is much simpler. */ - - if (TREE_CODE (orig) == SSA_NAME - && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (orig)) - return false; - - if (is_gimple_assign (dest)) - type_d = TREE_TYPE (gimple_assign_lhs (dest)); - else if (gimple_code (dest) == GIMPLE_COND) - type_d = boolean_type_node; - else if (is_gimple_call (dest) - && gimple_call_lhs (dest) != NULL_TREE) - type_d = TREE_TYPE (gimple_call_lhs (dest)); - else - gcc_unreachable (); - - type_o = TREE_TYPE (orig); - - if (!useless_type_conversion_p (type_d, type_o)) - return false; - - return true; -} - -/* Similarly, but we know that we're propagating into an ASM_EXPR. */ - -bool -may_propagate_copy_into_asm (tree dest ATTRIBUTE_UNUSED) -{ - return true; -} - - -/* Common code for propagate_value and replace_exp. - - Replace use operand OP_P with VAL. FOR_PROPAGATION indicates if the - replacement is done to propagate a value or not. */ - -static void -replace_exp_1 (use_operand_p op_p, tree val, - bool for_propagation ATTRIBUTE_UNUSED) -{ -#if defined ENABLE_CHECKING - tree op = USE_FROM_PTR (op_p); - - gcc_assert (!(for_propagation - && TREE_CODE (op) == SSA_NAME - && TREE_CODE (val) == SSA_NAME - && !may_propagate_copy (op, val))); -#endif - - if (TREE_CODE (val) == SSA_NAME) - SET_USE (op_p, val); - else - SET_USE (op_p, unshare_expr (val)); -} - - -/* Propagate the value VAL (assumed to be a constant or another SSA_NAME) - into the operand pointed to by OP_P. - - Use this version for const/copy propagation as it will perform additional - checks to ensure validity of the const/copy propagation. */ - -void -propagate_value (use_operand_p op_p, tree val) -{ - replace_exp_1 (op_p, val, true); -} - -/* Replace *OP_P with value VAL (assumed to be a constant or another SSA_NAME). - - Use this version when not const/copy propagating values. For example, - PRE uses this version when building expressions as they would appear - in specific blocks taking into account actions of PHI nodes. - - The statement in which an expression has been replaced should be - folded using fold_stmt_inplace. */ - -void -replace_exp (use_operand_p op_p, tree val) -{ - replace_exp_1 (op_p, val, false); -} - - -/* Propagate the value VAL (assumed to be a constant or another SSA_NAME) - into the tree pointed to by OP_P. - - Use this version for const/copy propagation when SSA operands are not - available. It will perform the additional checks to ensure validity of - the const/copy propagation, but will not update any operand information. - Be sure to mark the stmt as modified. */ - -void -propagate_tree_value (tree *op_p, tree val) -{ - gcc_checking_assert (!(TREE_CODE (val) == SSA_NAME - && *op_p - && TREE_CODE (*op_p) == SSA_NAME - && !may_propagate_copy (*op_p, val))); - - if (TREE_CODE (val) == SSA_NAME) - *op_p = val; - else - *op_p = unshare_expr (val); -} - - -/* Like propagate_tree_value, but use as the operand to replace - the principal expression (typically, the RHS) contained in the - statement referenced by iterator GSI. Note that it is not - always possible to update the statement in-place, so a new - statement may be created to replace the original. */ - -void -propagate_tree_value_into_stmt (gimple_stmt_iterator *gsi, tree val) -{ - gimple stmt = gsi_stmt (*gsi); - - if (is_gimple_assign (stmt)) - { - tree expr = NULL_TREE; - if (gimple_assign_single_p (stmt)) - expr = gimple_assign_rhs1 (stmt); - propagate_tree_value (&expr, val); - gimple_assign_set_rhs_from_tree (gsi, expr); - } - else if (gimple_code (stmt) == GIMPLE_COND) - { - tree lhs = NULL_TREE; - tree rhs = build_zero_cst (TREE_TYPE (val)); - propagate_tree_value (&lhs, val); - gimple_cond_set_code (stmt, NE_EXPR); - gimple_cond_set_lhs (stmt, lhs); - gimple_cond_set_rhs (stmt, rhs); - } - else if (is_gimple_call (stmt) - && gimple_call_lhs (stmt) != NULL_TREE) - { - tree expr = NULL_TREE; - bool res; - propagate_tree_value (&expr, val); - res = update_call_from_tree (gsi, expr); - gcc_assert (res); - } - else if (gimple_code (stmt) == GIMPLE_SWITCH) - propagate_tree_value (gimple_switch_index_ptr (stmt), val); - else - gcc_unreachable (); -} - /*--------------------------------------------------------------------------- Copy propagation ---------------------------------------------------------------------------*/ diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index bd13476..50027eb 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -44,6 +44,7 @@ along with GCC; see the file COPYING3. If not see #include "dbgcnt.h" #include "domwalk.h" #include "ipa-prop.h" +#include "tree-ssa-propagate.h" /* TODO: diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c index e5dfabc..591f550 100644 --- a/gcc/tree-ssa-propagate.c +++ b/gcc/tree-ssa-propagate.c @@ -1226,4 +1226,219 @@ substitute_and_fold (ssa_prop_get_value_fn get_value_fn, return something_changed; } + +/* Return true if we may propagate ORIG into DEST, false otherwise. */ + +bool +may_propagate_copy (tree dest, tree orig) +{ + tree type_d = TREE_TYPE (dest); + tree type_o = TREE_TYPE (orig); + + /* If ORIG flows in from an abnormal edge, it cannot be propagated. */ + if (TREE_CODE (orig) == SSA_NAME + && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (orig) + /* If it is the default definition and an automatic variable then + we can though and it is important that we do to avoid + uninitialized regular copies. */ + && !(SSA_NAME_IS_DEFAULT_DEF (orig) + && (SSA_NAME_VAR (orig) == NULL_TREE + || TREE_CODE (SSA_NAME_VAR (orig)) == VAR_DECL))) + return false; + + /* If DEST is an SSA_NAME that flows from an abnormal edge, then it + cannot be replaced. */ + if (TREE_CODE (dest) == SSA_NAME + && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (dest)) + return false; + + /* Do not copy between types for which we *do* need a conversion. */ + if (!useless_type_conversion_p (type_d, type_o)) + return false; + + /* Generally propagating virtual operands is not ok as that may + create overlapping life-ranges. */ + if (TREE_CODE (dest) == SSA_NAME && virtual_operand_p (dest)) + return false; + + /* Anything else is OK. */ + return true; +} + +/* Like may_propagate_copy, but use as the destination expression + the principal expression (typically, the RHS) contained in + statement DEST. This is more efficient when working with the + gimple tuples representation. */ + +bool +may_propagate_copy_into_stmt (gimple dest, tree orig) +{ + tree type_d; + tree type_o; + + /* If the statement is a switch or a single-rhs assignment, + then the expression to be replaced by the propagation may + be an SSA_NAME. Fortunately, there is an explicit tree + for the expression, so we delegate to may_propagate_copy. */ + + if (gimple_assign_single_p (dest)) + return may_propagate_copy (gimple_assign_rhs1 (dest), orig); + else if (gimple_code (dest) == GIMPLE_SWITCH) + return may_propagate_copy (gimple_switch_index (dest), orig); + + /* In other cases, the expression is not materialized, so there + is no destination to pass to may_propagate_copy. On the other + hand, the expression cannot be an SSA_NAME, so the analysis + is much simpler. */ + + if (TREE_CODE (orig) == SSA_NAME + && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (orig)) + return false; + + if (is_gimple_assign (dest)) + type_d = TREE_TYPE (gimple_assign_lhs (dest)); + else if (gimple_code (dest) == GIMPLE_COND) + type_d = boolean_type_node; + else if (is_gimple_call (dest) + && gimple_call_lhs (dest) != NULL_TREE) + type_d = TREE_TYPE (gimple_call_lhs (dest)); + else + gcc_unreachable (); + + type_o = TREE_TYPE (orig); + + if (!useless_type_conversion_p (type_d, type_o)) + return false; + + return true; +} + +/* Similarly, but we know that we're propagating into an ASM_EXPR. */ + +bool +may_propagate_copy_into_asm (tree dest ATTRIBUTE_UNUSED) +{ + return true; +} + + +/* Common code for propagate_value and replace_exp. + + Replace use operand OP_P with VAL. FOR_PROPAGATION indicates if the + replacement is done to propagate a value or not. */ + +static void +replace_exp_1 (use_operand_p op_p, tree val, + bool for_propagation ATTRIBUTE_UNUSED) +{ +#if defined ENABLE_CHECKING + tree op = USE_FROM_PTR (op_p); + + gcc_assert (!(for_propagation + && TREE_CODE (op) == SSA_NAME + && TREE_CODE (val) == SSA_NAME + && !may_propagate_copy (op, val))); +#endif + + if (TREE_CODE (val) == SSA_NAME) + SET_USE (op_p, val); + else + SET_USE (op_p, unshare_expr (val)); +} + + +/* Propagate the value VAL (assumed to be a constant or another SSA_NAME) + into the operand pointed to by OP_P. + + Use this version for const/copy propagation as it will perform additional + checks to ensure validity of the const/copy propagation. */ + +void +propagate_value (use_operand_p op_p, tree val) +{ + replace_exp_1 (op_p, val, true); +} + +/* Replace *OP_P with value VAL (assumed to be a constant or another SSA_NAME). + + Use this version when not const/copy propagating values. For example, + PRE uses this version when building expressions as they would appear + in specific blocks taking into account actions of PHI nodes. + + The statement in which an expression has been replaced should be + folded using fold_stmt_inplace. */ + +void +replace_exp (use_operand_p op_p, tree val) +{ + replace_exp_1 (op_p, val, false); +} + + +/* Propagate the value VAL (assumed to be a constant or another SSA_NAME) + into the tree pointed to by OP_P. + + Use this version for const/copy propagation when SSA operands are not + available. It will perform the additional checks to ensure validity of + the const/copy propagation, but will not update any operand information. + Be sure to mark the stmt as modified. */ + +void +propagate_tree_value (tree *op_p, tree val) +{ + gcc_checking_assert (!(TREE_CODE (val) == SSA_NAME + && *op_p + && TREE_CODE (*op_p) == SSA_NAME + && !may_propagate_copy (*op_p, val))); + + if (TREE_CODE (val) == SSA_NAME) + *op_p = val; + else + *op_p = unshare_expr (val); +} + + +/* Like propagate_tree_value, but use as the operand to replace + the principal expression (typically, the RHS) contained in the + statement referenced by iterator GSI. Note that it is not + always possible to update the statement in-place, so a new + statement may be created to replace the original. */ + +void +propagate_tree_value_into_stmt (gimple_stmt_iterator *gsi, tree val) +{ + gimple stmt = gsi_stmt (*gsi); + + if (is_gimple_assign (stmt)) + { + tree expr = NULL_TREE; + if (gimple_assign_single_p (stmt)) + expr = gimple_assign_rhs1 (stmt); + propagate_tree_value (&expr, val); + gimple_assign_set_rhs_from_tree (gsi, expr); + } + else if (gimple_code (stmt) == GIMPLE_COND) + { + tree lhs = NULL_TREE; + tree rhs = build_zero_cst (TREE_TYPE (val)); + propagate_tree_value (&lhs, val); + gimple_cond_set_code (stmt, NE_EXPR); + gimple_cond_set_lhs (stmt, lhs); + gimple_cond_set_rhs (stmt, rhs); + } + else if (is_gimple_call (stmt) + && gimple_call_lhs (stmt) != NULL_TREE) + { + tree expr = NULL_TREE; + bool res; + propagate_tree_value (&expr, val); + res = update_call_from_tree (gsi, expr); + gcc_assert (res); + } + else if (gimple_code (stmt) == GIMPLE_SWITCH) + propagate_tree_value (gimple_switch_index_ptr (stmt), val); + else + gcc_unreachable (); +} + #include "gt-tree-ssa-propagate.h" diff --git a/gcc/tree-ssa-propagate.h b/gcc/tree-ssa-propagate.h index cd6f025..1b8bf90 100644 --- a/gcc/tree-ssa-propagate.h +++ b/gcc/tree-ssa-propagate.h @@ -68,13 +68,20 @@ typedef bool (*ssa_prop_fold_stmt_fn) (gimple_stmt_iterator *gsi); typedef tree (*ssa_prop_get_value_fn) (tree); -/* In tree-ssa-propagate.c */ -void ssa_propagate (ssa_prop_visit_stmt_fn, ssa_prop_visit_phi_fn); -bool valid_gimple_rhs_p (tree); -void move_ssa_defining_stmt_for_defs (gimple, gimple); -bool update_gimple_call (gimple_stmt_iterator *, tree, int, ...); -bool update_call_from_tree (gimple_stmt_iterator *, tree); -bool stmt_makes_single_store (gimple); -bool substitute_and_fold (ssa_prop_get_value_fn, ssa_prop_fold_stmt_fn, bool); +extern bool valid_gimple_rhs_p (tree); +extern void move_ssa_defining_stmt_for_defs (gimple, gimple); +extern bool update_gimple_call (gimple_stmt_iterator *, tree, int, ...); +extern bool update_call_from_tree (gimple_stmt_iterator *, tree); +extern void ssa_propagate (ssa_prop_visit_stmt_fn, ssa_prop_visit_phi_fn); +extern bool stmt_makes_single_store (gimple); +extern bool substitute_and_fold (ssa_prop_get_value_fn, ssa_prop_fold_stmt_fn, + bool); +extern bool may_propagate_copy (tree, tree); +extern bool may_propagate_copy_into_stmt (gimple, tree); +extern bool may_propagate_copy_into_asm (tree); +extern void propagate_value (use_operand_p, tree); +extern void replace_exp (use_operand_p, tree); +extern void propagate_tree_value (tree *, tree); +extern void propagate_tree_value_into_stmt (gimple_stmt_iterator *, tree); #endif /* _TREE_SSA_PROPAGATE_H */ diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index bd2feb4..91604e2 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -37,7 +37,6 @@ along with GCC; see the file COPYING3. If not see #include "params.h" #include "tree-ssa-propagate.h" #include "tree-ssa-sccvn.h" -#include "gimple-fold.h" /* This algorithm is based on the SCC algorithm presented by Keith Cooper and L. Taylor Simpson in "SCC-Based Value numbering" diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index 52d9008..3464529 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -37,7 +37,6 @@ along with GCC; see the file COPYING3. If not see #include "tree-ssa-propagate.h" #include "tree-chrec.h" #include "tree-ssa-threadupdate.h" -#include "gimple-fold.h" #include "expr.h" #include "optabs.h" |