+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
#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"
#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 */
#include "tree.h"
#include "tree-ssa-alias.h"
#include "internal-fn.h"
+#include "gimple-fold.h"
typedef gimple gimple_seq_node;
#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);
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
#include "tree-pass.h"
#include "value-prof.h"
#include "sese.h"
+#include "tree-ssa-propagate.h"
/* Print to stderr the element ELT. */
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);
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 *);
#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,
#include "target.h"
#include "diagnostic-core.h"
#include "dbgcnt.h"
-#include "gimple-fold.h"
#include "params.h"
#include "hash-table.h"
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
---------------------------------------------------------------------------*/
#include "dbgcnt.h"
#include "domwalk.h"
#include "ipa-prop.h"
+#include "tree-ssa-propagate.h"
/* TODO:
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"
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 */
#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"
#include "tree-ssa-propagate.h"
#include "tree-chrec.h"
#include "tree-ssa-threadupdate.h"
-#include "gimple-fold.h"
#include "expr.h"
#include "optabs.h"
git://gcc.gnu.org / gcc.git / commitdiff