static VEC (switch_update, heap) *to_update_switch_stmts;
-/* Return the maximum value for TYPEs base type. */
+/* Return the maximum value for TYPE. */
static inline tree
vrp_val_max (const_tree type)
if (!INTEGRAL_TYPE_P (type))
return NULL_TREE;
- /* For integer sub-types the values for the base type are relevant. */
- if (TREE_TYPE (type))
- type = TREE_TYPE (type);
-
return TYPE_MAX_VALUE (type);
}
-/* Return the minimum value for TYPEs base type. */
+/* Return the minimum value for TYPE. */
static inline tree
vrp_val_min (const_tree type)
if (!INTEGRAL_TYPE_P (type))
return NULL_TREE;
- /* For integer sub-types the values for the base type are relevant. */
- if (TREE_TYPE (type))
- type = TREE_TYPE (type);
-
return TYPE_MIN_VALUE (type);
}
static inline bool
needs_overflow_infinity (const_tree type)
{
- return (INTEGRAL_TYPE_P (type)
- && !TYPE_OVERFLOW_WRAPS (type)
- /* Integer sub-types never overflow as they are never
- operands of arithmetic operators. */
- && !(TREE_TYPE (type) && TREE_TYPE (type) != type));
+ return INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type);
}
/* Return whether TYPE can support our overflow infinity
tree inner_type = TREE_TYPE (op0);
tree outer_type = type;
- /* Always use base-types here. This is important for the
- correct signedness. */
- if (TREE_TYPE (inner_type))
- inner_type = TREE_TYPE (inner_type);
- if (TREE_TYPE (outer_type))
- outer_type = TREE_TYPE (outer_type);
-
/* If VR0 is varying and we increase the type precision, assume
a full range for the following transformation. */
if (vr0.type == VR_VARYING
stmt = gsi_stmt (si);
+ if (is_gimple_debug (stmt))
+ continue;
+
/* See if we can derive an assertion for any of STMT's operands. */
FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE)
{
IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside a ADDR_EXPR. */
static void
-check_array_ref (tree ref, location_t location, bool ignore_off_by_one)
+check_array_ref (location_t location, tree ref, bool ignore_off_by_one)
{
value_range_t* vr = NULL;
tree low_sub, up_sub;
do
{
if (TREE_CODE (t) == ARRAY_REF)
- check_array_ref (t, location, true /*ignore_off_by_one*/);
+ check_array_ref (location, t, true /*ignore_off_by_one*/);
t = TREE_OPERAND (t, 0);
}
{
tree t = *tp;
struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
- const location_t *location = (const location_t *) wi->info;
+ location_t location;
+
+ if (EXPR_HAS_LOCATION (t))
+ location = EXPR_LOCATION (t);
+ else
+ {
+ location_t *locp = (location_t *) wi->info;
+ location = *locp;
+ }
*walk_subtree = TRUE;
if (TREE_CODE (t) == ARRAY_REF)
- check_array_ref (t, *location, false /*ignore_off_by_one*/);
+ check_array_ref (location, t, false /*ignore_off_by_one*/);
if (TREE_CODE (t) == INDIRECT_REF
|| (TREE_CODE (t) == RETURN_EXPR && TREE_OPERAND (t, 0)))
- search_for_addr_array (TREE_OPERAND (t, 0), *location);
+ search_for_addr_array (TREE_OPERAND (t, 0), location);
if (TREE_CODE (t) == ADDR_EXPR)
*walk_subtree = FALSE;
{
gimple stmt = gsi_stmt (si);
- if (!stmt_interesting_for_vrp (stmt))
+ /* If the statement is a control insn, then we do not
+ want to avoid simulating the statement once. Failure
+ to do so means that those edges will never get added. */
+ if (stmt_ends_bb_p (stmt))
+ prop_set_simulate_again (stmt, true);
+ else if (!stmt_interesting_for_vrp (stmt))
{
ssa_op_iter i;
tree def;
prop_set_simulate_again (stmt, false);
}
else
- {
- prop_set_simulate_again (stmt, true);
- }
+ prop_set_simulate_again (stmt, true);
}
}
}
based on undefined signed overflow, issue a warning if
appropriate. */
-tree
+static tree
vrp_evaluate_conditional (enum tree_code code, tree op0, tree op1, gimple stmt)
{
bool sop;
tree ret;
bool only_ranges;
+ /* Some passes and foldings leak constants with overflow flag set
+ into the IL. Avoid doing wrong things with these and bail out. */
+ if ((TREE_CODE (op0) == INTEGER_CST
+ && TREE_OVERFLOW (op0))
+ || (TREE_CODE (op1) == INTEGER_CST
+ && TREE_OVERFLOW (op1)))
+ return NULL_TREE;
+
sop = false;
ret = vrp_evaluate_conditional_warnv_with_ops (code, op0, op1, true, &sop,
&only_ranges);
location = input_location;
else
location = gimple_location (stmt);
- warning (OPT_Wstrict_overflow, "%H%s", &location, warnmsg);
+ warning_at (location, OPT_Wstrict_overflow, "%s", warnmsg);
}
}
the natural range of OP0's type, then the predicate will
always fold regardless of the value of OP0. If -Wtype-limits
was specified, emit a warning. */
- const char *warnmsg = NULL;
tree type = TREE_TYPE (op0);
value_range_t *vr0 = get_value_range (op0);
&& vrp_val_is_max (vr0->max)
&& is_gimple_min_invariant (op1))
{
- if (integer_zerop (ret))
- warnmsg = G_("comparison always false due to limited range of "
- "data type");
- else
- warnmsg = G_("comparison always true due to limited range of "
- "data type");
- }
-
- if (warnmsg)
- {
location_t location;
if (!gimple_has_location (stmt))
else
location = gimple_location (stmt);
- warning (OPT_Wtype_limits, "%H%s", &location, warnmsg);
+ warning_at (location, OPT_Wtype_limits,
+ integer_zerop (ret)
+ ? G_("comparison always false "
+ "due to limited range of data type")
+ : G_("comparison always true "
+ "due to limited range of data type"));
}
}
fprintf (dump_file, "\n");
}
- if (is_gimple_assign (stmt) || is_gimple_call (stmt))
+ if (!stmt_interesting_for_vrp (stmt))
+ gcc_assert (stmt_ends_bb_p (stmt));
+ else if (is_gimple_assign (stmt) || is_gimple_call (stmt))
{
/* In general, assignments with virtual operands are not useful
for deriving ranges, with the obvious exception of calls to
location = input_location;
else
location = gimple_location (stmt);
- warning (OPT_Wstrict_overflow,
- ("%Hassuming signed overflow does not occur when "
- "simplifying / or %% to >> or &"),
- &location);
+ warning_at (location, OPT_Wstrict_overflow,
+ "assuming signed overflow does not occur when "
+ "simplifying %</%> or %<%%%> to %<>>%> or %<&%>");
}
}
location = input_location;
else
location = gimple_location (stmt);
- warning (OPT_Wstrict_overflow,
- ("%Hassuming signed overflow does not occur when "
- "simplifying abs (X) to X or -X"),
- &location);
+ warning_at (location, OPT_Wstrict_overflow,
+ "assuming signed overflow does not occur when "
+ "simplifying %<abs (X)%> to %<X%> or %<-X%>");
}
gimple_assign_set_rhs1 (stmt, op);
value range information we have for op0. */
if (min && max)
{
- if (compare_values (vr->min, min) == -1)
- min = min;
- else
+ if (compare_values (vr->min, min) == 1)
min = vr->min;
- if (compare_values (vr->max, max) == 1)
- max = max;
- else
+ if (compare_values (vr->max, max) == -1)
max = vr->max;
/* If the new min/max values have converged to a single value,
/* Simplify STMT using ranges if possible. */
-bool
+static bool
simplify_stmt_using_ranges (gimple_stmt_iterator *gsi)
{
gimple stmt = gsi_stmt (*gsi);
return false;
}
+/* If the statement pointed by SI has a predicate whose value can be
+ computed using the value range information computed by VRP, compute
+ its value and return true. Otherwise, return false. */
+
+static bool
+fold_predicate_in (gimple_stmt_iterator *si)
+{
+ bool assignment_p = false;
+ tree val;
+ gimple stmt = gsi_stmt (*si);
+
+ if (is_gimple_assign (stmt)
+ && TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
+ {
+ assignment_p = true;
+ val = vrp_evaluate_conditional (gimple_assign_rhs_code (stmt),
+ gimple_assign_rhs1 (stmt),
+ gimple_assign_rhs2 (stmt),
+ stmt);
+ }
+ else if (gimple_code (stmt) == GIMPLE_COND)
+ val = vrp_evaluate_conditional (gimple_cond_code (stmt),
+ gimple_cond_lhs (stmt),
+ gimple_cond_rhs (stmt),
+ stmt);
+ else
+ return false;
+
+ if (val)
+ {
+ if (assignment_p)
+ val = fold_convert (gimple_expr_type (stmt), val);
+
+ if (dump_file)
+ {
+ fprintf (dump_file, "Folding predicate ");
+ print_gimple_expr (dump_file, stmt, 0, 0);
+ fprintf (dump_file, " to ");
+ print_generic_expr (dump_file, val, 0);
+ fprintf (dump_file, "\n");
+ }
+
+ if (is_gimple_assign (stmt))
+ gimple_assign_set_rhs_from_tree (si, val);
+ else
+ {
+ gcc_assert (gimple_code (stmt) == GIMPLE_COND);
+ if (integer_zerop (val))
+ gimple_cond_make_false (stmt);
+ else if (integer_onep (val))
+ gimple_cond_make_true (stmt);
+ else
+ gcc_unreachable ();
+ }
+
+ return true;
+ }
+
+ return false;
+}
+
+/* Callback for substitute_and_fold folding the stmt at *SI. */
+
+static bool
+vrp_fold_stmt (gimple_stmt_iterator *si)
+{
+ if (fold_predicate_in (si))
+ return true;
+
+ return simplify_stmt_using_ranges (si);
+}
+
/* Stack of dest,src equivalency pairs that need to be restored after
each attempt to thread a block's incoming edge to an outgoing edge.
}
/* We may have ended with ranges that have exactly one value. Those
- values can be substituted as any other copy/const propagated
+ values can be substituted as any other const propagated
value using substitute_and_fold. */
single_val_range = XCNEWVEC (prop_value_t, num_ssa_names);
for (i = 0; i < num_ssa_names; i++)
if (vr_value[i]
&& vr_value[i]->type == VR_RANGE
- && vr_value[i]->min == vr_value[i]->max)
+ && vr_value[i]->min == vr_value[i]->max
+ && is_gimple_min_invariant (vr_value[i]->min))
{
single_val_range[i].value = vr_value[i]->min;
do_value_subst_p = true;
single_val_range = NULL;
}
- substitute_and_fold (single_val_range, true);
+ substitute_and_fold (single_val_range, vrp_fold_stmt);
if (warn_array_bounds)
check_all_array_refs ();
NULL, /* next */
0, /* static_pass_number */
TV_TREE_VRP, /* tv_id */
- PROP_ssa | PROP_alias, /* properties_required */
+ PROP_ssa, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
OSDN Git Service
