* tree-chrec.c: Include tree-scalar-evolution.h.
(chrec_convert): Instantiate the base and step before calling
scev_probably_wraps_p that would fail on parametric evolutions.
Collect all the fails into a single section failed_to_convert,
print a diagnostic, and return chrec_dont_know instead of calling
fold_convert.
* tree-scalar-evolution.c (loop_closed_phi_def): New.
(instantiate_parameters_1): Avoid instantiation of loop closed ssa
phi nodes.
(scev_const_prop): Don't replace the definition of a loop closed ssa
phi node by itself, or by another loop closed ssa phi node.
* tree-ssa-loop-niter.c (scev_probably_wraps_p, convert_step): Check
that base and step are defined.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@104092
138bc75d-0d04-0410-961f-
82ee72b054a4
+2005-09-09 Sebastian Pop <pop@cri.ensmp.fr>
+
+ * Makefile.in (tree-chrec.o): Depends on SCEV_H.
+ * tree-chrec.c: Include tree-scalar-evolution.h.
+ (chrec_convert): Instantiate the base and step before calling
+ scev_probably_wraps_p that would fail on parametric evolutions.
+ Collect all the fails into a single section failed_to_convert,
+ print a diagnostic, and return chrec_dont_know instead of calling
+ fold_convert.
+ * tree-scalar-evolution.c (loop_closed_phi_def): New.
+ (instantiate_parameters_1): Avoid instantiation of loop closed ssa
+ phi nodes.
+ (scev_const_prop): Don't replace the definition of a loop closed ssa
+ phi node by itself, or by another loop closed ssa phi node.
+ * tree-ssa-loop-niter.c (scev_probably_wraps_p, convert_step): Check
+ that base and step are defined.
+
2005-09-09 Richard Guenther <rguenther@suse.de>
PR c++/23624
$(TREE_H) tree-inline.h $(DIAGNOSTIC_H) $(HASHTAB_H) \
$(TM_H) coretypes.h
tree-chrec.o: tree-chrec.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
- $(GGC_H) $(TREE_H) real.h tree-chrec.h tree-pass.h $(PARAMS_H) \
+ $(GGC_H) $(TREE_H) real.h $(SCEV_H) tree-pass.h $(PARAMS_H) \
$(DIAGNOSTIC_H) $(VARRAY_H) $(CFGLOOP_H) $(TREE_FLOW_H)
tree-scalar-evolution.o: tree-scalar-evolution.c $(CONFIG_H) $(SYSTEM_H) \
coretypes.h $(TM_H) $(GGC_H) $(TREE_H) real.h $(RTL_H) \
#include "tree-chrec.h"
#include "tree-pass.h"
#include "params.h"
+#include "tree-scalar-evolution.h"
\f
if (evolution_function_is_affine_p (chrec))
{
- tree step;
+ tree base, step;
bool dummy;
+ struct loop *loop = current_loops->parray[CHREC_VARIABLE (chrec)];
+
+ base = instantiate_parameters (loop, CHREC_LEFT (chrec));
+ step = instantiate_parameters (loop, CHREC_RIGHT (chrec));
/* Avoid conversion of (signed char) {(uchar)1, +, (uchar)1}_x
when it is not possible to prove that the scev does not wrap.
1, 2, ..., 127, -128, ... The result should not be
{(schar)1, +, (schar)1}_x, but instead, we should keep the
conversion: (schar) {(uchar)1, +, (uchar)1}_x. */
- if (scev_probably_wraps_p (type, CHREC_LEFT (chrec), CHREC_RIGHT (chrec),
- at_stmt,
- current_loops->parray[CHREC_VARIABLE (chrec)],
+ if (scev_probably_wraps_p (type, base, step, at_stmt, loop,
&dummy, &dummy))
- return fold_convert (type, chrec);
+ goto failed_to_convert;
- step = convert_step (current_loops->parray[CHREC_VARIABLE (chrec)], type,
- CHREC_LEFT (chrec), CHREC_RIGHT (chrec), at_stmt);
+ step = convert_step (loop, type, base, step, at_stmt);
if (!step)
- return fold_convert (type, chrec);
+ {
+ failed_to_convert:;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "(failed conversion:");
+ fprintf (dump_file, "\n type: ");
+ print_generic_expr (dump_file, type, 0);
+ fprintf (dump_file, "\n base: ");
+ print_generic_expr (dump_file, base, 0);
+ fprintf (dump_file, "\n step: ");
+ print_generic_expr (dump_file, step, 0);
+ fprintf (dump_file, "\n estimated_nb_iterations: ");
+ print_generic_expr (dump_file, loop->estimated_nb_iterations, 0);
+ fprintf (dump_file, "\n)\n");
+ }
+
+ /* Directly convert to "don't know": no worth dealing with
+ difficult cases. */
+ return chrec_dont_know;
+ }
return build_polynomial_chrec (CHREC_VARIABLE (chrec),
chrec_convert (type, CHREC_LEFT (chrec),
info->chrec = val;
}
+/* Return the closed_loop_phi node for VAR. If there is none, return
+ NULL_TREE. */
+
+static tree
+loop_closed_phi_def (tree var)
+{
+ struct loop *loop;
+ edge exit;
+ tree phi;
+
+ if (var == NULL_TREE
+ || TREE_CODE (var) != SSA_NAME)
+ return NULL_TREE;
+
+ loop = loop_containing_stmt (SSA_NAME_DEF_STMT (var));
+ exit = loop->single_exit;
+ if (!exit)
+ return NULL_TREE;
+
+ for (phi = phi_nodes (exit->dest); phi; phi = PHI_CHAIN (phi))
+ if (PHI_ARG_DEF_FROM_EDGE (phi, exit) == var)
+ return PHI_RESULT (phi);
+
+ return NULL_TREE;
+}
+
/* Analyze all the parameters of the chrec that were left under a symbolic form,
with respect to LOOP. CHREC is the chrec to instantiate. If
ALLOW_SUPERLOOP_CHRECS is true, replacing loop invariants with
result again. */
bitmap_set_bit (already_instantiated, SSA_NAME_VERSION (chrec));
res = analyze_scalar_evolution (def_loop, chrec);
- if (res != chrec_dont_know)
+
+ /* Don't instantiate loop-closed-ssa phi nodes. */
+ if (TREE_CODE (res) == SSA_NAME
+ && (loop_containing_stmt (SSA_NAME_DEF_STMT (res)) == NULL
+ || (loop_containing_stmt (SSA_NAME_DEF_STMT (res))->depth
+ > def_loop->depth)))
+ {
+ if (res == chrec)
+ res = loop_closed_phi_def (chrec);
+ else
+ res = chrec;
+
+ if (res == NULL_TREE)
+ res = chrec_dont_know;
+ }
+
+ else if (res != chrec_dont_know)
res = instantiate_parameters_1 (loop, res, allow_superloop_chrecs,
cache);
+
bitmap_clear_bit (already_instantiated, SSA_NAME_VERSION (chrec));
/* Store the correct value to the cache. */
continue;
/* Replace the uses of the name. */
- replace_uses_by (name, ev);
+ if (name != ev)
+ replace_uses_by (name, ev);
if (!ssa_names_to_remove)
ssa_names_to_remove = BITMAP_ALLOC (NULL);
def = analyze_scalar_evolution_in_loop (ex_loop, ex_loop, def);
if (!tree_does_not_contain_chrecs (def)
- || chrec_contains_symbols_defined_in_loop (def, loop->num))
+ || chrec_contains_symbols_defined_in_loop (def, loop->num)
+ || def == PHI_RESULT (phi)
+ || (TREE_CODE (def) == SSA_NAME
+ && loop_containing_stmt (SSA_NAME_DEF_STMT (def))
+ && loop_containing_stmt (phi)
+ && loop_containing_stmt (SSA_NAME_DEF_STMT (def))
+ == loop_containing_stmt (phi)))
continue;
/* If computing the expression is expensive, let it remain in
}
}
- if (TREE_CODE (base) == REAL_CST
+ if (chrec_contains_undetermined (base)
+ || chrec_contains_undetermined (step)
+ || TREE_CODE (base) == REAL_CST
|| TREE_CODE (step) == REAL_CST)
{
*unknown_max = true;
convert_step (struct loop *loop, tree new_type, tree base, tree step,
tree at_stmt)
{
- tree base_type = TREE_TYPE (base);
+ tree base_type;
+
+ if (chrec_contains_undetermined (base)
+ || chrec_contains_undetermined (step))
+ return NULL_TREE;
+
+ base_type = TREE_TYPE (base);
/* When not using wrapping arithmetic, signed types don't wrap. */
if (!flag_wrapv && !TYPE_UNSIGNED (base_type))
OSDN Git Service
