/* Support routines for Value Range Propagation (VRP).
|
/* Support routines for Value Range Propagation (VRP).
|
Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
|
Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
|
Contributed by Diego Novillo <dnovillo@redhat.com>.
|
Contributed by Diego Novillo <dnovillo@redhat.com>.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify
|
GCC is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3, or (at your option)
|
the Free Software Foundation; either version 3, or (at your option)
|
any later version.
|
any later version.
|
|
|
GCC is distributed in the hope that it will be useful,
|
GCC is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "tree-dump.h"
|
#include "tree-dump.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "intl.h"
|
#include "intl.h"
|
#include "cfgloop.h"
|
#include "cfgloop.h"
|
#include "tree-scalar-evolution.h"
|
#include "tree-scalar-evolution.h"
|
#include "tree-ssa-propagate.h"
|
#include "tree-ssa-propagate.h"
|
#include "tree-chrec.h"
|
#include "tree-chrec.h"
|
|
|
/* Set of SSA names found during the dominator traversal of a
|
/* Set of SSA names found during the dominator traversal of a
|
sub-graph in find_assert_locations. */
|
sub-graph in find_assert_locations. */
|
static sbitmap found_in_subgraph;
|
static sbitmap found_in_subgraph;
|
|
|
/* Local functions. */
|
/* Local functions. */
|
static int compare_values (tree val1, tree val2);
|
static int compare_values (tree val1, tree val2);
|
static int compare_values_warnv (tree val1, tree val2, bool *);
|
static int compare_values_warnv (tree val1, tree val2, bool *);
|
static tree vrp_evaluate_conditional_warnv (tree, bool, bool *);
|
static tree vrp_evaluate_conditional_warnv (tree, bool, bool *);
|
|
|
/* Location information for ASSERT_EXPRs. Each instance of this
|
/* Location information for ASSERT_EXPRs. Each instance of this
|
structure describes an ASSERT_EXPR for an SSA name. Since a single
|
structure describes an ASSERT_EXPR for an SSA name. Since a single
|
SSA name may have more than one assertion associated with it, these
|
SSA name may have more than one assertion associated with it, these
|
locations are kept in a linked list attached to the corresponding
|
locations are kept in a linked list attached to the corresponding
|
SSA name. */
|
SSA name. */
|
struct assert_locus_d
|
struct assert_locus_d
|
{
|
{
|
/* Basic block where the assertion would be inserted. */
|
/* Basic block where the assertion would be inserted. */
|
basic_block bb;
|
basic_block bb;
|
|
|
/* Some assertions need to be inserted on an edge (e.g., assertions
|
/* Some assertions need to be inserted on an edge (e.g., assertions
|
generated by COND_EXPRs). In those cases, BB will be NULL. */
|
generated by COND_EXPRs). In those cases, BB will be NULL. */
|
edge e;
|
edge e;
|
|
|
/* Pointer to the statement that generated this assertion. */
|
/* Pointer to the statement that generated this assertion. */
|
block_stmt_iterator si;
|
block_stmt_iterator si;
|
|
|
/* Predicate code for the ASSERT_EXPR. Must be COMPARISON_CLASS_P. */
|
/* Predicate code for the ASSERT_EXPR. Must be COMPARISON_CLASS_P. */
|
enum tree_code comp_code;
|
enum tree_code comp_code;
|
|
|
/* Value being compared against. */
|
/* Value being compared against. */
|
tree val;
|
tree val;
|
|
|
/* Next node in the linked list. */
|
/* Next node in the linked list. */
|
struct assert_locus_d *next;
|
struct assert_locus_d *next;
|
};
|
};
|
|
|
typedef struct assert_locus_d *assert_locus_t;
|
typedef struct assert_locus_d *assert_locus_t;
|
|
|
/* If bit I is present, it means that SSA name N_i has a list of
|
/* If bit I is present, it means that SSA name N_i has a list of
|
assertions that should be inserted in the IL. */
|
assertions that should be inserted in the IL. */
|
static bitmap need_assert_for;
|
static bitmap need_assert_for;
|
|
|
/* Array of locations lists where to insert assertions. ASSERTS_FOR[I]
|
/* Array of locations lists where to insert assertions. ASSERTS_FOR[I]
|
holds a list of ASSERT_LOCUS_T nodes that describe where
|
holds a list of ASSERT_LOCUS_T nodes that describe where
|
ASSERT_EXPRs for SSA name N_I should be inserted. */
|
ASSERT_EXPRs for SSA name N_I should be inserted. */
|
static assert_locus_t *asserts_for;
|
static assert_locus_t *asserts_for;
|
|
|
/* Set of blocks visited in find_assert_locations. Used to avoid
|
/* Set of blocks visited in find_assert_locations. Used to avoid
|
visiting the same block more than once. */
|
visiting the same block more than once. */
|
static sbitmap blocks_visited;
|
static sbitmap blocks_visited;
|
|
|
/* Value range array. After propagation, VR_VALUE[I] holds the range
|
/* Value range array. After propagation, VR_VALUE[I] holds the range
|
of values that SSA name N_I may take. */
|
of values that SSA name N_I may take. */
|
static value_range_t **vr_value;
|
static value_range_t **vr_value;
|
|
|
|
|
/* Return whether TYPE should use an overflow infinity distinct from
|
/* Return whether TYPE should use an overflow infinity distinct from
|
TYPE_{MIN,MAX}_VALUE. We use an overflow infinity value to
|
TYPE_{MIN,MAX}_VALUE. We use an overflow infinity value to
|
represent a signed overflow during VRP computations. An infinity
|
represent a signed overflow during VRP computations. An infinity
|
is distinct from a half-range, which will go from some number to
|
is distinct from a half-range, which will go from some number to
|
TYPE_{MIN,MAX}_VALUE. */
|
TYPE_{MIN,MAX}_VALUE. */
|
|
|
static inline bool
|
static inline bool
|
needs_overflow_infinity (tree type)
|
needs_overflow_infinity (tree type)
|
{
|
{
|
return INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type);
|
return INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type);
|
}
|
}
|
|
|
/* Return whether TYPE can support our overflow infinity
|
/* Return whether TYPE can support our overflow infinity
|
representation: we use the TREE_OVERFLOW flag, which only exists
|
representation: we use the TREE_OVERFLOW flag, which only exists
|
for constants. If TYPE doesn't support this, we don't optimize
|
for constants. If TYPE doesn't support this, we don't optimize
|
cases which would require signed overflow--we drop them to
|
cases which would require signed overflow--we drop them to
|
VARYING. */
|
VARYING. */
|
|
|
static inline bool
|
static inline bool
|
supports_overflow_infinity (tree type)
|
supports_overflow_infinity (tree type)
|
{
|
{
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
gcc_assert (needs_overflow_infinity (type));
|
gcc_assert (needs_overflow_infinity (type));
|
#endif
|
#endif
|
return (TYPE_MIN_VALUE (type) != NULL_TREE
|
return (TYPE_MIN_VALUE (type) != NULL_TREE
|
&& CONSTANT_CLASS_P (TYPE_MIN_VALUE (type))
|
&& CONSTANT_CLASS_P (TYPE_MIN_VALUE (type))
|
&& TYPE_MAX_VALUE (type) != NULL_TREE
|
&& TYPE_MAX_VALUE (type) != NULL_TREE
|
&& CONSTANT_CLASS_P (TYPE_MAX_VALUE (type)));
|
&& CONSTANT_CLASS_P (TYPE_MAX_VALUE (type)));
|
}
|
}
|
|
|
/* VAL is the maximum or minimum value of a type. Return a
|
/* VAL is the maximum or minimum value of a type. Return a
|
corresponding overflow infinity. */
|
corresponding overflow infinity. */
|
|
|
static inline tree
|
static inline tree
|
make_overflow_infinity (tree val)
|
make_overflow_infinity (tree val)
|
{
|
{
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
gcc_assert (val != NULL_TREE && CONSTANT_CLASS_P (val));
|
gcc_assert (val != NULL_TREE && CONSTANT_CLASS_P (val));
|
#endif
|
#endif
|
val = copy_node (val);
|
val = copy_node (val);
|
TREE_OVERFLOW (val) = 1;
|
TREE_OVERFLOW (val) = 1;
|
return val;
|
return val;
|
}
|
}
|
|
|
/* Return a negative overflow infinity for TYPE. */
|
/* Return a negative overflow infinity for TYPE. */
|
|
|
static inline tree
|
static inline tree
|
negative_overflow_infinity (tree type)
|
negative_overflow_infinity (tree type)
|
{
|
{
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
gcc_assert (supports_overflow_infinity (type));
|
gcc_assert (supports_overflow_infinity (type));
|
#endif
|
#endif
|
return make_overflow_infinity (TYPE_MIN_VALUE (type));
|
return make_overflow_infinity (TYPE_MIN_VALUE (type));
|
}
|
}
|
|
|
/* Return a positive overflow infinity for TYPE. */
|
/* Return a positive overflow infinity for TYPE. */
|
|
|
static inline tree
|
static inline tree
|
positive_overflow_infinity (tree type)
|
positive_overflow_infinity (tree type)
|
{
|
{
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
gcc_assert (supports_overflow_infinity (type));
|
gcc_assert (supports_overflow_infinity (type));
|
#endif
|
#endif
|
return make_overflow_infinity (TYPE_MAX_VALUE (type));
|
return make_overflow_infinity (TYPE_MAX_VALUE (type));
|
}
|
}
|
|
|
/* Return whether VAL is a negative overflow infinity. */
|
/* Return whether VAL is a negative overflow infinity. */
|
|
|
static inline bool
|
static inline bool
|
is_negative_overflow_infinity (tree val)
|
is_negative_overflow_infinity (tree val)
|
{
|
{
|
return (needs_overflow_infinity (TREE_TYPE (val))
|
return (needs_overflow_infinity (TREE_TYPE (val))
|
&& CONSTANT_CLASS_P (val)
|
&& CONSTANT_CLASS_P (val)
|
&& TREE_OVERFLOW (val)
|
&& TREE_OVERFLOW (val)
|
&& operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0));
|
&& operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0));
|
}
|
}
|
|
|
/* Return whether VAL is a positive overflow infinity. */
|
/* Return whether VAL is a positive overflow infinity. */
|
|
|
static inline bool
|
static inline bool
|
is_positive_overflow_infinity (tree val)
|
is_positive_overflow_infinity (tree val)
|
{
|
{
|
return (needs_overflow_infinity (TREE_TYPE (val))
|
return (needs_overflow_infinity (TREE_TYPE (val))
|
&& CONSTANT_CLASS_P (val)
|
&& CONSTANT_CLASS_P (val)
|
&& TREE_OVERFLOW (val)
|
&& TREE_OVERFLOW (val)
|
&& operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0));
|
&& operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0));
|
}
|
}
|
|
|
/* Return whether VAL is a positive or negative overflow infinity. */
|
/* Return whether VAL is a positive or negative overflow infinity. */
|
|
|
static inline bool
|
static inline bool
|
is_overflow_infinity (tree val)
|
is_overflow_infinity (tree val)
|
{
|
{
|
return (needs_overflow_infinity (TREE_TYPE (val))
|
return (needs_overflow_infinity (TREE_TYPE (val))
|
&& CONSTANT_CLASS_P (val)
|
&& CONSTANT_CLASS_P (val)
|
&& TREE_OVERFLOW (val)
|
&& TREE_OVERFLOW (val)
|
&& (operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0)
|
&& (operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0)
|
|| operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0)));
|
|| operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0)));
|
}
|
}
|
|
|
/* If VAL is now an overflow infinity, return VAL. Otherwise, return
|
/* If VAL is now an overflow infinity, return VAL. Otherwise, return
|
the same value with TREE_OVERFLOW clear. This can be used to avoid
|
the same value with TREE_OVERFLOW clear. This can be used to avoid
|
confusing a regular value with an overflow value. */
|
confusing a regular value with an overflow value. */
|
|
|
static inline tree
|
static inline tree
|
avoid_overflow_infinity (tree val)
|
avoid_overflow_infinity (tree val)
|
{
|
{
|
if (!is_overflow_infinity (val))
|
if (!is_overflow_infinity (val))
|
return val;
|
return val;
|
|
|
if (operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0))
|
if (operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0))
|
return TYPE_MAX_VALUE (TREE_TYPE (val));
|
return TYPE_MAX_VALUE (TREE_TYPE (val));
|
else
|
else
|
{
|
{
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
gcc_assert (operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0));
|
gcc_assert (operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0));
|
#endif
|
#endif
|
return TYPE_MIN_VALUE (TREE_TYPE (val));
|
return TYPE_MIN_VALUE (TREE_TYPE (val));
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Return whether VAL is equal to the maximum value of its type. This
|
/* Return whether VAL is equal to the maximum value of its type. This
|
will be true for a positive overflow infinity. We can't do a
|
will be true for a positive overflow infinity. We can't do a
|
simple equality comparison with TYPE_MAX_VALUE because C typedefs
|
simple equality comparison with TYPE_MAX_VALUE because C typedefs
|
and Ada subtypes can produce types whose TYPE_MAX_VALUE is not ==
|
and Ada subtypes can produce types whose TYPE_MAX_VALUE is not ==
|
to the integer constant with the same value in the type. */
|
to the integer constant with the same value in the type. */
|
|
|
static inline bool
|
static inline bool
|
vrp_val_is_max (tree val)
|
vrp_val_is_max (tree val)
|
{
|
{
|
tree type_max = TYPE_MAX_VALUE (TREE_TYPE (val));
|
tree type_max = TYPE_MAX_VALUE (TREE_TYPE (val));
|
|
|
return (val == type_max
|
return (val == type_max
|
|| (type_max != NULL_TREE
|
|| (type_max != NULL_TREE
|
&& operand_equal_p (val, type_max, 0)));
|
&& operand_equal_p (val, type_max, 0)));
|
}
|
}
|
|
|
/* Return whether VAL is equal to the minimum value of its type. This
|
/* Return whether VAL is equal to the minimum value of its type. This
|
will be true for a negative overflow infinity. */
|
will be true for a negative overflow infinity. */
|
|
|
static inline bool
|
static inline bool
|
vrp_val_is_min (tree val)
|
vrp_val_is_min (tree val)
|
{
|
{
|
tree type_min = TYPE_MIN_VALUE (TREE_TYPE (val));
|
tree type_min = TYPE_MIN_VALUE (TREE_TYPE (val));
|
|
|
return (val == type_min
|
return (val == type_min
|
|| (type_min != NULL_TREE
|
|| (type_min != NULL_TREE
|
&& operand_equal_p (val, type_min, 0)));
|
&& operand_equal_p (val, type_min, 0)));
|
}
|
}
|
|
|
|
|
/* Return true if ARG is marked with the nonnull attribute in the
|
/* Return true if ARG is marked with the nonnull attribute in the
|
current function signature. */
|
current function signature. */
|
|
|
static bool
|
static bool
|
nonnull_arg_p (tree arg)
|
nonnull_arg_p (tree arg)
|
{
|
{
|
tree t, attrs, fntype;
|
tree t, attrs, fntype;
|
unsigned HOST_WIDE_INT arg_num;
|
unsigned HOST_WIDE_INT arg_num;
|
|
|
gcc_assert (TREE_CODE (arg) == PARM_DECL && POINTER_TYPE_P (TREE_TYPE (arg)));
|
gcc_assert (TREE_CODE (arg) == PARM_DECL && POINTER_TYPE_P (TREE_TYPE (arg)));
|
|
|
/* The static chain decl is always non null. */
|
/* The static chain decl is always non null. */
|
if (arg == cfun->static_chain_decl)
|
if (arg == cfun->static_chain_decl)
|
return true;
|
return true;
|
|
|
fntype = TREE_TYPE (current_function_decl);
|
fntype = TREE_TYPE (current_function_decl);
|
attrs = lookup_attribute ("nonnull", TYPE_ATTRIBUTES (fntype));
|
attrs = lookup_attribute ("nonnull", TYPE_ATTRIBUTES (fntype));
|
|
|
/* If "nonnull" wasn't specified, we know nothing about the argument. */
|
/* If "nonnull" wasn't specified, we know nothing about the argument. */
|
if (attrs == NULL_TREE)
|
if (attrs == NULL_TREE)
|
return false;
|
return false;
|
|
|
/* If "nonnull" applies to all the arguments, then ARG is non-null. */
|
/* If "nonnull" applies to all the arguments, then ARG is non-null. */
|
if (TREE_VALUE (attrs) == NULL_TREE)
|
if (TREE_VALUE (attrs) == NULL_TREE)
|
return true;
|
return true;
|
|
|
/* Get the position number for ARG in the function signature. */
|
/* Get the position number for ARG in the function signature. */
|
for (arg_num = 1, t = DECL_ARGUMENTS (current_function_decl);
|
for (arg_num = 1, t = DECL_ARGUMENTS (current_function_decl);
|
t;
|
t;
|
t = TREE_CHAIN (t), arg_num++)
|
t = TREE_CHAIN (t), arg_num++)
|
{
|
{
|
if (t == arg)
|
if (t == arg)
|
break;
|
break;
|
}
|
}
|
|
|
gcc_assert (t == arg);
|
gcc_assert (t == arg);
|
|
|
/* Now see if ARG_NUM is mentioned in the nonnull list. */
|
/* Now see if ARG_NUM is mentioned in the nonnull list. */
|
for (t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
|
for (t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
|
{
|
{
|
if (compare_tree_int (TREE_VALUE (t), arg_num) == 0)
|
if (compare_tree_int (TREE_VALUE (t), arg_num) == 0)
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Set value range VR to {T, MIN, MAX, EQUIV}. */
|
/* Set value range VR to {T, MIN, MAX, EQUIV}. */
|
|
|
static void
|
static void
|
set_value_range (value_range_t *vr, enum value_range_type t, tree min,
|
set_value_range (value_range_t *vr, enum value_range_type t, tree min,
|
tree max, bitmap equiv)
|
tree max, bitmap equiv)
|
{
|
{
|
#if defined ENABLE_CHECKING
|
#if defined ENABLE_CHECKING
|
/* Check the validity of the range. */
|
/* Check the validity of the range. */
|
if (t == VR_RANGE || t == VR_ANTI_RANGE)
|
if (t == VR_RANGE || t == VR_ANTI_RANGE)
|
{
|
{
|
int cmp;
|
int cmp;
|
|
|
gcc_assert (min && max);
|
gcc_assert (min && max);
|
|
|
if (INTEGRAL_TYPE_P (TREE_TYPE (min)) && t == VR_ANTI_RANGE)
|
if (INTEGRAL_TYPE_P (TREE_TYPE (min)) && t == VR_ANTI_RANGE)
|
gcc_assert (!vrp_val_is_min (min) || !vrp_val_is_max (max));
|
gcc_assert (!vrp_val_is_min (min) || !vrp_val_is_max (max));
|
|
|
cmp = compare_values (min, max);
|
cmp = compare_values (min, max);
|
gcc_assert (cmp == 0 || cmp == -1 || cmp == -2);
|
gcc_assert (cmp == 0 || cmp == -1 || cmp == -2);
|
|
|
if (needs_overflow_infinity (TREE_TYPE (min)))
|
if (needs_overflow_infinity (TREE_TYPE (min)))
|
gcc_assert (!is_overflow_infinity (min)
|
gcc_assert (!is_overflow_infinity (min)
|
|| !is_overflow_infinity (max));
|
|| !is_overflow_infinity (max));
|
}
|
}
|
|
|
if (t == VR_UNDEFINED || t == VR_VARYING)
|
if (t == VR_UNDEFINED || t == VR_VARYING)
|
gcc_assert (min == NULL_TREE && max == NULL_TREE);
|
gcc_assert (min == NULL_TREE && max == NULL_TREE);
|
|
|
if (t == VR_UNDEFINED || t == VR_VARYING)
|
if (t == VR_UNDEFINED || t == VR_VARYING)
|
gcc_assert (equiv == NULL || bitmap_empty_p (equiv));
|
gcc_assert (equiv == NULL || bitmap_empty_p (equiv));
|
#endif
|
#endif
|
|
|
vr->type = t;
|
vr->type = t;
|
vr->min = min;
|
vr->min = min;
|
vr->max = max;
|
vr->max = max;
|
|
|
/* Since updating the equivalence set involves deep copying the
|
/* Since updating the equivalence set involves deep copying the
|
bitmaps, only do it if absolutely necessary. */
|
bitmaps, only do it if absolutely necessary. */
|
if (vr->equiv == NULL)
|
if (vr->equiv == NULL)
|
vr->equiv = BITMAP_ALLOC (NULL);
|
vr->equiv = BITMAP_ALLOC (NULL);
|
|
|
if (equiv != vr->equiv)
|
if (equiv != vr->equiv)
|
{
|
{
|
if (equiv && !bitmap_empty_p (equiv))
|
if (equiv && !bitmap_empty_p (equiv))
|
bitmap_copy (vr->equiv, equiv);
|
bitmap_copy (vr->equiv, equiv);
|
else
|
else
|
bitmap_clear (vr->equiv);
|
bitmap_clear (vr->equiv);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Copy value range FROM into value range TO. */
|
/* Copy value range FROM into value range TO. */
|
|
|
static inline void
|
static inline void
|
copy_value_range (value_range_t *to, value_range_t *from)
|
copy_value_range (value_range_t *to, value_range_t *from)
|
{
|
{
|
set_value_range (to, from->type, from->min, from->max, from->equiv);
|
set_value_range (to, from->type, from->min, from->max, from->equiv);
|
}
|
}
|
|
|
|
|
/* Set value range VR to VR_VARYING. */
|
/* Set value range VR to VR_VARYING. */
|
|
|
static inline void
|
static inline void
|
set_value_range_to_varying (value_range_t *vr)
|
set_value_range_to_varying (value_range_t *vr)
|
{
|
{
|
vr->type = VR_VARYING;
|
vr->type = VR_VARYING;
|
vr->min = vr->max = NULL_TREE;
|
vr->min = vr->max = NULL_TREE;
|
if (vr->equiv)
|
if (vr->equiv)
|
bitmap_clear (vr->equiv);
|
bitmap_clear (vr->equiv);
|
}
|
}
|
|
|
/* Set value range VR to a single value. This function is only called
|
/* Set value range VR to a single value. This function is only called
|
with values we get from statements, and exists to clear the
|
with values we get from statements, and exists to clear the
|
TREE_OVERFLOW flag so that we don't think we have an overflow
|
TREE_OVERFLOW flag so that we don't think we have an overflow
|
infinity when we shouldn't. */
|
infinity when we shouldn't. */
|
|
|
static inline void
|
static inline void
|
set_value_range_to_value (value_range_t *vr, tree val, bitmap equiv)
|
set_value_range_to_value (value_range_t *vr, tree val, bitmap equiv)
|
{
|
{
|
gcc_assert (is_gimple_min_invariant (val));
|
gcc_assert (is_gimple_min_invariant (val));
|
val = avoid_overflow_infinity (val);
|
val = avoid_overflow_infinity (val);
|
set_value_range (vr, VR_RANGE, val, val, equiv);
|
set_value_range (vr, VR_RANGE, val, val, equiv);
|
}
|
}
|
|
|
/* Set value range VR to a non-negative range of type TYPE.
|
/* Set value range VR to a non-negative range of type TYPE.
|
OVERFLOW_INFINITY indicates whether to use a overflow infinity
|
OVERFLOW_INFINITY indicates whether to use a overflow infinity
|
rather than TYPE_MAX_VALUE; this should be true if we determine
|
rather than TYPE_MAX_VALUE; this should be true if we determine
|
that the range is nonnegative based on the assumption that signed
|
that the range is nonnegative based on the assumption that signed
|
overflow does not occur. */
|
overflow does not occur. */
|
|
|
static inline void
|
static inline void
|
set_value_range_to_nonnegative (value_range_t *vr, tree type,
|
set_value_range_to_nonnegative (value_range_t *vr, tree type,
|
bool overflow_infinity)
|
bool overflow_infinity)
|
{
|
{
|
tree zero;
|
tree zero;
|
|
|
if (overflow_infinity && !supports_overflow_infinity (type))
|
if (overflow_infinity && !supports_overflow_infinity (type))
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
zero = build_int_cst (type, 0);
|
zero = build_int_cst (type, 0);
|
set_value_range (vr, VR_RANGE, zero,
|
set_value_range (vr, VR_RANGE, zero,
|
(overflow_infinity
|
(overflow_infinity
|
? positive_overflow_infinity (type)
|
? positive_overflow_infinity (type)
|
: TYPE_MAX_VALUE (type)),
|
: TYPE_MAX_VALUE (type)),
|
vr->equiv);
|
vr->equiv);
|
}
|
}
|
|
|
/* Set value range VR to a non-NULL range of type TYPE. */
|
/* Set value range VR to a non-NULL range of type TYPE. */
|
|
|
static inline void
|
static inline void
|
set_value_range_to_nonnull (value_range_t *vr, tree type)
|
set_value_range_to_nonnull (value_range_t *vr, tree type)
|
{
|
{
|
tree zero = build_int_cst (type, 0);
|
tree zero = build_int_cst (type, 0);
|
set_value_range (vr, VR_ANTI_RANGE, zero, zero, vr->equiv);
|
set_value_range (vr, VR_ANTI_RANGE, zero, zero, vr->equiv);
|
}
|
}
|
|
|
|
|
/* Set value range VR to a NULL range of type TYPE. */
|
/* Set value range VR to a NULL range of type TYPE. */
|
|
|
static inline void
|
static inline void
|
set_value_range_to_null (value_range_t *vr, tree type)
|
set_value_range_to_null (value_range_t *vr, tree type)
|
{
|
{
|
set_value_range_to_value (vr, build_int_cst (type, 0), vr->equiv);
|
set_value_range_to_value (vr, build_int_cst (type, 0), vr->equiv);
|
}
|
}
|
|
|
|
|
/* Set value range VR to VR_UNDEFINED. */
|
/* Set value range VR to VR_UNDEFINED. */
|
|
|
static inline void
|
static inline void
|
set_value_range_to_undefined (value_range_t *vr)
|
set_value_range_to_undefined (value_range_t *vr)
|
{
|
{
|
vr->type = VR_UNDEFINED;
|
vr->type = VR_UNDEFINED;
|
vr->min = vr->max = NULL_TREE;
|
vr->min = vr->max = NULL_TREE;
|
if (vr->equiv)
|
if (vr->equiv)
|
bitmap_clear (vr->equiv);
|
bitmap_clear (vr->equiv);
|
}
|
}
|
|
|
|
|
/* Return value range information for VAR.
|
/* Return value range information for VAR.
|
|
|
If we have no values ranges recorded (ie, VRP is not running), then
|
If we have no values ranges recorded (ie, VRP is not running), then
|
return NULL. Otherwise create an empty range if none existed for VAR. */
|
return NULL. Otherwise create an empty range if none existed for VAR. */
|
|
|
static value_range_t *
|
static value_range_t *
|
get_value_range (tree var)
|
get_value_range (tree var)
|
{
|
{
|
value_range_t *vr;
|
value_range_t *vr;
|
tree sym;
|
tree sym;
|
unsigned ver = SSA_NAME_VERSION (var);
|
unsigned ver = SSA_NAME_VERSION (var);
|
|
|
/* If we have no recorded ranges, then return NULL. */
|
/* If we have no recorded ranges, then return NULL. */
|
if (! vr_value)
|
if (! vr_value)
|
return NULL;
|
return NULL;
|
|
|
vr = vr_value[ver];
|
vr = vr_value[ver];
|
if (vr)
|
if (vr)
|
return vr;
|
return vr;
|
|
|
/* Create a default value range. */
|
/* Create a default value range. */
|
vr_value[ver] = vr = XNEW (value_range_t);
|
vr_value[ver] = vr = XNEW (value_range_t);
|
memset (vr, 0, sizeof (*vr));
|
memset (vr, 0, sizeof (*vr));
|
|
|
/* Allocate an equivalence set. */
|
/* Allocate an equivalence set. */
|
vr->equiv = BITMAP_ALLOC (NULL);
|
vr->equiv = BITMAP_ALLOC (NULL);
|
|
|
/* If VAR is a default definition, the variable can take any value
|
/* If VAR is a default definition, the variable can take any value
|
in VAR's type. */
|
in VAR's type. */
|
sym = SSA_NAME_VAR (var);
|
sym = SSA_NAME_VAR (var);
|
if (var == default_def (sym))
|
if (var == default_def (sym))
|
{
|
{
|
/* Try to use the "nonnull" attribute to create ~[0, 0]
|
/* Try to use the "nonnull" attribute to create ~[0, 0]
|
anti-ranges for pointers. Note that this is only valid with
|
anti-ranges for pointers. Note that this is only valid with
|
default definitions of PARM_DECLs. */
|
default definitions of PARM_DECLs. */
|
if (TREE_CODE (sym) == PARM_DECL
|
if (TREE_CODE (sym) == PARM_DECL
|
&& POINTER_TYPE_P (TREE_TYPE (sym))
|
&& POINTER_TYPE_P (TREE_TYPE (sym))
|
&& nonnull_arg_p (sym))
|
&& nonnull_arg_p (sym))
|
set_value_range_to_nonnull (vr, TREE_TYPE (sym));
|
set_value_range_to_nonnull (vr, TREE_TYPE (sym));
|
else
|
else
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
}
|
}
|
|
|
return vr;
|
return vr;
|
}
|
}
|
|
|
/* Return true, if VAL1 and VAL2 are equal values for VRP purposes. */
|
/* Return true, if VAL1 and VAL2 are equal values for VRP purposes. */
|
|
|
static inline bool
|
static inline bool
|
vrp_operand_equal_p (tree val1, tree val2)
|
vrp_operand_equal_p (tree val1, tree val2)
|
{
|
{
|
if (val1 == val2)
|
if (val1 == val2)
|
return true;
|
return true;
|
if (!val1 || !val2 || !operand_equal_p (val1, val2, 0))
|
if (!val1 || !val2 || !operand_equal_p (val1, val2, 0))
|
return false;
|
return false;
|
if (is_overflow_infinity (val1))
|
if (is_overflow_infinity (val1))
|
return is_overflow_infinity (val2);
|
return is_overflow_infinity (val2);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Return true, if the bitmaps B1 and B2 are equal. */
|
/* Return true, if the bitmaps B1 and B2 are equal. */
|
|
|
static inline bool
|
static inline bool
|
vrp_bitmap_equal_p (bitmap b1, bitmap b2)
|
vrp_bitmap_equal_p (bitmap b1, bitmap b2)
|
{
|
{
|
return (b1 == b2
|
return (b1 == b2
|
|| (b1 && b2
|
|| (b1 && b2
|
&& bitmap_equal_p (b1, b2)));
|
&& bitmap_equal_p (b1, b2)));
|
}
|
}
|
|
|
/* Update the value range and equivalence set for variable VAR to
|
/* Update the value range and equivalence set for variable VAR to
|
NEW_VR. Return true if NEW_VR is different from VAR's previous
|
NEW_VR. Return true if NEW_VR is different from VAR's previous
|
value.
|
value.
|
|
|
NOTE: This function assumes that NEW_VR is a temporary value range
|
NOTE: This function assumes that NEW_VR is a temporary value range
|
object created for the sole purpose of updating VAR's range. The
|
object created for the sole purpose of updating VAR's range. The
|
storage used by the equivalence set from NEW_VR will be freed by
|
storage used by the equivalence set from NEW_VR will be freed by
|
this function. Do not call update_value_range when NEW_VR
|
this function. Do not call update_value_range when NEW_VR
|
is the range object associated with another SSA name. */
|
is the range object associated with another SSA name. */
|
|
|
static inline bool
|
static inline bool
|
update_value_range (tree var, value_range_t *new_vr)
|
update_value_range (tree var, value_range_t *new_vr)
|
{
|
{
|
value_range_t *old_vr;
|
value_range_t *old_vr;
|
bool is_new;
|
bool is_new;
|
|
|
/* Update the value range, if necessary. */
|
/* Update the value range, if necessary. */
|
old_vr = get_value_range (var);
|
old_vr = get_value_range (var);
|
is_new = old_vr->type != new_vr->type
|
is_new = old_vr->type != new_vr->type
|
|| !vrp_operand_equal_p (old_vr->min, new_vr->min)
|
|| !vrp_operand_equal_p (old_vr->min, new_vr->min)
|
|| !vrp_operand_equal_p (old_vr->max, new_vr->max)
|
|| !vrp_operand_equal_p (old_vr->max, new_vr->max)
|
|| !vrp_bitmap_equal_p (old_vr->equiv, new_vr->equiv);
|
|| !vrp_bitmap_equal_p (old_vr->equiv, new_vr->equiv);
|
|
|
if (is_new)
|
if (is_new)
|
set_value_range (old_vr, new_vr->type, new_vr->min, new_vr->max,
|
set_value_range (old_vr, new_vr->type, new_vr->min, new_vr->max,
|
new_vr->equiv);
|
new_vr->equiv);
|
|
|
BITMAP_FREE (new_vr->equiv);
|
BITMAP_FREE (new_vr->equiv);
|
new_vr->equiv = NULL;
|
new_vr->equiv = NULL;
|
|
|
return is_new;
|
return is_new;
|
}
|
}
|
|
|
|
|
/* Add VAR and VAR's equivalence set to EQUIV. */
|
/* Add VAR and VAR's equivalence set to EQUIV. */
|
|
|
static void
|
static void
|
add_equivalence (bitmap equiv, tree var)
|
add_equivalence (bitmap equiv, tree var)
|
{
|
{
|
unsigned ver = SSA_NAME_VERSION (var);
|
unsigned ver = SSA_NAME_VERSION (var);
|
value_range_t *vr = vr_value[ver];
|
value_range_t *vr = vr_value[ver];
|
|
|
bitmap_set_bit (equiv, ver);
|
bitmap_set_bit (equiv, ver);
|
if (vr && vr->equiv)
|
if (vr && vr->equiv)
|
bitmap_ior_into (equiv, vr->equiv);
|
bitmap_ior_into (equiv, vr->equiv);
|
}
|
}
|
|
|
|
|
/* Return true if VR is ~[0, 0]. */
|
/* Return true if VR is ~[0, 0]. */
|
|
|
static inline bool
|
static inline bool
|
range_is_nonnull (value_range_t *vr)
|
range_is_nonnull (value_range_t *vr)
|
{
|
{
|
return vr->type == VR_ANTI_RANGE
|
return vr->type == VR_ANTI_RANGE
|
&& integer_zerop (vr->min)
|
&& integer_zerop (vr->min)
|
&& integer_zerop (vr->max);
|
&& integer_zerop (vr->max);
|
}
|
}
|
|
|
|
|
/* Return true if VR is [0, 0]. */
|
/* Return true if VR is [0, 0]. */
|
|
|
static inline bool
|
static inline bool
|
range_is_null (value_range_t *vr)
|
range_is_null (value_range_t *vr)
|
{
|
{
|
return vr->type == VR_RANGE
|
return vr->type == VR_RANGE
|
&& integer_zerop (vr->min)
|
&& integer_zerop (vr->min)
|
&& integer_zerop (vr->max);
|
&& integer_zerop (vr->max);
|
}
|
}
|
|
|
|
|
/* Return true if value range VR involves at least one symbol. */
|
/* Return true if value range VR involves at least one symbol. */
|
|
|
static inline bool
|
static inline bool
|
symbolic_range_p (value_range_t *vr)
|
symbolic_range_p (value_range_t *vr)
|
{
|
{
|
return (!is_gimple_min_invariant (vr->min)
|
return (!is_gimple_min_invariant (vr->min)
|
|| !is_gimple_min_invariant (vr->max));
|
|| !is_gimple_min_invariant (vr->max));
|
}
|
}
|
|
|
/* Return true if value range VR uses a overflow infinity. */
|
/* Return true if value range VR uses a overflow infinity. */
|
|
|
static inline bool
|
static inline bool
|
overflow_infinity_range_p (value_range_t *vr)
|
overflow_infinity_range_p (value_range_t *vr)
|
{
|
{
|
return (vr->type == VR_RANGE
|
return (vr->type == VR_RANGE
|
&& (is_overflow_infinity (vr->min)
|
&& (is_overflow_infinity (vr->min)
|
|| is_overflow_infinity (vr->max)));
|
|| is_overflow_infinity (vr->max)));
|
}
|
}
|
|
|
/* Return false if we can not make a valid comparison based on VR;
|
/* Return false if we can not make a valid comparison based on VR;
|
this will be the case if it uses an overflow infinity and overflow
|
this will be the case if it uses an overflow infinity and overflow
|
is not undefined (i.e., -fno-strict-overflow is in effect).
|
is not undefined (i.e., -fno-strict-overflow is in effect).
|
Otherwise return true, and set *STRICT_OVERFLOW_P to true if VR
|
Otherwise return true, and set *STRICT_OVERFLOW_P to true if VR
|
uses an overflow infinity. */
|
uses an overflow infinity. */
|
|
|
static bool
|
static bool
|
usable_range_p (value_range_t *vr, bool *strict_overflow_p)
|
usable_range_p (value_range_t *vr, bool *strict_overflow_p)
|
{
|
{
|
gcc_assert (vr->type == VR_RANGE);
|
gcc_assert (vr->type == VR_RANGE);
|
if (is_overflow_infinity (vr->min))
|
if (is_overflow_infinity (vr->min))
|
{
|
{
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (vr->min)))
|
if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (vr->min)))
|
return false;
|
return false;
|
}
|
}
|
if (is_overflow_infinity (vr->max))
|
if (is_overflow_infinity (vr->max))
|
{
|
{
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (vr->max)))
|
if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (vr->max)))
|
return false;
|
return false;
|
}
|
}
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* Like tree_expr_nonnegative_warnv_p, but this function uses value
|
/* Like tree_expr_nonnegative_warnv_p, but this function uses value
|
ranges obtained so far. */
|
ranges obtained so far. */
|
|
|
static bool
|
static bool
|
vrp_expr_computes_nonnegative (tree expr, bool *strict_overflow_p)
|
vrp_expr_computes_nonnegative (tree expr, bool *strict_overflow_p)
|
{
|
{
|
return tree_expr_nonnegative_warnv_p (expr, strict_overflow_p);
|
return tree_expr_nonnegative_warnv_p (expr, strict_overflow_p);
|
}
|
}
|
|
|
/* Like tree_expr_nonzero_warnv_p, but this function uses value ranges
|
/* Like tree_expr_nonzero_warnv_p, but this function uses value ranges
|
obtained so far. */
|
obtained so far. */
|
|
|
static bool
|
static bool
|
vrp_expr_computes_nonzero (tree expr, bool *strict_overflow_p)
|
vrp_expr_computes_nonzero (tree expr, bool *strict_overflow_p)
|
{
|
{
|
if (tree_expr_nonzero_warnv_p (expr, strict_overflow_p))
|
if (tree_expr_nonzero_warnv_p (expr, strict_overflow_p))
|
return true;
|
return true;
|
|
|
/* If we have an expression of the form &X->a, then the expression
|
/* If we have an expression of the form &X->a, then the expression
|
is nonnull if X is nonnull. */
|
is nonnull if X is nonnull. */
|
if (TREE_CODE (expr) == ADDR_EXPR)
|
if (TREE_CODE (expr) == ADDR_EXPR)
|
{
|
{
|
tree base = get_base_address (TREE_OPERAND (expr, 0));
|
tree base = get_base_address (TREE_OPERAND (expr, 0));
|
|
|
if (base != NULL_TREE
|
if (base != NULL_TREE
|
&& TREE_CODE (base) == INDIRECT_REF
|
&& TREE_CODE (base) == INDIRECT_REF
|
&& TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
|
&& TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
|
{
|
{
|
value_range_t *vr = get_value_range (TREE_OPERAND (base, 0));
|
value_range_t *vr = get_value_range (TREE_OPERAND (base, 0));
|
if (range_is_nonnull (vr))
|
if (range_is_nonnull (vr))
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Returns true if EXPR is a valid value (as expected by compare_values) --
|
/* Returns true if EXPR is a valid value (as expected by compare_values) --
|
a gimple invariant, or SSA_NAME +- CST. */
|
a gimple invariant, or SSA_NAME +- CST. */
|
|
|
static bool
|
static bool
|
valid_value_p (tree expr)
|
valid_value_p (tree expr)
|
{
|
{
|
if (TREE_CODE (expr) == SSA_NAME)
|
if (TREE_CODE (expr) == SSA_NAME)
|
return true;
|
return true;
|
|
|
if (TREE_CODE (expr) == PLUS_EXPR
|
if (TREE_CODE (expr) == PLUS_EXPR
|
|| TREE_CODE (expr) == MINUS_EXPR)
|
|| TREE_CODE (expr) == MINUS_EXPR)
|
return (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
|
return (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
|
&& TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST);
|
&& TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST);
|
|
|
return is_gimple_min_invariant (expr);
|
return is_gimple_min_invariant (expr);
|
}
|
}
|
|
|
/* Compare two values VAL1 and VAL2. Return
|
/* Compare two values VAL1 and VAL2. Return
|
|
|
-2 if VAL1 and VAL2 cannot be compared at compile-time,
|
-2 if VAL1 and VAL2 cannot be compared at compile-time,
|
-1 if VAL1 < VAL2,
|
-1 if VAL1 < VAL2,
|
0 if VAL1 == VAL2,
|
0 if VAL1 == VAL2,
|
+1 if VAL1 > VAL2, and
|
+1 if VAL1 > VAL2, and
|
+2 if VAL1 != VAL2
|
+2 if VAL1 != VAL2
|
|
|
This is similar to tree_int_cst_compare but supports pointer values
|
This is similar to tree_int_cst_compare but supports pointer values
|
and values that cannot be compared at compile time.
|
and values that cannot be compared at compile time.
|
|
|
If STRICT_OVERFLOW_P is not NULL, then set *STRICT_OVERFLOW_P to
|
If STRICT_OVERFLOW_P is not NULL, then set *STRICT_OVERFLOW_P to
|
true if the return value is only valid if we assume that signed
|
true if the return value is only valid if we assume that signed
|
overflow is undefined. */
|
overflow is undefined. */
|
|
|
static int
|
static int
|
compare_values_warnv (tree val1, tree val2, bool *strict_overflow_p)
|
compare_values_warnv (tree val1, tree val2, bool *strict_overflow_p)
|
{
|
{
|
if (val1 == val2)
|
if (val1 == val2)
|
return 0;
|
return 0;
|
|
|
/* Below we rely on the fact that VAL1 and VAL2 are both pointers or
|
/* Below we rely on the fact that VAL1 and VAL2 are both pointers or
|
both integers. */
|
both integers. */
|
gcc_assert (POINTER_TYPE_P (TREE_TYPE (val1))
|
gcc_assert (POINTER_TYPE_P (TREE_TYPE (val1))
|
== POINTER_TYPE_P (TREE_TYPE (val2)));
|
== POINTER_TYPE_P (TREE_TYPE (val2)));
|
|
|
if ((TREE_CODE (val1) == SSA_NAME
|
if ((TREE_CODE (val1) == SSA_NAME
|
|| TREE_CODE (val1) == PLUS_EXPR
|
|| TREE_CODE (val1) == PLUS_EXPR
|
|| TREE_CODE (val1) == MINUS_EXPR)
|
|| TREE_CODE (val1) == MINUS_EXPR)
|
&& (TREE_CODE (val2) == SSA_NAME
|
&& (TREE_CODE (val2) == SSA_NAME
|
|| TREE_CODE (val2) == PLUS_EXPR
|
|| TREE_CODE (val2) == PLUS_EXPR
|
|| TREE_CODE (val2) == MINUS_EXPR))
|
|| TREE_CODE (val2) == MINUS_EXPR))
|
{
|
{
|
tree n1, c1, n2, c2;
|
tree n1, c1, n2, c2;
|
enum tree_code code1, code2;
|
enum tree_code code1, code2;
|
|
|
/* If VAL1 and VAL2 are of the form 'NAME [+-] CST' or 'NAME',
|
/* If VAL1 and VAL2 are of the form 'NAME [+-] CST' or 'NAME',
|
return -1 or +1 accordingly. If VAL1 and VAL2 don't use the
|
return -1 or +1 accordingly. If VAL1 and VAL2 don't use the
|
same name, return -2. */
|
same name, return -2. */
|
if (TREE_CODE (val1) == SSA_NAME)
|
if (TREE_CODE (val1) == SSA_NAME)
|
{
|
{
|
code1 = SSA_NAME;
|
code1 = SSA_NAME;
|
n1 = val1;
|
n1 = val1;
|
c1 = NULL_TREE;
|
c1 = NULL_TREE;
|
}
|
}
|
else
|
else
|
{
|
{
|
code1 = TREE_CODE (val1);
|
code1 = TREE_CODE (val1);
|
n1 = TREE_OPERAND (val1, 0);
|
n1 = TREE_OPERAND (val1, 0);
|
c1 = TREE_OPERAND (val1, 1);
|
c1 = TREE_OPERAND (val1, 1);
|
if (tree_int_cst_sgn (c1) == -1)
|
if (tree_int_cst_sgn (c1) == -1)
|
{
|
{
|
if (is_negative_overflow_infinity (c1))
|
if (is_negative_overflow_infinity (c1))
|
return -2;
|
return -2;
|
c1 = fold_unary_to_constant (NEGATE_EXPR, TREE_TYPE (c1), c1);
|
c1 = fold_unary_to_constant (NEGATE_EXPR, TREE_TYPE (c1), c1);
|
if (!c1)
|
if (!c1)
|
return -2;
|
return -2;
|
code1 = code1 == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR;
|
code1 = code1 == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR;
|
}
|
}
|
}
|
}
|
|
|
if (TREE_CODE (val2) == SSA_NAME)
|
if (TREE_CODE (val2) == SSA_NAME)
|
{
|
{
|
code2 = SSA_NAME;
|
code2 = SSA_NAME;
|
n2 = val2;
|
n2 = val2;
|
c2 = NULL_TREE;
|
c2 = NULL_TREE;
|
}
|
}
|
else
|
else
|
{
|
{
|
code2 = TREE_CODE (val2);
|
code2 = TREE_CODE (val2);
|
n2 = TREE_OPERAND (val2, 0);
|
n2 = TREE_OPERAND (val2, 0);
|
c2 = TREE_OPERAND (val2, 1);
|
c2 = TREE_OPERAND (val2, 1);
|
if (tree_int_cst_sgn (c2) == -1)
|
if (tree_int_cst_sgn (c2) == -1)
|
{
|
{
|
if (is_negative_overflow_infinity (c2))
|
if (is_negative_overflow_infinity (c2))
|
return -2;
|
return -2;
|
c2 = fold_unary_to_constant (NEGATE_EXPR, TREE_TYPE (c2), c2);
|
c2 = fold_unary_to_constant (NEGATE_EXPR, TREE_TYPE (c2), c2);
|
if (!c2)
|
if (!c2)
|
return -2;
|
return -2;
|
code2 = code2 == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR;
|
code2 = code2 == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR;
|
}
|
}
|
}
|
}
|
|
|
/* Both values must use the same name. */
|
/* Both values must use the same name. */
|
if (n1 != n2)
|
if (n1 != n2)
|
return -2;
|
return -2;
|
|
|
if (code1 == SSA_NAME
|
if (code1 == SSA_NAME
|
&& code2 == SSA_NAME)
|
&& code2 == SSA_NAME)
|
/* NAME == NAME */
|
/* NAME == NAME */
|
return 0;
|
return 0;
|
|
|
/* If overflow is defined we cannot simplify more. */
|
/* If overflow is defined we cannot simplify more. */
|
if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (val1)))
|
if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (val1)))
|
return -2;
|
return -2;
|
|
|
if (strict_overflow_p != NULL
|
if (strict_overflow_p != NULL
|
&& (code1 == SSA_NAME || !TREE_NO_WARNING (val1))
|
&& (code1 == SSA_NAME || !TREE_NO_WARNING (val1))
|
&& (code2 == SSA_NAME || !TREE_NO_WARNING (val2)))
|
&& (code2 == SSA_NAME || !TREE_NO_WARNING (val2)))
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
|
|
if (code1 == SSA_NAME)
|
if (code1 == SSA_NAME)
|
{
|
{
|
if (code2 == PLUS_EXPR)
|
if (code2 == PLUS_EXPR)
|
/* NAME < NAME + CST */
|
/* NAME < NAME + CST */
|
return -1;
|
return -1;
|
else if (code2 == MINUS_EXPR)
|
else if (code2 == MINUS_EXPR)
|
/* NAME > NAME - CST */
|
/* NAME > NAME - CST */
|
return 1;
|
return 1;
|
}
|
}
|
else if (code1 == PLUS_EXPR)
|
else if (code1 == PLUS_EXPR)
|
{
|
{
|
if (code2 == SSA_NAME)
|
if (code2 == SSA_NAME)
|
/* NAME + CST > NAME */
|
/* NAME + CST > NAME */
|
return 1;
|
return 1;
|
else if (code2 == PLUS_EXPR)
|
else if (code2 == PLUS_EXPR)
|
/* NAME + CST1 > NAME + CST2, if CST1 > CST2 */
|
/* NAME + CST1 > NAME + CST2, if CST1 > CST2 */
|
return compare_values_warnv (c1, c2, strict_overflow_p);
|
return compare_values_warnv (c1, c2, strict_overflow_p);
|
else if (code2 == MINUS_EXPR)
|
else if (code2 == MINUS_EXPR)
|
/* NAME + CST1 > NAME - CST2 */
|
/* NAME + CST1 > NAME - CST2 */
|
return 1;
|
return 1;
|
}
|
}
|
else if (code1 == MINUS_EXPR)
|
else if (code1 == MINUS_EXPR)
|
{
|
{
|
if (code2 == SSA_NAME)
|
if (code2 == SSA_NAME)
|
/* NAME - CST < NAME */
|
/* NAME - CST < NAME */
|
return -1;
|
return -1;
|
else if (code2 == PLUS_EXPR)
|
else if (code2 == PLUS_EXPR)
|
/* NAME - CST1 < NAME + CST2 */
|
/* NAME - CST1 < NAME + CST2 */
|
return -1;
|
return -1;
|
else if (code2 == MINUS_EXPR)
|
else if (code2 == MINUS_EXPR)
|
/* NAME - CST1 > NAME - CST2, if CST1 < CST2. Notice that
|
/* NAME - CST1 > NAME - CST2, if CST1 < CST2. Notice that
|
C1 and C2 are swapped in the call to compare_values. */
|
C1 and C2 are swapped in the call to compare_values. */
|
return compare_values_warnv (c2, c1, strict_overflow_p);
|
return compare_values_warnv (c2, c1, strict_overflow_p);
|
}
|
}
|
|
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* We cannot compare non-constants. */
|
/* We cannot compare non-constants. */
|
if (!is_gimple_min_invariant (val1) || !is_gimple_min_invariant (val2))
|
if (!is_gimple_min_invariant (val1) || !is_gimple_min_invariant (val2))
|
return -2;
|
return -2;
|
|
|
if (!POINTER_TYPE_P (TREE_TYPE (val1)))
|
if (!POINTER_TYPE_P (TREE_TYPE (val1)))
|
{
|
{
|
/* We cannot compare overflowed values, except for overflow
|
/* We cannot compare overflowed values, except for overflow
|
infinities. */
|
infinities. */
|
if (TREE_OVERFLOW (val1) || TREE_OVERFLOW (val2))
|
if (TREE_OVERFLOW (val1) || TREE_OVERFLOW (val2))
|
{
|
{
|
if (strict_overflow_p != NULL)
|
if (strict_overflow_p != NULL)
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
if (is_negative_overflow_infinity (val1))
|
if (is_negative_overflow_infinity (val1))
|
return is_negative_overflow_infinity (val2) ? 0 : -1;
|
return is_negative_overflow_infinity (val2) ? 0 : -1;
|
else if (is_negative_overflow_infinity (val2))
|
else if (is_negative_overflow_infinity (val2))
|
return 1;
|
return 1;
|
else if (is_positive_overflow_infinity (val1))
|
else if (is_positive_overflow_infinity (val1))
|
return is_positive_overflow_infinity (val2) ? 0 : 1;
|
return is_positive_overflow_infinity (val2) ? 0 : 1;
|
else if (is_positive_overflow_infinity (val2))
|
else if (is_positive_overflow_infinity (val2))
|
return -1;
|
return -1;
|
return -2;
|
return -2;
|
}
|
}
|
|
|
return tree_int_cst_compare (val1, val2);
|
return tree_int_cst_compare (val1, val2);
|
}
|
}
|
else
|
else
|
{
|
{
|
tree t;
|
tree t;
|
|
|
/* First see if VAL1 and VAL2 are not the same. */
|
/* First see if VAL1 and VAL2 are not the same. */
|
if (val1 == val2 || operand_equal_p (val1, val2, 0))
|
if (val1 == val2 || operand_equal_p (val1, val2, 0))
|
return 0;
|
return 0;
|
|
|
/* If VAL1 is a lower address than VAL2, return -1. */
|
/* If VAL1 is a lower address than VAL2, return -1. */
|
t = fold_binary (LT_EXPR, boolean_type_node, val1, val2);
|
t = fold_binary (LT_EXPR, boolean_type_node, val1, val2);
|
if (t == boolean_true_node)
|
if (t == boolean_true_node)
|
return -1;
|
return -1;
|
|
|
/* If VAL1 is a higher address than VAL2, return +1. */
|
/* If VAL1 is a higher address than VAL2, return +1. */
|
t = fold_binary (GT_EXPR, boolean_type_node, val1, val2);
|
t = fold_binary (GT_EXPR, boolean_type_node, val1, val2);
|
if (t == boolean_true_node)
|
if (t == boolean_true_node)
|
return 1;
|
return 1;
|
|
|
/* If VAL1 is different than VAL2, return +2. */
|
/* If VAL1 is different than VAL2, return +2. */
|
t = fold_binary (NE_EXPR, boolean_type_node, val1, val2);
|
t = fold_binary (NE_EXPR, boolean_type_node, val1, val2);
|
if (t == boolean_true_node)
|
if (t == boolean_true_node)
|
return 2;
|
return 2;
|
|
|
return -2;
|
return -2;
|
}
|
}
|
}
|
}
|
|
|
/* Compare values like compare_values_warnv, but treat comparisons of
|
/* Compare values like compare_values_warnv, but treat comparisons of
|
nonconstants which rely on undefined overflow as incomparable. */
|
nonconstants which rely on undefined overflow as incomparable. */
|
|
|
static int
|
static int
|
compare_values (tree val1, tree val2)
|
compare_values (tree val1, tree val2)
|
{
|
{
|
bool sop;
|
bool sop;
|
int ret;
|
int ret;
|
|
|
sop = false;
|
sop = false;
|
ret = compare_values_warnv (val1, val2, &sop);
|
ret = compare_values_warnv (val1, val2, &sop);
|
if (sop
|
if (sop
|
&& (!is_gimple_min_invariant (val1) || !is_gimple_min_invariant (val2)))
|
&& (!is_gimple_min_invariant (val1) || !is_gimple_min_invariant (val2)))
|
ret = -2;
|
ret = -2;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
|
|
/* Return 1 if VAL is inside value range VR (VR->MIN <= VAL <= VR->MAX),
|
/* Return 1 if VAL is inside value range VR (VR->MIN <= VAL <= VR->MAX),
|
0 if VAL is not inside VR,
|
0 if VAL is not inside VR,
|
-2 if we cannot tell either way.
|
-2 if we cannot tell either way.
|
|
|
FIXME, the current semantics of this functions are a bit quirky
|
FIXME, the current semantics of this functions are a bit quirky
|
when taken in the context of VRP. In here we do not care
|
when taken in the context of VRP. In here we do not care
|
about VR's type. If VR is the anti-range ~[3, 5] the call
|
about VR's type. If VR is the anti-range ~[3, 5] the call
|
value_inside_range (4, VR) will return 1.
|
value_inside_range (4, VR) will return 1.
|
|
|
This is counter-intuitive in a strict sense, but the callers
|
This is counter-intuitive in a strict sense, but the callers
|
currently expect this. They are calling the function
|
currently expect this. They are calling the function
|
merely to determine whether VR->MIN <= VAL <= VR->MAX. The
|
merely to determine whether VR->MIN <= VAL <= VR->MAX. The
|
callers are applying the VR_RANGE/VR_ANTI_RANGE semantics
|
callers are applying the VR_RANGE/VR_ANTI_RANGE semantics
|
themselves.
|
themselves.
|
|
|
This also applies to value_ranges_intersect_p and
|
This also applies to value_ranges_intersect_p and
|
range_includes_zero_p. The semantics of VR_RANGE and
|
range_includes_zero_p. The semantics of VR_RANGE and
|
VR_ANTI_RANGE should be encoded here, but that also means
|
VR_ANTI_RANGE should be encoded here, but that also means
|
adapting the users of these functions to the new semantics. */
|
adapting the users of these functions to the new semantics. */
|
|
|
static inline int
|
static inline int
|
value_inside_range (tree val, value_range_t *vr)
|
value_inside_range (tree val, value_range_t *vr)
|
{
|
{
|
tree cmp1, cmp2;
|
tree cmp1, cmp2;
|
|
|
fold_defer_overflow_warnings ();
|
fold_defer_overflow_warnings ();
|
|
|
cmp1 = fold_binary_to_constant (GE_EXPR, boolean_type_node, val, vr->min);
|
cmp1 = fold_binary_to_constant (GE_EXPR, boolean_type_node, val, vr->min);
|
if (!cmp1)
|
if (!cmp1)
|
{
|
{
|
fold_undefer_and_ignore_overflow_warnings ();
|
fold_undefer_and_ignore_overflow_warnings ();
|
return -2;
|
return -2;
|
}
|
}
|
|
|
cmp2 = fold_binary_to_constant (LE_EXPR, boolean_type_node, val, vr->max);
|
cmp2 = fold_binary_to_constant (LE_EXPR, boolean_type_node, val, vr->max);
|
|
|
fold_undefer_and_ignore_overflow_warnings ();
|
fold_undefer_and_ignore_overflow_warnings ();
|
|
|
if (!cmp2)
|
if (!cmp2)
|
return -2;
|
return -2;
|
|
|
return cmp1 == boolean_true_node && cmp2 == boolean_true_node;
|
return cmp1 == boolean_true_node && cmp2 == boolean_true_node;
|
}
|
}
|
|
|
|
|
/* Return true if value ranges VR0 and VR1 have a non-empty
|
/* Return true if value ranges VR0 and VR1 have a non-empty
|
intersection. */
|
intersection. */
|
|
|
static inline bool
|
static inline bool
|
value_ranges_intersect_p (value_range_t *vr0, value_range_t *vr1)
|
value_ranges_intersect_p (value_range_t *vr0, value_range_t *vr1)
|
{
|
{
|
return (value_inside_range (vr1->min, vr0) == 1
|
return (value_inside_range (vr1->min, vr0) == 1
|
|| value_inside_range (vr1->max, vr0) == 1
|
|| value_inside_range (vr1->max, vr0) == 1
|
|| value_inside_range (vr0->min, vr1) == 1
|
|| value_inside_range (vr0->min, vr1) == 1
|
|| value_inside_range (vr0->max, vr1) == 1);
|
|| value_inside_range (vr0->max, vr1) == 1);
|
}
|
}
|
|
|
|
|
/* Return true if VR includes the value zero, false otherwise. FIXME,
|
/* Return true if VR includes the value zero, false otherwise. FIXME,
|
currently this will return false for an anti-range like ~[-4, 3].
|
currently this will return false for an anti-range like ~[-4, 3].
|
This will be wrong when the semantics of value_inside_range are
|
This will be wrong when the semantics of value_inside_range are
|
modified (currently the users of this function expect these
|
modified (currently the users of this function expect these
|
semantics). */
|
semantics). */
|
|
|
static inline bool
|
static inline bool
|
range_includes_zero_p (value_range_t *vr)
|
range_includes_zero_p (value_range_t *vr)
|
{
|
{
|
tree zero;
|
tree zero;
|
|
|
gcc_assert (vr->type != VR_UNDEFINED
|
gcc_assert (vr->type != VR_UNDEFINED
|
&& vr->type != VR_VARYING
|
&& vr->type != VR_VARYING
|
&& !symbolic_range_p (vr));
|
&& !symbolic_range_p (vr));
|
|
|
zero = build_int_cst (TREE_TYPE (vr->min), 0);
|
zero = build_int_cst (TREE_TYPE (vr->min), 0);
|
return (value_inside_range (zero, vr) == 1);
|
return (value_inside_range (zero, vr) == 1);
|
}
|
}
|
|
|
/* Return true if T, an SSA_NAME, is known to be nonnegative. Return
|
/* Return true if T, an SSA_NAME, is known to be nonnegative. Return
|
false otherwise or if no value range information is available. */
|
false otherwise or if no value range information is available. */
|
|
|
bool
|
bool
|
ssa_name_nonnegative_p (tree t)
|
ssa_name_nonnegative_p (tree t)
|
{
|
{
|
value_range_t *vr = get_value_range (t);
|
value_range_t *vr = get_value_range (t);
|
|
|
if (!vr)
|
if (!vr)
|
return false;
|
return false;
|
|
|
/* Testing for VR_ANTI_RANGE is not useful here as any anti-range
|
/* Testing for VR_ANTI_RANGE is not useful here as any anti-range
|
which would return a useful value should be encoded as a VR_RANGE. */
|
which would return a useful value should be encoded as a VR_RANGE. */
|
if (vr->type == VR_RANGE)
|
if (vr->type == VR_RANGE)
|
{
|
{
|
int result = compare_values (vr->min, integer_zero_node);
|
int result = compare_values (vr->min, integer_zero_node);
|
|
|
return (result == 0 || result == 1);
|
return (result == 0 || result == 1);
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return true if T, an SSA_NAME, is known to be nonzero. Return
|
/* Return true if T, an SSA_NAME, is known to be nonzero. Return
|
false otherwise or if no value range information is available. */
|
false otherwise or if no value range information is available. */
|
|
|
bool
|
bool
|
ssa_name_nonzero_p (tree t)
|
ssa_name_nonzero_p (tree t)
|
{
|
{
|
value_range_t *vr = get_value_range (t);
|
value_range_t *vr = get_value_range (t);
|
|
|
if (!vr)
|
if (!vr)
|
return false;
|
return false;
|
|
|
/* A VR_RANGE which does not include zero is a nonzero value. */
|
/* A VR_RANGE which does not include zero is a nonzero value. */
|
if (vr->type == VR_RANGE && !symbolic_range_p (vr))
|
if (vr->type == VR_RANGE && !symbolic_range_p (vr))
|
return ! range_includes_zero_p (vr);
|
return ! range_includes_zero_p (vr);
|
|
|
/* A VR_ANTI_RANGE which does include zero is a nonzero value. */
|
/* A VR_ANTI_RANGE which does include zero is a nonzero value. */
|
if (vr->type == VR_ANTI_RANGE && !symbolic_range_p (vr))
|
if (vr->type == VR_ANTI_RANGE && !symbolic_range_p (vr))
|
return range_includes_zero_p (vr);
|
return range_includes_zero_p (vr);
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Extract value range information from an ASSERT_EXPR EXPR and store
|
/* Extract value range information from an ASSERT_EXPR EXPR and store
|
it in *VR_P. */
|
it in *VR_P. */
|
|
|
static void
|
static void
|
extract_range_from_assert (value_range_t *vr_p, tree expr)
|
extract_range_from_assert (value_range_t *vr_p, tree expr)
|
{
|
{
|
tree var, cond, limit, min, max, type;
|
tree var, cond, limit, min, max, type;
|
value_range_t *var_vr, *limit_vr;
|
value_range_t *var_vr, *limit_vr;
|
enum tree_code cond_code;
|
enum tree_code cond_code;
|
|
|
var = ASSERT_EXPR_VAR (expr);
|
var = ASSERT_EXPR_VAR (expr);
|
cond = ASSERT_EXPR_COND (expr);
|
cond = ASSERT_EXPR_COND (expr);
|
|
|
gcc_assert (COMPARISON_CLASS_P (cond));
|
gcc_assert (COMPARISON_CLASS_P (cond));
|
|
|
/* Find VAR in the ASSERT_EXPR conditional. */
|
/* Find VAR in the ASSERT_EXPR conditional. */
|
if (var == TREE_OPERAND (cond, 0))
|
if (var == TREE_OPERAND (cond, 0))
|
{
|
{
|
/* If the predicate is of the form VAR COMP LIMIT, then we just
|
/* If the predicate is of the form VAR COMP LIMIT, then we just
|
take LIMIT from the RHS and use the same comparison code. */
|
take LIMIT from the RHS and use the same comparison code. */
|
limit = TREE_OPERAND (cond, 1);
|
limit = TREE_OPERAND (cond, 1);
|
cond_code = TREE_CODE (cond);
|
cond_code = TREE_CODE (cond);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* If the predicate is of the form LIMIT COMP VAR, then we need
|
/* If the predicate is of the form LIMIT COMP VAR, then we need
|
to flip around the comparison code to create the proper range
|
to flip around the comparison code to create the proper range
|
for VAR. */
|
for VAR. */
|
limit = TREE_OPERAND (cond, 0);
|
limit = TREE_OPERAND (cond, 0);
|
cond_code = swap_tree_comparison (TREE_CODE (cond));
|
cond_code = swap_tree_comparison (TREE_CODE (cond));
|
}
|
}
|
|
|
limit = avoid_overflow_infinity (limit);
|
limit = avoid_overflow_infinity (limit);
|
|
|
type = TREE_TYPE (limit);
|
type = TREE_TYPE (limit);
|
gcc_assert (limit != var);
|
gcc_assert (limit != var);
|
|
|
/* For pointer arithmetic, we only keep track of pointer equality
|
/* For pointer arithmetic, we only keep track of pointer equality
|
and inequality. */
|
and inequality. */
|
if (POINTER_TYPE_P (type) && cond_code != NE_EXPR && cond_code != EQ_EXPR)
|
if (POINTER_TYPE_P (type) && cond_code != NE_EXPR && cond_code != EQ_EXPR)
|
{
|
{
|
set_value_range_to_varying (vr_p);
|
set_value_range_to_varying (vr_p);
|
return;
|
return;
|
}
|
}
|
|
|
/* If LIMIT is another SSA name and LIMIT has a range of its own,
|
/* If LIMIT is another SSA name and LIMIT has a range of its own,
|
try to use LIMIT's range to avoid creating symbolic ranges
|
try to use LIMIT's range to avoid creating symbolic ranges
|
unnecessarily. */
|
unnecessarily. */
|
limit_vr = (TREE_CODE (limit) == SSA_NAME) ? get_value_range (limit) : NULL;
|
limit_vr = (TREE_CODE (limit) == SSA_NAME) ? get_value_range (limit) : NULL;
|
|
|
/* LIMIT's range is only interesting if it has any useful information. */
|
/* LIMIT's range is only interesting if it has any useful information. */
|
if (limit_vr
|
if (limit_vr
|
&& (limit_vr->type == VR_UNDEFINED
|
&& (limit_vr->type == VR_UNDEFINED
|
|| limit_vr->type == VR_VARYING
|
|| limit_vr->type == VR_VARYING
|
|| symbolic_range_p (limit_vr)))
|
|| symbolic_range_p (limit_vr)))
|
limit_vr = NULL;
|
limit_vr = NULL;
|
|
|
/* Initially, the new range has the same set of equivalences of
|
/* Initially, the new range has the same set of equivalences of
|
VAR's range. This will be revised before returning the final
|
VAR's range. This will be revised before returning the final
|
value. Since assertions may be chained via mutually exclusive
|
value. Since assertions may be chained via mutually exclusive
|
predicates, we will need to trim the set of equivalences before
|
predicates, we will need to trim the set of equivalences before
|
we are done. */
|
we are done. */
|
gcc_assert (vr_p->equiv == NULL);
|
gcc_assert (vr_p->equiv == NULL);
|
vr_p->equiv = BITMAP_ALLOC (NULL);
|
vr_p->equiv = BITMAP_ALLOC (NULL);
|
add_equivalence (vr_p->equiv, var);
|
add_equivalence (vr_p->equiv, var);
|
|
|
/* Extract a new range based on the asserted comparison for VAR and
|
/* Extract a new range based on the asserted comparison for VAR and
|
LIMIT's value range. Notice that if LIMIT has an anti-range, we
|
LIMIT's value range. Notice that if LIMIT has an anti-range, we
|
will only use it for equality comparisons (EQ_EXPR). For any
|
will only use it for equality comparisons (EQ_EXPR). For any
|
other kind of assertion, we cannot derive a range from LIMIT's
|
other kind of assertion, we cannot derive a range from LIMIT's
|
anti-range that can be used to describe the new range. For
|
anti-range that can be used to describe the new range. For
|
instance, ASSERT_EXPR <x_2, x_2 <= b_4>. If b_4 is ~[2, 10],
|
instance, ASSERT_EXPR <x_2, x_2 <= b_4>. If b_4 is ~[2, 10],
|
then b_4 takes on the ranges [-INF, 1] and [11, +INF]. There is
|
then b_4 takes on the ranges [-INF, 1] and [11, +INF]. There is
|
no single range for x_2 that could describe LE_EXPR, so we might
|
no single range for x_2 that could describe LE_EXPR, so we might
|
as well build the range [b_4, +INF] for it. */
|
as well build the range [b_4, +INF] for it. */
|
if (cond_code == EQ_EXPR)
|
if (cond_code == EQ_EXPR)
|
{
|
{
|
enum value_range_type range_type;
|
enum value_range_type range_type;
|
|
|
if (limit_vr)
|
if (limit_vr)
|
{
|
{
|
range_type = limit_vr->type;
|
range_type = limit_vr->type;
|
min = limit_vr->min;
|
min = limit_vr->min;
|
max = limit_vr->max;
|
max = limit_vr->max;
|
}
|
}
|
else
|
else
|
{
|
{
|
range_type = VR_RANGE;
|
range_type = VR_RANGE;
|
min = limit;
|
min = limit;
|
max = limit;
|
max = limit;
|
}
|
}
|
|
|
set_value_range (vr_p, range_type, min, max, vr_p->equiv);
|
set_value_range (vr_p, range_type, min, max, vr_p->equiv);
|
|
|
/* When asserting the equality VAR == LIMIT and LIMIT is another
|
/* When asserting the equality VAR == LIMIT and LIMIT is another
|
SSA name, the new range will also inherit the equivalence set
|
SSA name, the new range will also inherit the equivalence set
|
from LIMIT. */
|
from LIMIT. */
|
if (TREE_CODE (limit) == SSA_NAME)
|
if (TREE_CODE (limit) == SSA_NAME)
|
add_equivalence (vr_p->equiv, limit);
|
add_equivalence (vr_p->equiv, limit);
|
}
|
}
|
else if (cond_code == NE_EXPR)
|
else if (cond_code == NE_EXPR)
|
{
|
{
|
/* As described above, when LIMIT's range is an anti-range and
|
/* As described above, when LIMIT's range is an anti-range and
|
this assertion is an inequality (NE_EXPR), then we cannot
|
this assertion is an inequality (NE_EXPR), then we cannot
|
derive anything from the anti-range. For instance, if
|
derive anything from the anti-range. For instance, if
|
LIMIT's range was ~[0, 0], the assertion 'VAR != LIMIT' does
|
LIMIT's range was ~[0, 0], the assertion 'VAR != LIMIT' does
|
not imply that VAR's range is [0, 0]. So, in the case of
|
not imply that VAR's range is [0, 0]. So, in the case of
|
anti-ranges, we just assert the inequality using LIMIT and
|
anti-ranges, we just assert the inequality using LIMIT and
|
not its anti-range.
|
not its anti-range.
|
|
|
If LIMIT_VR is a range, we can only use it to build a new
|
If LIMIT_VR is a range, we can only use it to build a new
|
anti-range if LIMIT_VR is a single-valued range. For
|
anti-range if LIMIT_VR is a single-valued range. For
|
instance, if LIMIT_VR is [0, 1], the predicate
|
instance, if LIMIT_VR is [0, 1], the predicate
|
VAR != [0, 1] does not mean that VAR's range is ~[0, 1].
|
VAR != [0, 1] does not mean that VAR's range is ~[0, 1].
|
Rather, it means that for value 0 VAR should be ~[0, 0]
|
Rather, it means that for value 0 VAR should be ~[0, 0]
|
and for value 1, VAR should be ~[1, 1]. We cannot
|
and for value 1, VAR should be ~[1, 1]. We cannot
|
represent these ranges.
|
represent these ranges.
|
|
|
The only situation in which we can build a valid
|
The only situation in which we can build a valid
|
anti-range is when LIMIT_VR is a single-valued range
|
anti-range is when LIMIT_VR is a single-valued range
|
(i.e., LIMIT_VR->MIN == LIMIT_VR->MAX). In that case,
|
(i.e., LIMIT_VR->MIN == LIMIT_VR->MAX). In that case,
|
build the anti-range ~[LIMIT_VR->MIN, LIMIT_VR->MAX]. */
|
build the anti-range ~[LIMIT_VR->MIN, LIMIT_VR->MAX]. */
|
if (limit_vr
|
if (limit_vr
|
&& limit_vr->type == VR_RANGE
|
&& limit_vr->type == VR_RANGE
|
&& compare_values (limit_vr->min, limit_vr->max) == 0)
|
&& compare_values (limit_vr->min, limit_vr->max) == 0)
|
{
|
{
|
min = limit_vr->min;
|
min = limit_vr->min;
|
max = limit_vr->max;
|
max = limit_vr->max;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* In any other case, we cannot use LIMIT's range to build a
|
/* In any other case, we cannot use LIMIT's range to build a
|
valid anti-range. */
|
valid anti-range. */
|
min = max = limit;
|
min = max = limit;
|
}
|
}
|
|
|
/* If MIN and MAX cover the whole range for their type, then
|
/* If MIN and MAX cover the whole range for their type, then
|
just use the original LIMIT. */
|
just use the original LIMIT. */
|
if (INTEGRAL_TYPE_P (type)
|
if (INTEGRAL_TYPE_P (type)
|
&& vrp_val_is_min (min)
|
&& vrp_val_is_min (min)
|
&& vrp_val_is_max (max))
|
&& vrp_val_is_max (max))
|
min = max = limit;
|
min = max = limit;
|
|
|
set_value_range (vr_p, VR_ANTI_RANGE, min, max, vr_p->equiv);
|
set_value_range (vr_p, VR_ANTI_RANGE, min, max, vr_p->equiv);
|
}
|
}
|
else if (cond_code == LE_EXPR || cond_code == LT_EXPR)
|
else if (cond_code == LE_EXPR || cond_code == LT_EXPR)
|
{
|
{
|
min = TYPE_MIN_VALUE (type);
|
min = TYPE_MIN_VALUE (type);
|
|
|
if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE)
|
if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE)
|
max = limit;
|
max = limit;
|
else
|
else
|
{
|
{
|
/* If LIMIT_VR is of the form [N1, N2], we need to build the
|
/* If LIMIT_VR is of the form [N1, N2], we need to build the
|
range [MIN, N2] for LE_EXPR and [MIN, N2 - 1] for
|
range [MIN, N2] for LE_EXPR and [MIN, N2 - 1] for
|
LT_EXPR. */
|
LT_EXPR. */
|
max = limit_vr->max;
|
max = limit_vr->max;
|
}
|
}
|
|
|
/* If the maximum value forces us to be out of bounds, simply punt.
|
/* If the maximum value forces us to be out of bounds, simply punt.
|
It would be pointless to try and do anything more since this
|
It would be pointless to try and do anything more since this
|
all should be optimized away above us. */
|
all should be optimized away above us. */
|
if ((cond_code == LT_EXPR
|
if ((cond_code == LT_EXPR
|
&& compare_values (max, min) == 0)
|
&& compare_values (max, min) == 0)
|
|| is_overflow_infinity (max))
|
|| is_overflow_infinity (max))
|
set_value_range_to_varying (vr_p);
|
set_value_range_to_varying (vr_p);
|
else
|
else
|
{
|
{
|
/* For LT_EXPR, we create the range [MIN, MAX - 1]. */
|
/* For LT_EXPR, we create the range [MIN, MAX - 1]. */
|
if (cond_code == LT_EXPR)
|
if (cond_code == LT_EXPR)
|
{
|
{
|
tree one = build_int_cst (type, 1);
|
tree one = build_int_cst (type, 1);
|
max = fold_build2 (MINUS_EXPR, type, max, one);
|
max = fold_build2 (MINUS_EXPR, type, max, one);
|
if (EXPR_P (max))
|
if (EXPR_P (max))
|
TREE_NO_WARNING (max) = 1;
|
TREE_NO_WARNING (max) = 1;
|
}
|
}
|
|
|
set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
|
set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
|
}
|
}
|
}
|
}
|
else if (cond_code == GE_EXPR || cond_code == GT_EXPR)
|
else if (cond_code == GE_EXPR || cond_code == GT_EXPR)
|
{
|
{
|
max = TYPE_MAX_VALUE (type);
|
max = TYPE_MAX_VALUE (type);
|
|
|
if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE)
|
if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE)
|
min = limit;
|
min = limit;
|
else
|
else
|
{
|
{
|
/* If LIMIT_VR is of the form [N1, N2], we need to build the
|
/* If LIMIT_VR is of the form [N1, N2], we need to build the
|
range [N1, MAX] for GE_EXPR and [N1 + 1, MAX] for
|
range [N1, MAX] for GE_EXPR and [N1 + 1, MAX] for
|
GT_EXPR. */
|
GT_EXPR. */
|
min = limit_vr->min;
|
min = limit_vr->min;
|
}
|
}
|
|
|
/* If the minimum value forces us to be out of bounds, simply punt.
|
/* If the minimum value forces us to be out of bounds, simply punt.
|
It would be pointless to try and do anything more since this
|
It would be pointless to try and do anything more since this
|
all should be optimized away above us. */
|
all should be optimized away above us. */
|
if ((cond_code == GT_EXPR
|
if ((cond_code == GT_EXPR
|
&& compare_values (min, max) == 0)
|
&& compare_values (min, max) == 0)
|
|| is_overflow_infinity (min))
|
|| is_overflow_infinity (min))
|
set_value_range_to_varying (vr_p);
|
set_value_range_to_varying (vr_p);
|
else
|
else
|
{
|
{
|
/* For GT_EXPR, we create the range [MIN + 1, MAX]. */
|
/* For GT_EXPR, we create the range [MIN + 1, MAX]. */
|
if (cond_code == GT_EXPR)
|
if (cond_code == GT_EXPR)
|
{
|
{
|
tree one = build_int_cst (type, 1);
|
tree one = build_int_cst (type, 1);
|
min = fold_build2 (PLUS_EXPR, type, min, one);
|
min = fold_build2 (PLUS_EXPR, type, min, one);
|
if (EXPR_P (min))
|
if (EXPR_P (min))
|
TREE_NO_WARNING (min) = 1;
|
TREE_NO_WARNING (min) = 1;
|
}
|
}
|
|
|
set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
|
set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
|
}
|
}
|
}
|
}
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
|
|
/* If VAR already had a known range, it may happen that the new
|
/* If VAR already had a known range, it may happen that the new
|
range we have computed and VAR's range are not compatible. For
|
range we have computed and VAR's range are not compatible. For
|
instance,
|
instance,
|
|
|
if (p_5 == NULL)
|
if (p_5 == NULL)
|
p_6 = ASSERT_EXPR <p_5, p_5 == NULL>;
|
p_6 = ASSERT_EXPR <p_5, p_5 == NULL>;
|
x_7 = p_6->fld;
|
x_7 = p_6->fld;
|
p_8 = ASSERT_EXPR <p_6, p_6 != NULL>;
|
p_8 = ASSERT_EXPR <p_6, p_6 != NULL>;
|
|
|
While the above comes from a faulty program, it will cause an ICE
|
While the above comes from a faulty program, it will cause an ICE
|
later because p_8 and p_6 will have incompatible ranges and at
|
later because p_8 and p_6 will have incompatible ranges and at
|
the same time will be considered equivalent. A similar situation
|
the same time will be considered equivalent. A similar situation
|
would arise from
|
would arise from
|
|
|
if (i_5 > 10)
|
if (i_5 > 10)
|
i_6 = ASSERT_EXPR <i_5, i_5 > 10>;
|
i_6 = ASSERT_EXPR <i_5, i_5 > 10>;
|
if (i_5 < 5)
|
if (i_5 < 5)
|
i_7 = ASSERT_EXPR <i_6, i_6 < 5>;
|
i_7 = ASSERT_EXPR <i_6, i_6 < 5>;
|
|
|
Again i_6 and i_7 will have incompatible ranges. It would be
|
Again i_6 and i_7 will have incompatible ranges. It would be
|
pointless to try and do anything with i_7's range because
|
pointless to try and do anything with i_7's range because
|
anything dominated by 'if (i_5 < 5)' will be optimized away.
|
anything dominated by 'if (i_5 < 5)' will be optimized away.
|
Note, due to the wa in which simulation proceeds, the statement
|
Note, due to the wa in which simulation proceeds, the statement
|
i_7 = ASSERT_EXPR <...> we would never be visited because the
|
i_7 = ASSERT_EXPR <...> we would never be visited because the
|
conditional 'if (i_5 < 5)' always evaluates to false. However,
|
conditional 'if (i_5 < 5)' always evaluates to false. However,
|
this extra check does not hurt and may protect against future
|
this extra check does not hurt and may protect against future
|
changes to VRP that may get into a situation similar to the
|
changes to VRP that may get into a situation similar to the
|
NULL pointer dereference example.
|
NULL pointer dereference example.
|
|
|
Note that these compatibility tests are only needed when dealing
|
Note that these compatibility tests are only needed when dealing
|
with ranges or a mix of range and anti-range. If VAR_VR and VR_P
|
with ranges or a mix of range and anti-range. If VAR_VR and VR_P
|
are both anti-ranges, they will always be compatible, because two
|
are both anti-ranges, they will always be compatible, because two
|
anti-ranges will always have a non-empty intersection. */
|
anti-ranges will always have a non-empty intersection. */
|
|
|
var_vr = get_value_range (var);
|
var_vr = get_value_range (var);
|
|
|
/* We may need to make adjustments when VR_P and VAR_VR are numeric
|
/* We may need to make adjustments when VR_P and VAR_VR are numeric
|
ranges or anti-ranges. */
|
ranges or anti-ranges. */
|
if (vr_p->type == VR_VARYING
|
if (vr_p->type == VR_VARYING
|
|| vr_p->type == VR_UNDEFINED
|
|| vr_p->type == VR_UNDEFINED
|
|| var_vr->type == VR_VARYING
|
|| var_vr->type == VR_VARYING
|
|| var_vr->type == VR_UNDEFINED
|
|| var_vr->type == VR_UNDEFINED
|
|| symbolic_range_p (vr_p)
|
|| symbolic_range_p (vr_p)
|
|| symbolic_range_p (var_vr))
|
|| symbolic_range_p (var_vr))
|
return;
|
return;
|
|
|
if (var_vr->type == VR_RANGE && vr_p->type == VR_RANGE)
|
if (var_vr->type == VR_RANGE && vr_p->type == VR_RANGE)
|
{
|
{
|
/* If the two ranges have a non-empty intersection, we can
|
/* If the two ranges have a non-empty intersection, we can
|
refine the resulting range. Since the assert expression
|
refine the resulting range. Since the assert expression
|
creates an equivalency and at the same time it asserts a
|
creates an equivalency and at the same time it asserts a
|
predicate, we can take the intersection of the two ranges to
|
predicate, we can take the intersection of the two ranges to
|
get better precision. */
|
get better precision. */
|
if (value_ranges_intersect_p (var_vr, vr_p))
|
if (value_ranges_intersect_p (var_vr, vr_p))
|
{
|
{
|
/* Use the larger of the two minimums. */
|
/* Use the larger of the two minimums. */
|
if (compare_values (vr_p->min, var_vr->min) == -1)
|
if (compare_values (vr_p->min, var_vr->min) == -1)
|
min = var_vr->min;
|
min = var_vr->min;
|
else
|
else
|
min = vr_p->min;
|
min = vr_p->min;
|
|
|
/* Use the smaller of the two maximums. */
|
/* Use the smaller of the two maximums. */
|
if (compare_values (vr_p->max, var_vr->max) == 1)
|
if (compare_values (vr_p->max, var_vr->max) == 1)
|
max = var_vr->max;
|
max = var_vr->max;
|
else
|
else
|
max = vr_p->max;
|
max = vr_p->max;
|
|
|
set_value_range (vr_p, vr_p->type, min, max, vr_p->equiv);
|
set_value_range (vr_p, vr_p->type, min, max, vr_p->equiv);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* The two ranges do not intersect, set the new range to
|
/* The two ranges do not intersect, set the new range to
|
VARYING, because we will not be able to do anything
|
VARYING, because we will not be able to do anything
|
meaningful with it. */
|
meaningful with it. */
|
set_value_range_to_varying (vr_p);
|
set_value_range_to_varying (vr_p);
|
}
|
}
|
}
|
}
|
else if ((var_vr->type == VR_RANGE && vr_p->type == VR_ANTI_RANGE)
|
else if ((var_vr->type == VR_RANGE && vr_p->type == VR_ANTI_RANGE)
|
|| (var_vr->type == VR_ANTI_RANGE && vr_p->type == VR_RANGE))
|
|| (var_vr->type == VR_ANTI_RANGE && vr_p->type == VR_RANGE))
|
{
|
{
|
/* A range and an anti-range will cancel each other only if
|
/* A range and an anti-range will cancel each other only if
|
their ends are the same. For instance, in the example above,
|
their ends are the same. For instance, in the example above,
|
p_8's range ~[0, 0] and p_6's range [0, 0] are incompatible,
|
p_8's range ~[0, 0] and p_6's range [0, 0] are incompatible,
|
so VR_P should be set to VR_VARYING. */
|
so VR_P should be set to VR_VARYING. */
|
if (compare_values (var_vr->min, vr_p->min) == 0
|
if (compare_values (var_vr->min, vr_p->min) == 0
|
&& compare_values (var_vr->max, vr_p->max) == 0)
|
&& compare_values (var_vr->max, vr_p->max) == 0)
|
set_value_range_to_varying (vr_p);
|
set_value_range_to_varying (vr_p);
|
else
|
else
|
{
|
{
|
tree min, max, anti_min, anti_max, real_min, real_max;
|
tree min, max, anti_min, anti_max, real_min, real_max;
|
|
|
/* We want to compute the logical AND of the two ranges;
|
/* We want to compute the logical AND of the two ranges;
|
there are three cases to consider.
|
there are three cases to consider.
|
|
|
|
|
1. The VR_ANTI_RANGE range is completely within the
|
1. The VR_ANTI_RANGE range is completely within the
|
VR_RANGE and the endpoints of the ranges are
|
VR_RANGE and the endpoints of the ranges are
|
different. In that case the resulting range
|
different. In that case the resulting range
|
should be whichever range is more precise.
|
should be whichever range is more precise.
|
Typically that will be the VR_RANGE.
|
Typically that will be the VR_RANGE.
|
|
|
2. The VR_ANTI_RANGE is completely disjoint from
|
2. The VR_ANTI_RANGE is completely disjoint from
|
the VR_RANGE. In this case the resulting range
|
the VR_RANGE. In this case the resulting range
|
should be the VR_RANGE.
|
should be the VR_RANGE.
|
|
|
3. There is some overlap between the VR_ANTI_RANGE
|
3. There is some overlap between the VR_ANTI_RANGE
|
and the VR_RANGE.
|
and the VR_RANGE.
|
|
|
3a. If the high limit of the VR_ANTI_RANGE resides
|
3a. If the high limit of the VR_ANTI_RANGE resides
|
within the VR_RANGE, then the result is a new
|
within the VR_RANGE, then the result is a new
|
VR_RANGE starting at the high limit of the
|
VR_RANGE starting at the high limit of the
|
the VR_ANTI_RANGE + 1 and extending to the
|
the VR_ANTI_RANGE + 1 and extending to the
|
high limit of the original VR_RANGE.
|
high limit of the original VR_RANGE.
|
|
|
3b. If the low limit of the VR_ANTI_RANGE resides
|
3b. If the low limit of the VR_ANTI_RANGE resides
|
within the VR_RANGE, then the result is a new
|
within the VR_RANGE, then the result is a new
|
VR_RANGE starting at the low limit of the original
|
VR_RANGE starting at the low limit of the original
|
VR_RANGE and extending to the low limit of the
|
VR_RANGE and extending to the low limit of the
|
VR_ANTI_RANGE - 1. */
|
VR_ANTI_RANGE - 1. */
|
if (vr_p->type == VR_ANTI_RANGE)
|
if (vr_p->type == VR_ANTI_RANGE)
|
{
|
{
|
anti_min = vr_p->min;
|
anti_min = vr_p->min;
|
anti_max = vr_p->max;
|
anti_max = vr_p->max;
|
real_min = var_vr->min;
|
real_min = var_vr->min;
|
real_max = var_vr->max;
|
real_max = var_vr->max;
|
}
|
}
|
else
|
else
|
{
|
{
|
anti_min = var_vr->min;
|
anti_min = var_vr->min;
|
anti_max = var_vr->max;
|
anti_max = var_vr->max;
|
real_min = vr_p->min;
|
real_min = vr_p->min;
|
real_max = vr_p->max;
|
real_max = vr_p->max;
|
}
|
}
|
|
|
|
|
/* Case 1, VR_ANTI_RANGE completely within VR_RANGE,
|
/* Case 1, VR_ANTI_RANGE completely within VR_RANGE,
|
not including any endpoints. */
|
not including any endpoints. */
|
if (compare_values (anti_max, real_max) == -1
|
if (compare_values (anti_max, real_max) == -1
|
&& compare_values (anti_min, real_min) == 1)
|
&& compare_values (anti_min, real_min) == 1)
|
{
|
{
|
set_value_range (vr_p, VR_RANGE, real_min,
|
set_value_range (vr_p, VR_RANGE, real_min,
|
real_max, vr_p->equiv);
|
real_max, vr_p->equiv);
|
}
|
}
|
/* Case 2, VR_ANTI_RANGE completely disjoint from
|
/* Case 2, VR_ANTI_RANGE completely disjoint from
|
VR_RANGE. */
|
VR_RANGE. */
|
else if (compare_values (anti_min, real_max) == 1
|
else if (compare_values (anti_min, real_max) == 1
|
|| compare_values (anti_max, real_min) == -1)
|
|| compare_values (anti_max, real_min) == -1)
|
{
|
{
|
set_value_range (vr_p, VR_RANGE, real_min,
|
set_value_range (vr_p, VR_RANGE, real_min,
|
real_max, vr_p->equiv);
|
real_max, vr_p->equiv);
|
}
|
}
|
/* Case 3a, the anti-range extends into the low
|
/* Case 3a, the anti-range extends into the low
|
part of the real range. Thus creating a new
|
part of the real range. Thus creating a new
|
low for the real range. */
|
low for the real range. */
|
else if ((compare_values (anti_max, real_min) == 1
|
else if ((compare_values (anti_max, real_min) == 1
|
|| compare_values (anti_max, real_min) == 0)
|
|| compare_values (anti_max, real_min) == 0)
|
&& compare_values (anti_max, real_max) == -1)
|
&& compare_values (anti_max, real_max) == -1)
|
{
|
{
|
gcc_assert (!is_positive_overflow_infinity (anti_max));
|
gcc_assert (!is_positive_overflow_infinity (anti_max));
|
if (needs_overflow_infinity (TREE_TYPE (anti_max))
|
if (needs_overflow_infinity (TREE_TYPE (anti_max))
|
&& vrp_val_is_max (anti_max))
|
&& vrp_val_is_max (anti_max))
|
{
|
{
|
if (!supports_overflow_infinity (TREE_TYPE (var_vr->min)))
|
if (!supports_overflow_infinity (TREE_TYPE (var_vr->min)))
|
{
|
{
|
set_value_range_to_varying (vr_p);
|
set_value_range_to_varying (vr_p);
|
return;
|
return;
|
}
|
}
|
min = positive_overflow_infinity (TREE_TYPE (var_vr->min));
|
min = positive_overflow_infinity (TREE_TYPE (var_vr->min));
|
}
|
}
|
else
|
else
|
min = fold_build2 (PLUS_EXPR, TREE_TYPE (var_vr->min),
|
min = fold_build2 (PLUS_EXPR, TREE_TYPE (var_vr->min),
|
anti_max,
|
anti_max,
|
build_int_cst (TREE_TYPE (var_vr->min), 1));
|
build_int_cst (TREE_TYPE (var_vr->min), 1));
|
max = real_max;
|
max = real_max;
|
set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
|
set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
|
}
|
}
|
/* Case 3b, the anti-range extends into the high
|
/* Case 3b, the anti-range extends into the high
|
part of the real range. Thus creating a new
|
part of the real range. Thus creating a new
|
higher for the real range. */
|
higher for the real range. */
|
else if (compare_values (anti_min, real_min) == 1
|
else if (compare_values (anti_min, real_min) == 1
|
&& (compare_values (anti_min, real_max) == -1
|
&& (compare_values (anti_min, real_max) == -1
|
|| compare_values (anti_min, real_max) == 0))
|
|| compare_values (anti_min, real_max) == 0))
|
{
|
{
|
gcc_assert (!is_negative_overflow_infinity (anti_min));
|
gcc_assert (!is_negative_overflow_infinity (anti_min));
|
if (needs_overflow_infinity (TREE_TYPE (anti_min))
|
if (needs_overflow_infinity (TREE_TYPE (anti_min))
|
&& vrp_val_is_min (anti_min))
|
&& vrp_val_is_min (anti_min))
|
{
|
{
|
if (!supports_overflow_infinity (TREE_TYPE (var_vr->min)))
|
if (!supports_overflow_infinity (TREE_TYPE (var_vr->min)))
|
{
|
{
|
set_value_range_to_varying (vr_p);
|
set_value_range_to_varying (vr_p);
|
return;
|
return;
|
}
|
}
|
max = negative_overflow_infinity (TREE_TYPE (var_vr->min));
|
max = negative_overflow_infinity (TREE_TYPE (var_vr->min));
|
}
|
}
|
else
|
else
|
max = fold_build2 (MINUS_EXPR, TREE_TYPE (var_vr->min),
|
max = fold_build2 (MINUS_EXPR, TREE_TYPE (var_vr->min),
|
anti_min,
|
anti_min,
|
build_int_cst (TREE_TYPE (var_vr->min), 1));
|
build_int_cst (TREE_TYPE (var_vr->min), 1));
|
min = real_min;
|
min = real_min;
|
set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
|
set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Extract range information from SSA name VAR and store it in VR. If
|
/* Extract range information from SSA name VAR and store it in VR. If
|
VAR has an interesting range, use it. Otherwise, create the
|
VAR has an interesting range, use it. Otherwise, create the
|
range [VAR, VAR] and return it. This is useful in situations where
|
range [VAR, VAR] and return it. This is useful in situations where
|
we may have conditionals testing values of VARYING names. For
|
we may have conditionals testing values of VARYING names. For
|
instance,
|
instance,
|
|
|
x_3 = y_5;
|
x_3 = y_5;
|
if (x_3 > y_5)
|
if (x_3 > y_5)
|
...
|
...
|
|
|
Even if y_5 is deemed VARYING, we can determine that x_3 > y_5 is
|
Even if y_5 is deemed VARYING, we can determine that x_3 > y_5 is
|
always false. */
|
always false. */
|
|
|
static void
|
static void
|
extract_range_from_ssa_name (value_range_t *vr, tree var)
|
extract_range_from_ssa_name (value_range_t *vr, tree var)
|
{
|
{
|
value_range_t *var_vr = get_value_range (var);
|
value_range_t *var_vr = get_value_range (var);
|
|
|
if (var_vr->type != VR_UNDEFINED && var_vr->type != VR_VARYING)
|
if (var_vr->type != VR_UNDEFINED && var_vr->type != VR_VARYING)
|
copy_value_range (vr, var_vr);
|
copy_value_range (vr, var_vr);
|
else
|
else
|
set_value_range (vr, VR_RANGE, var, var, NULL);
|
set_value_range (vr, VR_RANGE, var, var, NULL);
|
|
|
add_equivalence (vr->equiv, var);
|
add_equivalence (vr->equiv, var);
|
}
|
}
|
|
|
|
|
/* Wrapper around int_const_binop. If the operation overflows and we
|
/* Wrapper around int_const_binop. If the operation overflows and we
|
are not using wrapping arithmetic, then adjust the result to be
|
are not using wrapping arithmetic, then adjust the result to be
|
-INF or +INF depending on CODE, VAL1 and VAL2. This can return
|
-INF or +INF depending on CODE, VAL1 and VAL2. This can return
|
NULL_TREE if we need to use an overflow infinity representation but
|
NULL_TREE if we need to use an overflow infinity representation but
|
the type does not support it. */
|
the type does not support it. */
|
|
|
static tree
|
static tree
|
vrp_int_const_binop (enum tree_code code, tree val1, tree val2)
|
vrp_int_const_binop (enum tree_code code, tree val1, tree val2)
|
{
|
{
|
tree res;
|
tree res;
|
|
|
res = int_const_binop (code, val1, val2, 0);
|
res = int_const_binop (code, val1, val2, 0);
|
|
|
/* If we are not using wrapping arithmetic, operate symbolically
|
/* If we are not using wrapping arithmetic, operate symbolically
|
on -INF and +INF. */
|
on -INF and +INF. */
|
if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (val1)))
|
if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (val1)))
|
{
|
{
|
int checkz = compare_values (res, val1);
|
int checkz = compare_values (res, val1);
|
bool overflow = false;
|
bool overflow = false;
|
|
|
/* Ensure that res = val1 [+*] val2 >= val1
|
/* Ensure that res = val1 [+*] val2 >= val1
|
or that res = val1 - val2 <= val1. */
|
or that res = val1 - val2 <= val1. */
|
if ((code == PLUS_EXPR
|
if ((code == PLUS_EXPR
|
&& !(checkz == 1 || checkz == 0))
|
&& !(checkz == 1 || checkz == 0))
|
|| (code == MINUS_EXPR
|
|| (code == MINUS_EXPR
|
&& !(checkz == 0 || checkz == -1)))
|
&& !(checkz == 0 || checkz == -1)))
|
{
|
{
|
overflow = true;
|
overflow = true;
|
}
|
}
|
/* Checking for multiplication overflow is done by dividing the
|
/* Checking for multiplication overflow is done by dividing the
|
output of the multiplication by the first input of the
|
output of the multiplication by the first input of the
|
multiplication. If the result of that division operation is
|
multiplication. If the result of that division operation is
|
not equal to the second input of the multiplication, then the
|
not equal to the second input of the multiplication, then the
|
multiplication overflowed. */
|
multiplication overflowed. */
|
else if (code == MULT_EXPR && !integer_zerop (val1))
|
else if (code == MULT_EXPR && !integer_zerop (val1))
|
{
|
{
|
tree tmp = int_const_binop (TRUNC_DIV_EXPR,
|
tree tmp = int_const_binop (TRUNC_DIV_EXPR,
|
res,
|
res,
|
val1, 0);
|
val1, 0);
|
int check = compare_values (tmp, val2);
|
int check = compare_values (tmp, val2);
|
|
|
if (check != 0)
|
if (check != 0)
|
overflow = true;
|
overflow = true;
|
}
|
}
|
|
|
if (overflow)
|
if (overflow)
|
{
|
{
|
res = copy_node (res);
|
res = copy_node (res);
|
TREE_OVERFLOW (res) = 1;
|
TREE_OVERFLOW (res) = 1;
|
}
|
}
|
|
|
}
|
}
|
else if ((TREE_OVERFLOW (res)
|
else if ((TREE_OVERFLOW (res)
|
&& !TREE_OVERFLOW (val1)
|
&& !TREE_OVERFLOW (val1)
|
&& !TREE_OVERFLOW (val2))
|
&& !TREE_OVERFLOW (val2))
|
|| is_overflow_infinity (val1)
|
|| is_overflow_infinity (val1)
|
|| is_overflow_infinity (val2))
|
|| is_overflow_infinity (val2))
|
{
|
{
|
/* If the operation overflowed but neither VAL1 nor VAL2 are
|
/* If the operation overflowed but neither VAL1 nor VAL2 are
|
overflown, return -INF or +INF depending on the operation
|
overflown, return -INF or +INF depending on the operation
|
and the combination of signs of the operands. */
|
and the combination of signs of the operands. */
|
int sgn1 = tree_int_cst_sgn (val1);
|
int sgn1 = tree_int_cst_sgn (val1);
|
int sgn2 = tree_int_cst_sgn (val2);
|
int sgn2 = tree_int_cst_sgn (val2);
|
|
|
if (needs_overflow_infinity (TREE_TYPE (res))
|
if (needs_overflow_infinity (TREE_TYPE (res))
|
&& !supports_overflow_infinity (TREE_TYPE (res)))
|
&& !supports_overflow_infinity (TREE_TYPE (res)))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* We have to punt on adding infinities of different signs,
|
/* We have to punt on adding infinities of different signs,
|
since we can't tell what the sign of the result should be.
|
since we can't tell what the sign of the result should be.
|
Likewise for subtracting infinities of the same sign. */
|
Likewise for subtracting infinities of the same sign. */
|
if (((code == PLUS_EXPR && sgn1 != sgn2)
|
if (((code == PLUS_EXPR && sgn1 != sgn2)
|
|| (code == MINUS_EXPR && sgn1 == sgn2))
|
|| (code == MINUS_EXPR && sgn1 == sgn2))
|
&& is_overflow_infinity (val1)
|
&& is_overflow_infinity (val1)
|
&& is_overflow_infinity (val2))
|
&& is_overflow_infinity (val2))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* Don't try to handle division or shifting of infinities. */
|
/* Don't try to handle division or shifting of infinities. */
|
if ((code == TRUNC_DIV_EXPR
|
if ((code == TRUNC_DIV_EXPR
|
|| code == FLOOR_DIV_EXPR
|
|| code == FLOOR_DIV_EXPR
|
|| code == CEIL_DIV_EXPR
|
|| code == CEIL_DIV_EXPR
|
|| code == EXACT_DIV_EXPR
|
|| code == EXACT_DIV_EXPR
|
|| code == ROUND_DIV_EXPR
|
|| code == ROUND_DIV_EXPR
|
|| code == RSHIFT_EXPR)
|
|| code == RSHIFT_EXPR)
|
&& (is_overflow_infinity (val1)
|
&& (is_overflow_infinity (val1)
|
|| is_overflow_infinity (val2)))
|
|| is_overflow_infinity (val2)))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* Notice that we only need to handle the restricted set of
|
/* Notice that we only need to handle the restricted set of
|
operations handled by extract_range_from_binary_expr.
|
operations handled by extract_range_from_binary_expr.
|
Among them, only multiplication, addition and subtraction
|
Among them, only multiplication, addition and subtraction
|
can yield overflow without overflown operands because we
|
can yield overflow without overflown operands because we
|
are working with integral types only... except in the
|
are working with integral types only... except in the
|
case VAL1 = -INF and VAL2 = -1 which overflows to +INF
|
case VAL1 = -INF and VAL2 = -1 which overflows to +INF
|
for division too. */
|
for division too. */
|
|
|
/* For multiplication, the sign of the overflow is given
|
/* For multiplication, the sign of the overflow is given
|
by the comparison of the signs of the operands. */
|
by the comparison of the signs of the operands. */
|
if ((code == MULT_EXPR && sgn1 == sgn2)
|
if ((code == MULT_EXPR && sgn1 == sgn2)
|
/* For addition, the operands must be of the same sign
|
/* For addition, the operands must be of the same sign
|
to yield an overflow. Its sign is therefore that
|
to yield an overflow. Its sign is therefore that
|
of one of the operands, for example the first. For
|
of one of the operands, for example the first. For
|
infinite operands X + -INF is negative, not positive. */
|
infinite operands X + -INF is negative, not positive. */
|
|| (code == PLUS_EXPR
|
|| (code == PLUS_EXPR
|
&& (sgn1 >= 0
|
&& (sgn1 >= 0
|
? !is_negative_overflow_infinity (val2)
|
? !is_negative_overflow_infinity (val2)
|
: is_positive_overflow_infinity (val2)))
|
: is_positive_overflow_infinity (val2)))
|
/* For subtraction, non-infinite operands must be of
|
/* For subtraction, non-infinite operands must be of
|
different signs to yield an overflow. Its sign is
|
different signs to yield an overflow. Its sign is
|
therefore that of the first operand or the opposite of
|
therefore that of the first operand or the opposite of
|
that of the second operand. A first operand of 0 counts
|
that of the second operand. A first operand of 0 counts
|
as positive here, for the corner case 0 - (-INF), which
|
as positive here, for the corner case 0 - (-INF), which
|
overflows, but must yield +INF. For infinite operands 0
|
overflows, but must yield +INF. For infinite operands 0
|
- INF is negative, not positive. */
|
- INF is negative, not positive. */
|
|| (code == MINUS_EXPR
|
|| (code == MINUS_EXPR
|
&& (sgn1 >= 0
|
&& (sgn1 >= 0
|
? !is_positive_overflow_infinity (val2)
|
? !is_positive_overflow_infinity (val2)
|
: is_negative_overflow_infinity (val2)))
|
: is_negative_overflow_infinity (val2)))
|
/* For division, the only case is -INF / -1 = +INF. */
|
/* For division, the only case is -INF / -1 = +INF. */
|
|| code == TRUNC_DIV_EXPR
|
|| code == TRUNC_DIV_EXPR
|
|| code == FLOOR_DIV_EXPR
|
|| code == FLOOR_DIV_EXPR
|
|| code == CEIL_DIV_EXPR
|
|| code == CEIL_DIV_EXPR
|
|| code == EXACT_DIV_EXPR
|
|| code == EXACT_DIV_EXPR
|
|| code == ROUND_DIV_EXPR)
|
|| code == ROUND_DIV_EXPR)
|
return (needs_overflow_infinity (TREE_TYPE (res))
|
return (needs_overflow_infinity (TREE_TYPE (res))
|
? positive_overflow_infinity (TREE_TYPE (res))
|
? positive_overflow_infinity (TREE_TYPE (res))
|
: TYPE_MAX_VALUE (TREE_TYPE (res)));
|
: TYPE_MAX_VALUE (TREE_TYPE (res)));
|
else
|
else
|
return (needs_overflow_infinity (TREE_TYPE (res))
|
return (needs_overflow_infinity (TREE_TYPE (res))
|
? negative_overflow_infinity (TREE_TYPE (res))
|
? negative_overflow_infinity (TREE_TYPE (res))
|
: TYPE_MIN_VALUE (TREE_TYPE (res)));
|
: TYPE_MIN_VALUE (TREE_TYPE (res)));
|
}
|
}
|
|
|
return res;
|
return res;
|
}
|
}
|
|
|
|
|
/* Extract range information from a binary expression EXPR based on
|
/* Extract range information from a binary expression EXPR based on
|
the ranges of each of its operands and the expression code. */
|
the ranges of each of its operands and the expression code. */
|
|
|
static void
|
static void
|
extract_range_from_binary_expr (value_range_t *vr, tree expr)
|
extract_range_from_binary_expr (value_range_t *vr, tree expr)
|
{
|
{
|
enum tree_code code = TREE_CODE (expr);
|
enum tree_code code = TREE_CODE (expr);
|
enum value_range_type type;
|
enum value_range_type type;
|
tree op0, op1, min, max;
|
tree op0, op1, min, max;
|
int cmp;
|
int cmp;
|
value_range_t vr0 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
|
value_range_t vr0 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
|
value_range_t vr1 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
|
value_range_t vr1 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
|
|
|
/* Not all binary expressions can be applied to ranges in a
|
/* Not all binary expressions can be applied to ranges in a
|
meaningful way. Handle only arithmetic operations. */
|
meaningful way. Handle only arithmetic operations. */
|
if (code != PLUS_EXPR
|
if (code != PLUS_EXPR
|
&& code != MINUS_EXPR
|
&& code != MINUS_EXPR
|
&& code != MULT_EXPR
|
&& code != MULT_EXPR
|
&& code != TRUNC_DIV_EXPR
|
&& code != TRUNC_DIV_EXPR
|
&& code != FLOOR_DIV_EXPR
|
&& code != FLOOR_DIV_EXPR
|
&& code != CEIL_DIV_EXPR
|
&& code != CEIL_DIV_EXPR
|
&& code != EXACT_DIV_EXPR
|
&& code != EXACT_DIV_EXPR
|
&& code != ROUND_DIV_EXPR
|
&& code != ROUND_DIV_EXPR
|
&& code != MIN_EXPR
|
&& code != MIN_EXPR
|
&& code != MAX_EXPR
|
&& code != MAX_EXPR
|
&& code != BIT_AND_EXPR
|
&& code != BIT_AND_EXPR
|
&& code != TRUTH_ANDIF_EXPR
|
&& code != TRUTH_ANDIF_EXPR
|
&& code != TRUTH_ORIF_EXPR
|
&& code != TRUTH_ORIF_EXPR
|
&& code != TRUTH_AND_EXPR
|
&& code != TRUTH_AND_EXPR
|
&& code != TRUTH_OR_EXPR)
|
&& code != TRUTH_OR_EXPR)
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* Get value ranges for each operand. For constant operands, create
|
/* Get value ranges for each operand. For constant operands, create
|
a new value range with the operand to simplify processing. */
|
a new value range with the operand to simplify processing. */
|
op0 = TREE_OPERAND (expr, 0);
|
op0 = TREE_OPERAND (expr, 0);
|
if (TREE_CODE (op0) == SSA_NAME)
|
if (TREE_CODE (op0) == SSA_NAME)
|
vr0 = *(get_value_range (op0));
|
vr0 = *(get_value_range (op0));
|
else if (is_gimple_min_invariant (op0))
|
else if (is_gimple_min_invariant (op0))
|
set_value_range_to_value (&vr0, op0, NULL);
|
set_value_range_to_value (&vr0, op0, NULL);
|
else
|
else
|
set_value_range_to_varying (&vr0);
|
set_value_range_to_varying (&vr0);
|
|
|
op1 = TREE_OPERAND (expr, 1);
|
op1 = TREE_OPERAND (expr, 1);
|
if (TREE_CODE (op1) == SSA_NAME)
|
if (TREE_CODE (op1) == SSA_NAME)
|
vr1 = *(get_value_range (op1));
|
vr1 = *(get_value_range (op1));
|
else if (is_gimple_min_invariant (op1))
|
else if (is_gimple_min_invariant (op1))
|
set_value_range_to_value (&vr1, op1, NULL);
|
set_value_range_to_value (&vr1, op1, NULL);
|
else
|
else
|
set_value_range_to_varying (&vr1);
|
set_value_range_to_varying (&vr1);
|
|
|
/* If either range is UNDEFINED, so is the result. */
|
/* If either range is UNDEFINED, so is the result. */
|
if (vr0.type == VR_UNDEFINED || vr1.type == VR_UNDEFINED)
|
if (vr0.type == VR_UNDEFINED || vr1.type == VR_UNDEFINED)
|
{
|
{
|
set_value_range_to_undefined (vr);
|
set_value_range_to_undefined (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* The type of the resulting value range defaults to VR0.TYPE. */
|
/* The type of the resulting value range defaults to VR0.TYPE. */
|
type = vr0.type;
|
type = vr0.type;
|
|
|
/* Refuse to operate on VARYING ranges, ranges of different kinds
|
/* Refuse to operate on VARYING ranges, ranges of different kinds
|
and symbolic ranges. As an exception, we allow BIT_AND_EXPR
|
and symbolic ranges. As an exception, we allow BIT_AND_EXPR
|
because we may be able to derive a useful range even if one of
|
because we may be able to derive a useful range even if one of
|
the operands is VR_VARYING or symbolic range. TODO, we may be
|
the operands is VR_VARYING or symbolic range. TODO, we may be
|
able to derive anti-ranges in some cases. */
|
able to derive anti-ranges in some cases. */
|
if (code != BIT_AND_EXPR
|
if (code != BIT_AND_EXPR
|
&& code != TRUTH_AND_EXPR
|
&& code != TRUTH_AND_EXPR
|
&& code != TRUTH_OR_EXPR
|
&& code != TRUTH_OR_EXPR
|
&& (vr0.type == VR_VARYING
|
&& (vr0.type == VR_VARYING
|
|| vr1.type == VR_VARYING
|
|| vr1.type == VR_VARYING
|
|| vr0.type != vr1.type
|
|| vr0.type != vr1.type
|
|| symbolic_range_p (&vr0)
|
|| symbolic_range_p (&vr0)
|
|| symbolic_range_p (&vr1)))
|
|| symbolic_range_p (&vr1)))
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* Now evaluate the expression to determine the new range. */
|
/* Now evaluate the expression to determine the new range. */
|
if (POINTER_TYPE_P (TREE_TYPE (expr))
|
if (POINTER_TYPE_P (TREE_TYPE (expr))
|
|| POINTER_TYPE_P (TREE_TYPE (op0))
|
|| POINTER_TYPE_P (TREE_TYPE (op0))
|
|| POINTER_TYPE_P (TREE_TYPE (op1)))
|
|| POINTER_TYPE_P (TREE_TYPE (op1)))
|
{
|
{
|
/* For pointer types, we are really only interested in asserting
|
/* For pointer types, we are really only interested in asserting
|
whether the expression evaluates to non-NULL. FIXME, we used
|
whether the expression evaluates to non-NULL. FIXME, we used
|
to gcc_assert (code == PLUS_EXPR || code == MINUS_EXPR), but
|
to gcc_assert (code == PLUS_EXPR || code == MINUS_EXPR), but
|
ivopts is generating expressions with pointer multiplication
|
ivopts is generating expressions with pointer multiplication
|
in them. */
|
in them. */
|
if (code == PLUS_EXPR)
|
if (code == PLUS_EXPR)
|
{
|
{
|
if (range_is_nonnull (&vr0) || range_is_nonnull (&vr1))
|
if (range_is_nonnull (&vr0) || range_is_nonnull (&vr1))
|
set_value_range_to_nonnull (vr, TREE_TYPE (expr));
|
set_value_range_to_nonnull (vr, TREE_TYPE (expr));
|
else if (range_is_null (&vr0) && range_is_null (&vr1))
|
else if (range_is_null (&vr0) && range_is_null (&vr1))
|
set_value_range_to_null (vr, TREE_TYPE (expr));
|
set_value_range_to_null (vr, TREE_TYPE (expr));
|
else
|
else
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Subtracting from a pointer, may yield 0, so just drop the
|
/* Subtracting from a pointer, may yield 0, so just drop the
|
resulting range to varying. */
|
resulting range to varying. */
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
}
|
}
|
|
|
return;
|
return;
|
}
|
}
|
|
|
/* For integer ranges, apply the operation to each end of the
|
/* For integer ranges, apply the operation to each end of the
|
range and see what we end up with. */
|
range and see what we end up with. */
|
if (code == TRUTH_ANDIF_EXPR
|
if (code == TRUTH_ANDIF_EXPR
|
|| code == TRUTH_ORIF_EXPR
|
|| code == TRUTH_ORIF_EXPR
|
|| code == TRUTH_AND_EXPR
|
|| code == TRUTH_AND_EXPR
|
|| code == TRUTH_OR_EXPR)
|
|| code == TRUTH_OR_EXPR)
|
{
|
{
|
/* If one of the operands is zero, we know that the whole
|
/* If one of the operands is zero, we know that the whole
|
expression evaluates zero. */
|
expression evaluates zero. */
|
if (code == TRUTH_AND_EXPR
|
if (code == TRUTH_AND_EXPR
|
&& ((vr0.type == VR_RANGE
|
&& ((vr0.type == VR_RANGE
|
&& integer_zerop (vr0.min)
|
&& integer_zerop (vr0.min)
|
&& integer_zerop (vr0.max))
|
&& integer_zerop (vr0.max))
|
|| (vr1.type == VR_RANGE
|
|| (vr1.type == VR_RANGE
|
&& integer_zerop (vr1.min)
|
&& integer_zerop (vr1.min)
|
&& integer_zerop (vr1.max))))
|
&& integer_zerop (vr1.max))))
|
{
|
{
|
type = VR_RANGE;
|
type = VR_RANGE;
|
min = max = build_int_cst (TREE_TYPE (expr), 0);
|
min = max = build_int_cst (TREE_TYPE (expr), 0);
|
}
|
}
|
/* If one of the operands is one, we know that the whole
|
/* If one of the operands is one, we know that the whole
|
expression evaluates one. */
|
expression evaluates one. */
|
else if (code == TRUTH_OR_EXPR
|
else if (code == TRUTH_OR_EXPR
|
&& ((vr0.type == VR_RANGE
|
&& ((vr0.type == VR_RANGE
|
&& integer_onep (vr0.min)
|
&& integer_onep (vr0.min)
|
&& integer_onep (vr0.max))
|
&& integer_onep (vr0.max))
|
|| (vr1.type == VR_RANGE
|
|| (vr1.type == VR_RANGE
|
&& integer_onep (vr1.min)
|
&& integer_onep (vr1.min)
|
&& integer_onep (vr1.max))))
|
&& integer_onep (vr1.max))))
|
{
|
{
|
type = VR_RANGE;
|
type = VR_RANGE;
|
min = max = build_int_cst (TREE_TYPE (expr), 1);
|
min = max = build_int_cst (TREE_TYPE (expr), 1);
|
}
|
}
|
else if (vr0.type != VR_VARYING
|
else if (vr0.type != VR_VARYING
|
&& vr1.type != VR_VARYING
|
&& vr1.type != VR_VARYING
|
&& vr0.type == vr1.type
|
&& vr0.type == vr1.type
|
&& !symbolic_range_p (&vr0)
|
&& !symbolic_range_p (&vr0)
|
&& !overflow_infinity_range_p (&vr0)
|
&& !overflow_infinity_range_p (&vr0)
|
&& !symbolic_range_p (&vr1)
|
&& !symbolic_range_p (&vr1)
|
&& !overflow_infinity_range_p (&vr1))
|
&& !overflow_infinity_range_p (&vr1))
|
{
|
{
|
/* Boolean expressions cannot be folded with int_const_binop. */
|
/* Boolean expressions cannot be folded with int_const_binop. */
|
min = fold_binary (code, TREE_TYPE (expr), vr0.min, vr1.min);
|
min = fold_binary (code, TREE_TYPE (expr), vr0.min, vr1.min);
|
max = fold_binary (code, TREE_TYPE (expr), vr0.max, vr1.max);
|
max = fold_binary (code, TREE_TYPE (expr), vr0.max, vr1.max);
|
}
|
}
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
else if (code == PLUS_EXPR
|
else if (code == PLUS_EXPR
|
|| code == MIN_EXPR
|
|| code == MIN_EXPR
|
|| code == MAX_EXPR)
|
|| code == MAX_EXPR)
|
{
|
{
|
/* If we have a PLUS_EXPR with two VR_ANTI_RANGEs, drop to
|
/* If we have a PLUS_EXPR with two VR_ANTI_RANGEs, drop to
|
VR_VARYING. It would take more effort to compute a precise
|
VR_VARYING. It would take more effort to compute a precise
|
range for such a case. For example, if we have op0 == 1 and
|
range for such a case. For example, if we have op0 == 1 and
|
op1 == -1 with their ranges both being ~[0,0], we would have
|
op1 == -1 with their ranges both being ~[0,0], we would have
|
op0 + op1 == 0, so we cannot claim that the sum is in ~[0,0].
|
op0 + op1 == 0, so we cannot claim that the sum is in ~[0,0].
|
Note that we are guaranteed to have vr0.type == vr1.type at
|
Note that we are guaranteed to have vr0.type == vr1.type at
|
this point. */
|
this point. */
|
if (code == PLUS_EXPR && vr0.type == VR_ANTI_RANGE)
|
if (code == PLUS_EXPR && vr0.type == VR_ANTI_RANGE)
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* For operations that make the resulting range directly
|
/* For operations that make the resulting range directly
|
proportional to the original ranges, apply the operation to
|
proportional to the original ranges, apply the operation to
|
the same end of each range. */
|
the same end of each range. */
|
min = vrp_int_const_binop (code, vr0.min, vr1.min);
|
min = vrp_int_const_binop (code, vr0.min, vr1.min);
|
max = vrp_int_const_binop (code, vr0.max, vr1.max);
|
max = vrp_int_const_binop (code, vr0.max, vr1.max);
|
}
|
}
|
else if (code == MULT_EXPR
|
else if (code == MULT_EXPR
|
|| code == TRUNC_DIV_EXPR
|
|| code == TRUNC_DIV_EXPR
|
|| code == FLOOR_DIV_EXPR
|
|| code == FLOOR_DIV_EXPR
|
|| code == CEIL_DIV_EXPR
|
|| code == CEIL_DIV_EXPR
|
|| code == EXACT_DIV_EXPR
|
|| code == EXACT_DIV_EXPR
|
|| code == ROUND_DIV_EXPR)
|
|| code == ROUND_DIV_EXPR)
|
{
|
{
|
tree val[4];
|
tree val[4];
|
size_t i;
|
size_t i;
|
bool sop;
|
bool sop;
|
|
|
/* If we have an unsigned MULT_EXPR with two VR_ANTI_RANGEs,
|
/* If we have an unsigned MULT_EXPR with two VR_ANTI_RANGEs,
|
drop to VR_VARYING. It would take more effort to compute a
|
drop to VR_VARYING. It would take more effort to compute a
|
precise range for such a case. For example, if we have
|
precise range for such a case. For example, if we have
|
op0 == 65536 and op1 == 65536 with their ranges both being
|
op0 == 65536 and op1 == 65536 with their ranges both being
|
~[0,0] on a 32-bit machine, we would have op0 * op1 == 0, so
|
~[0,0] on a 32-bit machine, we would have op0 * op1 == 0, so
|
we cannot claim that the product is in ~[0,0]. Note that we
|
we cannot claim that the product is in ~[0,0]. Note that we
|
are guaranteed to have vr0.type == vr1.type at this
|
are guaranteed to have vr0.type == vr1.type at this
|
point. */
|
point. */
|
if (code == MULT_EXPR
|
if (code == MULT_EXPR
|
&& vr0.type == VR_ANTI_RANGE
|
&& vr0.type == VR_ANTI_RANGE
|
&& !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0)))
|
&& !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0)))
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* Multiplications and divisions are a bit tricky to handle,
|
/* Multiplications and divisions are a bit tricky to handle,
|
depending on the mix of signs we have in the two ranges, we
|
depending on the mix of signs we have in the two ranges, we
|
need to operate on different values to get the minimum and
|
need to operate on different values to get the minimum and
|
maximum values for the new range. One approach is to figure
|
maximum values for the new range. One approach is to figure
|
out all the variations of range combinations and do the
|
out all the variations of range combinations and do the
|
operations.
|
operations.
|
|
|
However, this involves several calls to compare_values and it
|
However, this involves several calls to compare_values and it
|
is pretty convoluted. It's simpler to do the 4 operations
|
is pretty convoluted. It's simpler to do the 4 operations
|
(MIN0 OP MIN1, MIN0 OP MAX1, MAX0 OP MIN1 and MAX0 OP MAX0 OP
|
(MIN0 OP MIN1, MIN0 OP MAX1, MAX0 OP MIN1 and MAX0 OP MAX0 OP
|
MAX1) and then figure the smallest and largest values to form
|
MAX1) and then figure the smallest and largest values to form
|
the new range. */
|
the new range. */
|
|
|
/* Divisions by zero result in a VARYING value. */
|
/* Divisions by zero result in a VARYING value. */
|
if (code != MULT_EXPR
|
if (code != MULT_EXPR
|
&& (vr0.type == VR_ANTI_RANGE || range_includes_zero_p (&vr1)))
|
&& (vr0.type == VR_ANTI_RANGE || range_includes_zero_p (&vr1)))
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* Compute the 4 cross operations. */
|
/* Compute the 4 cross operations. */
|
sop = false;
|
sop = false;
|
val[0] = vrp_int_const_binop (code, vr0.min, vr1.min);
|
val[0] = vrp_int_const_binop (code, vr0.min, vr1.min);
|
if (val[0] == NULL_TREE)
|
if (val[0] == NULL_TREE)
|
sop = true;
|
sop = true;
|
|
|
if (vr1.max == vr1.min)
|
if (vr1.max == vr1.min)
|
val[1] = NULL_TREE;
|
val[1] = NULL_TREE;
|
else
|
else
|
{
|
{
|
val[1] = vrp_int_const_binop (code, vr0.min, vr1.max);
|
val[1] = vrp_int_const_binop (code, vr0.min, vr1.max);
|
if (val[1] == NULL_TREE)
|
if (val[1] == NULL_TREE)
|
sop = true;
|
sop = true;
|
}
|
}
|
|
|
if (vr0.max == vr0.min)
|
if (vr0.max == vr0.min)
|
val[2] = NULL_TREE;
|
val[2] = NULL_TREE;
|
else
|
else
|
{
|
{
|
val[2] = vrp_int_const_binop (code, vr0.max, vr1.min);
|
val[2] = vrp_int_const_binop (code, vr0.max, vr1.min);
|
if (val[2] == NULL_TREE)
|
if (val[2] == NULL_TREE)
|
sop = true;
|
sop = true;
|
}
|
}
|
|
|
if (vr0.min == vr0.max || vr1.min == vr1.max)
|
if (vr0.min == vr0.max || vr1.min == vr1.max)
|
val[3] = NULL_TREE;
|
val[3] = NULL_TREE;
|
else
|
else
|
{
|
{
|
val[3] = vrp_int_const_binop (code, vr0.max, vr1.max);
|
val[3] = vrp_int_const_binop (code, vr0.max, vr1.max);
|
if (val[3] == NULL_TREE)
|
if (val[3] == NULL_TREE)
|
sop = true;
|
sop = true;
|
}
|
}
|
|
|
if (sop)
|
if (sop)
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* Set MIN to the minimum of VAL[i] and MAX to the maximum
|
/* Set MIN to the minimum of VAL[i] and MAX to the maximum
|
of VAL[i]. */
|
of VAL[i]. */
|
min = val[0];
|
min = val[0];
|
max = val[0];
|
max = val[0];
|
for (i = 1; i < 4; i++)
|
for (i = 1; i < 4; i++)
|
{
|
{
|
if (!is_gimple_min_invariant (min)
|
if (!is_gimple_min_invariant (min)
|
|| (TREE_OVERFLOW (min) && !is_overflow_infinity (min))
|
|| (TREE_OVERFLOW (min) && !is_overflow_infinity (min))
|
|| !is_gimple_min_invariant (max)
|
|| !is_gimple_min_invariant (max)
|
|| (TREE_OVERFLOW (max) && !is_overflow_infinity (max)))
|
|| (TREE_OVERFLOW (max) && !is_overflow_infinity (max)))
|
break;
|
break;
|
|
|
if (val[i])
|
if (val[i])
|
{
|
{
|
if (!is_gimple_min_invariant (val[i])
|
if (!is_gimple_min_invariant (val[i])
|
|| (TREE_OVERFLOW (val[i])
|
|| (TREE_OVERFLOW (val[i])
|
&& !is_overflow_infinity (val[i])))
|
&& !is_overflow_infinity (val[i])))
|
{
|
{
|
/* If we found an overflowed value, set MIN and MAX
|
/* If we found an overflowed value, set MIN and MAX
|
to it so that we set the resulting range to
|
to it so that we set the resulting range to
|
VARYING. */
|
VARYING. */
|
min = max = val[i];
|
min = max = val[i];
|
break;
|
break;
|
}
|
}
|
|
|
if (compare_values (val[i], min) == -1)
|
if (compare_values (val[i], min) == -1)
|
min = val[i];
|
min = val[i];
|
|
|
if (compare_values (val[i], max) == 1)
|
if (compare_values (val[i], max) == 1)
|
max = val[i];
|
max = val[i];
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (code == MINUS_EXPR)
|
else if (code == MINUS_EXPR)
|
{
|
{
|
/* If we have a MINUS_EXPR with two VR_ANTI_RANGEs, drop to
|
/* If we have a MINUS_EXPR with two VR_ANTI_RANGEs, drop to
|
VR_VARYING. It would take more effort to compute a precise
|
VR_VARYING. It would take more effort to compute a precise
|
range for such a case. For example, if we have op0 == 1 and
|
range for such a case. For example, if we have op0 == 1 and
|
op1 == 1 with their ranges both being ~[0,0], we would have
|
op1 == 1 with their ranges both being ~[0,0], we would have
|
op0 - op1 == 0, so we cannot claim that the difference is in
|
op0 - op1 == 0, so we cannot claim that the difference is in
|
~[0,0]. Note that we are guaranteed to have
|
~[0,0]. Note that we are guaranteed to have
|
vr0.type == vr1.type at this point. */
|
vr0.type == vr1.type at this point. */
|
if (vr0.type == VR_ANTI_RANGE)
|
if (vr0.type == VR_ANTI_RANGE)
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* For MINUS_EXPR, apply the operation to the opposite ends of
|
/* For MINUS_EXPR, apply the operation to the opposite ends of
|
each range. */
|
each range. */
|
min = vrp_int_const_binop (code, vr0.min, vr1.max);
|
min = vrp_int_const_binop (code, vr0.min, vr1.max);
|
max = vrp_int_const_binop (code, vr0.max, vr1.min);
|
max = vrp_int_const_binop (code, vr0.max, vr1.min);
|
}
|
}
|
else if (code == BIT_AND_EXPR)
|
else if (code == BIT_AND_EXPR)
|
{
|
{
|
if (vr0.type == VR_RANGE
|
if (vr0.type == VR_RANGE
|
&& vr0.min == vr0.max
|
&& vr0.min == vr0.max
|
&& TREE_CODE (vr0.max) == INTEGER_CST
|
&& TREE_CODE (vr0.max) == INTEGER_CST
|
&& !TREE_OVERFLOW (vr0.max)
|
&& !TREE_OVERFLOW (vr0.max)
|
&& tree_int_cst_sgn (vr0.max) >= 0)
|
&& tree_int_cst_sgn (vr0.max) >= 0)
|
{
|
{
|
min = build_int_cst (TREE_TYPE (expr), 0);
|
min = build_int_cst (TREE_TYPE (expr), 0);
|
max = vr0.max;
|
max = vr0.max;
|
}
|
}
|
else if (vr1.type == VR_RANGE
|
else if (vr1.type == VR_RANGE
|
&& vr1.min == vr1.max
|
&& vr1.min == vr1.max
|
&& TREE_CODE (vr1.max) == INTEGER_CST
|
&& TREE_CODE (vr1.max) == INTEGER_CST
|
&& !TREE_OVERFLOW (vr1.max)
|
&& !TREE_OVERFLOW (vr1.max)
|
&& tree_int_cst_sgn (vr1.max) >= 0)
|
&& tree_int_cst_sgn (vr1.max) >= 0)
|
{
|
{
|
type = VR_RANGE;
|
type = VR_RANGE;
|
min = build_int_cst (TREE_TYPE (expr), 0);
|
min = build_int_cst (TREE_TYPE (expr), 0);
|
max = vr1.max;
|
max = vr1.max;
|
}
|
}
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
|
|
/* If either MIN or MAX overflowed, then set the resulting range to
|
/* If either MIN or MAX overflowed, then set the resulting range to
|
VARYING. But we do accept an overflow infinity
|
VARYING. But we do accept an overflow infinity
|
representation. */
|
representation. */
|
if (min == NULL_TREE
|
if (min == NULL_TREE
|
|| !is_gimple_min_invariant (min)
|
|| !is_gimple_min_invariant (min)
|
|| (TREE_OVERFLOW (min) && !is_overflow_infinity (min))
|
|| (TREE_OVERFLOW (min) && !is_overflow_infinity (min))
|
|| max == NULL_TREE
|
|| max == NULL_TREE
|
|| !is_gimple_min_invariant (max)
|
|| !is_gimple_min_invariant (max)
|
|| (TREE_OVERFLOW (max) && !is_overflow_infinity (max)))
|
|| (TREE_OVERFLOW (max) && !is_overflow_infinity (max)))
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* We punt if:
|
/* We punt if:
|
1) [-INF, +INF]
|
1) [-INF, +INF]
|
2) [-INF, +-INF(OVF)]
|
2) [-INF, +-INF(OVF)]
|
3) [+-INF(OVF), +INF]
|
3) [+-INF(OVF), +INF]
|
4) [+-INF(OVF), +-INF(OVF)]
|
4) [+-INF(OVF), +-INF(OVF)]
|
We learn nothing when we have INF and INF(OVF) on both sides.
|
We learn nothing when we have INF and INF(OVF) on both sides.
|
Note that we do accept [-INF, -INF] and [+INF, +INF] without
|
Note that we do accept [-INF, -INF] and [+INF, +INF] without
|
overflow. */
|
overflow. */
|
if ((vrp_val_is_min (min) || is_overflow_infinity (min))
|
if ((vrp_val_is_min (min) || is_overflow_infinity (min))
|
&& (vrp_val_is_max (max) || is_overflow_infinity (max)))
|
&& (vrp_val_is_max (max) || is_overflow_infinity (max)))
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
cmp = compare_values (min, max);
|
cmp = compare_values (min, max);
|
if (cmp == -2 || cmp == 1)
|
if (cmp == -2 || cmp == 1)
|
{
|
{
|
/* If the new range has its limits swapped around (MIN > MAX),
|
/* If the new range has its limits swapped around (MIN > MAX),
|
then the operation caused one of them to wrap around, mark
|
then the operation caused one of them to wrap around, mark
|
the new range VARYING. */
|
the new range VARYING. */
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
}
|
}
|
else
|
else
|
set_value_range (vr, type, min, max, NULL);
|
set_value_range (vr, type, min, max, NULL);
|
}
|
}
|
|
|
|
|
/* Extract range information from a unary expression EXPR based on
|
/* Extract range information from a unary expression EXPR based on
|
the range of its operand and the expression code. */
|
the range of its operand and the expression code. */
|
|
|
static void
|
static void
|
extract_range_from_unary_expr (value_range_t *vr, tree expr)
|
extract_range_from_unary_expr (value_range_t *vr, tree expr)
|
{
|
{
|
enum tree_code code = TREE_CODE (expr);
|
enum tree_code code = TREE_CODE (expr);
|
tree min, max, op0;
|
tree min, max, op0;
|
int cmp;
|
int cmp;
|
value_range_t vr0 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
|
value_range_t vr0 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
|
|
|
/* Refuse to operate on certain unary expressions for which we
|
/* Refuse to operate on certain unary expressions for which we
|
cannot easily determine a resulting range. */
|
cannot easily determine a resulting range. */
|
if (code == FIX_TRUNC_EXPR
|
if (code == FIX_TRUNC_EXPR
|
|| code == FIX_CEIL_EXPR
|
|| code == FIX_CEIL_EXPR
|
|| code == FIX_FLOOR_EXPR
|
|| code == FIX_FLOOR_EXPR
|
|| code == FIX_ROUND_EXPR
|
|| code == FIX_ROUND_EXPR
|
|| code == FLOAT_EXPR
|
|| code == FLOAT_EXPR
|
|| code == BIT_NOT_EXPR
|
|| code == BIT_NOT_EXPR
|
|| code == NON_LVALUE_EXPR
|
|| code == NON_LVALUE_EXPR
|
|| code == CONJ_EXPR)
|
|| code == CONJ_EXPR)
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* Get value ranges for the operand. For constant operands, create
|
/* Get value ranges for the operand. For constant operands, create
|
a new value range with the operand to simplify processing. */
|
a new value range with the operand to simplify processing. */
|
op0 = TREE_OPERAND (expr, 0);
|
op0 = TREE_OPERAND (expr, 0);
|
if (TREE_CODE (op0) == SSA_NAME)
|
if (TREE_CODE (op0) == SSA_NAME)
|
vr0 = *(get_value_range (op0));
|
vr0 = *(get_value_range (op0));
|
else if (is_gimple_min_invariant (op0))
|
else if (is_gimple_min_invariant (op0))
|
set_value_range_to_value (&vr0, op0, NULL);
|
set_value_range_to_value (&vr0, op0, NULL);
|
else
|
else
|
set_value_range_to_varying (&vr0);
|
set_value_range_to_varying (&vr0);
|
|
|
/* If VR0 is UNDEFINED, so is the result. */
|
/* If VR0 is UNDEFINED, so is the result. */
|
if (vr0.type == VR_UNDEFINED)
|
if (vr0.type == VR_UNDEFINED)
|
{
|
{
|
set_value_range_to_undefined (vr);
|
set_value_range_to_undefined (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* Refuse to operate on symbolic ranges, or if neither operand is
|
/* Refuse to operate on symbolic ranges, or if neither operand is
|
a pointer or integral type. */
|
a pointer or integral type. */
|
if ((!INTEGRAL_TYPE_P (TREE_TYPE (op0))
|
if ((!INTEGRAL_TYPE_P (TREE_TYPE (op0))
|
&& !POINTER_TYPE_P (TREE_TYPE (op0)))
|
&& !POINTER_TYPE_P (TREE_TYPE (op0)))
|
|| (vr0.type != VR_VARYING
|
|| (vr0.type != VR_VARYING
|
&& symbolic_range_p (&vr0)))
|
&& symbolic_range_p (&vr0)))
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* If the expression involves pointers, we are only interested in
|
/* If the expression involves pointers, we are only interested in
|
determining if it evaluates to NULL [0, 0] or non-NULL (~[0, 0]). */
|
determining if it evaluates to NULL [0, 0] or non-NULL (~[0, 0]). */
|
if (POINTER_TYPE_P (TREE_TYPE (expr)) || POINTER_TYPE_P (TREE_TYPE (op0)))
|
if (POINTER_TYPE_P (TREE_TYPE (expr)) || POINTER_TYPE_P (TREE_TYPE (op0)))
|
{
|
{
|
bool sop;
|
bool sop;
|
|
|
sop = false;
|
sop = false;
|
if (range_is_nonnull (&vr0)
|
if (range_is_nonnull (&vr0)
|
|| (tree_expr_nonzero_warnv_p (expr, &sop)
|
|| (tree_expr_nonzero_warnv_p (expr, &sop)
|
&& !sop))
|
&& !sop))
|
set_value_range_to_nonnull (vr, TREE_TYPE (expr));
|
set_value_range_to_nonnull (vr, TREE_TYPE (expr));
|
else if (range_is_null (&vr0))
|
else if (range_is_null (&vr0))
|
set_value_range_to_null (vr, TREE_TYPE (expr));
|
set_value_range_to_null (vr, TREE_TYPE (expr));
|
else
|
else
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
|
|
return;
|
return;
|
}
|
}
|
|
|
/* Handle unary expressions on integer ranges. */
|
/* Handle unary expressions on integer ranges. */
|
if (code == NOP_EXPR || code == CONVERT_EXPR)
|
if (code == NOP_EXPR || code == CONVERT_EXPR)
|
{
|
{
|
tree inner_type = TREE_TYPE (op0);
|
tree inner_type = TREE_TYPE (op0);
|
tree outer_type = TREE_TYPE (expr);
|
tree outer_type = TREE_TYPE (expr);
|
|
|
/* If VR0 represents a simple range, then try to convert
|
/* If VR0 represents a simple range, then try to convert
|
the min and max values for the range to the same type
|
the min and max values for the range to the same type
|
as OUTER_TYPE. If the results compare equal to VR0's
|
as OUTER_TYPE. If the results compare equal to VR0's
|
min and max values and the new min is still less than
|
min and max values and the new min is still less than
|
or equal to the new max, then we can safely use the newly
|
or equal to the new max, then we can safely use the newly
|
computed range for EXPR. This allows us to compute
|
computed range for EXPR. This allows us to compute
|
accurate ranges through many casts. */
|
accurate ranges through many casts. */
|
if ((vr0.type == VR_RANGE
|
if ((vr0.type == VR_RANGE
|
&& !overflow_infinity_range_p (&vr0))
|
&& !overflow_infinity_range_p (&vr0))
|
|| (vr0.type == VR_VARYING
|
|| (vr0.type == VR_VARYING
|
&& TYPE_PRECISION (outer_type) > TYPE_PRECISION (inner_type)))
|
&& TYPE_PRECISION (outer_type) > TYPE_PRECISION (inner_type)))
|
{
|
{
|
tree new_min, new_max, orig_min, orig_max;
|
tree new_min, new_max, orig_min, orig_max;
|
|
|
/* Convert the input operand min/max to OUTER_TYPE. If
|
/* Convert the input operand min/max to OUTER_TYPE. If
|
the input has no range information, then use the min/max
|
the input has no range information, then use the min/max
|
for the input's type. */
|
for the input's type. */
|
if (vr0.type == VR_RANGE)
|
if (vr0.type == VR_RANGE)
|
{
|
{
|
orig_min = vr0.min;
|
orig_min = vr0.min;
|
orig_max = vr0.max;
|
orig_max = vr0.max;
|
}
|
}
|
else
|
else
|
{
|
{
|
orig_min = TYPE_MIN_VALUE (inner_type);
|
orig_min = TYPE_MIN_VALUE (inner_type);
|
orig_max = TYPE_MAX_VALUE (inner_type);
|
orig_max = TYPE_MAX_VALUE (inner_type);
|
}
|
}
|
|
|
new_min = fold_convert (outer_type, orig_min);
|
new_min = fold_convert (outer_type, orig_min);
|
new_max = fold_convert (outer_type, orig_max);
|
new_max = fold_convert (outer_type, orig_max);
|
|
|
/* Verify the new min/max values are gimple values and
|
/* Verify the new min/max values are gimple values and
|
that they compare equal to the original input's
|
that they compare equal to the original input's
|
min/max values. */
|
min/max values. */
|
if (is_gimple_val (new_min)
|
if (is_gimple_val (new_min)
|
&& is_gimple_val (new_max)
|
&& is_gimple_val (new_max)
|
&& tree_int_cst_equal (new_min, orig_min)
|
&& tree_int_cst_equal (new_min, orig_min)
|
&& tree_int_cst_equal (new_max, orig_max)
|
&& tree_int_cst_equal (new_max, orig_max)
|
&& (!is_overflow_infinity (new_min)
|
&& (!is_overflow_infinity (new_min)
|
|| !is_overflow_infinity (new_max))
|
|| !is_overflow_infinity (new_max))
|
&& compare_values (new_min, new_max) <= 0
|
&& compare_values (new_min, new_max) <= 0
|
&& compare_values (new_min, new_max) >= -1)
|
&& compare_values (new_min, new_max) >= -1)
|
{
|
{
|
set_value_range (vr, VR_RANGE, new_min, new_max, vr->equiv);
|
set_value_range (vr, VR_RANGE, new_min, new_max, vr->equiv);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
/* When converting types of different sizes, set the result to
|
/* When converting types of different sizes, set the result to
|
VARYING. Things like sign extensions and precision loss may
|
VARYING. Things like sign extensions and precision loss may
|
change the range. For instance, if x_3 is of type 'long long
|
change the range. For instance, if x_3 is of type 'long long
|
int' and 'y_5 = (unsigned short) x_3', if x_3 is ~[0, 0], it
|
int' and 'y_5 = (unsigned short) x_3', if x_3 is ~[0, 0], it
|
is impossible to know at compile time whether y_5 will be
|
is impossible to know at compile time whether y_5 will be
|
~[0, 0]. */
|
~[0, 0]. */
|
if (TYPE_SIZE (inner_type) != TYPE_SIZE (outer_type)
|
if (TYPE_SIZE (inner_type) != TYPE_SIZE (outer_type)
|
|| TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
|
|| TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
/* Conversion of a VR_VARYING value to a wider type can result
|
/* Conversion of a VR_VARYING value to a wider type can result
|
in a usable range. So wait until after we've handled conversions
|
in a usable range. So wait until after we've handled conversions
|
before dropping the result to VR_VARYING if we had a source
|
before dropping the result to VR_VARYING if we had a source
|
operand that is VR_VARYING. */
|
operand that is VR_VARYING. */
|
if (vr0.type == VR_VARYING)
|
if (vr0.type == VR_VARYING)
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* Apply the operation to each end of the range and see what we end
|
/* Apply the operation to each end of the range and see what we end
|
up with. */
|
up with. */
|
if (code == NEGATE_EXPR
|
if (code == NEGATE_EXPR
|
&& !TYPE_UNSIGNED (TREE_TYPE (expr)))
|
&& !TYPE_UNSIGNED (TREE_TYPE (expr)))
|
{
|
{
|
/* NEGATE_EXPR flips the range around. We need to treat
|
/* NEGATE_EXPR flips the range around. We need to treat
|
TYPE_MIN_VALUE specially. */
|
TYPE_MIN_VALUE specially. */
|
if (is_positive_overflow_infinity (vr0.max))
|
if (is_positive_overflow_infinity (vr0.max))
|
min = negative_overflow_infinity (TREE_TYPE (expr));
|
min = negative_overflow_infinity (TREE_TYPE (expr));
|
else if (is_negative_overflow_infinity (vr0.max))
|
else if (is_negative_overflow_infinity (vr0.max))
|
min = positive_overflow_infinity (TREE_TYPE (expr));
|
min = positive_overflow_infinity (TREE_TYPE (expr));
|
else if (!vrp_val_is_min (vr0.max))
|
else if (!vrp_val_is_min (vr0.max))
|
min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max);
|
min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max);
|
else if (needs_overflow_infinity (TREE_TYPE (expr)))
|
else if (needs_overflow_infinity (TREE_TYPE (expr)))
|
{
|
{
|
if (supports_overflow_infinity (TREE_TYPE (expr))
|
if (supports_overflow_infinity (TREE_TYPE (expr))
|
&& !is_overflow_infinity (vr0.min)
|
&& !is_overflow_infinity (vr0.min)
|
&& !vrp_val_is_min (vr0.min))
|
&& !vrp_val_is_min (vr0.min))
|
min = positive_overflow_infinity (TREE_TYPE (expr));
|
min = positive_overflow_infinity (TREE_TYPE (expr));
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
else
|
else
|
min = TYPE_MIN_VALUE (TREE_TYPE (expr));
|
min = TYPE_MIN_VALUE (TREE_TYPE (expr));
|
|
|
if (is_positive_overflow_infinity (vr0.min))
|
if (is_positive_overflow_infinity (vr0.min))
|
max = negative_overflow_infinity (TREE_TYPE (expr));
|
max = negative_overflow_infinity (TREE_TYPE (expr));
|
else if (is_negative_overflow_infinity (vr0.min))
|
else if (is_negative_overflow_infinity (vr0.min))
|
max = positive_overflow_infinity (TREE_TYPE (expr));
|
max = positive_overflow_infinity (TREE_TYPE (expr));
|
else if (!vrp_val_is_min (vr0.min))
|
else if (!vrp_val_is_min (vr0.min))
|
max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min);
|
max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min);
|
else if (needs_overflow_infinity (TREE_TYPE (expr)))
|
else if (needs_overflow_infinity (TREE_TYPE (expr)))
|
{
|
{
|
if (supports_overflow_infinity (TREE_TYPE (expr)))
|
if (supports_overflow_infinity (TREE_TYPE (expr)))
|
max = positive_overflow_infinity (TREE_TYPE (expr));
|
max = positive_overflow_infinity (TREE_TYPE (expr));
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
else
|
else
|
max = TYPE_MIN_VALUE (TREE_TYPE (expr));
|
max = TYPE_MIN_VALUE (TREE_TYPE (expr));
|
}
|
}
|
else if (code == NEGATE_EXPR
|
else if (code == NEGATE_EXPR
|
&& TYPE_UNSIGNED (TREE_TYPE (expr)))
|
&& TYPE_UNSIGNED (TREE_TYPE (expr)))
|
{
|
{
|
if (!range_includes_zero_p (&vr0))
|
if (!range_includes_zero_p (&vr0))
|
{
|
{
|
max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min);
|
max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min);
|
min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max);
|
min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (range_is_null (&vr0))
|
if (range_is_null (&vr0))
|
set_value_range_to_null (vr, TREE_TYPE (expr));
|
set_value_range_to_null (vr, TREE_TYPE (expr));
|
else
|
else
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
else if (code == ABS_EXPR
|
else if (code == ABS_EXPR
|
&& !TYPE_UNSIGNED (TREE_TYPE (expr)))
|
&& !TYPE_UNSIGNED (TREE_TYPE (expr)))
|
{
|
{
|
/* -TYPE_MIN_VALUE = TYPE_MIN_VALUE with flag_wrapv so we can't get a
|
/* -TYPE_MIN_VALUE = TYPE_MIN_VALUE with flag_wrapv so we can't get a
|
useful range. */
|
useful range. */
|
if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (expr))
|
if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (expr))
|
&& ((vr0.type == VR_RANGE
|
&& ((vr0.type == VR_RANGE
|
&& vrp_val_is_min (vr0.min))
|
&& vrp_val_is_min (vr0.min))
|
|| (vr0.type == VR_ANTI_RANGE
|
|| (vr0.type == VR_ANTI_RANGE
|
&& !vrp_val_is_min (vr0.min)
|
&& !vrp_val_is_min (vr0.min)
|
&& !range_includes_zero_p (&vr0))))
|
&& !range_includes_zero_p (&vr0))))
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
/* ABS_EXPR may flip the range around, if the original range
|
/* ABS_EXPR may flip the range around, if the original range
|
included negative values. */
|
included negative values. */
|
if (is_overflow_infinity (vr0.min))
|
if (is_overflow_infinity (vr0.min))
|
min = positive_overflow_infinity (TREE_TYPE (expr));
|
min = positive_overflow_infinity (TREE_TYPE (expr));
|
else if (!vrp_val_is_min (vr0.min))
|
else if (!vrp_val_is_min (vr0.min))
|
min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min);
|
min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min);
|
else if (!needs_overflow_infinity (TREE_TYPE (expr)))
|
else if (!needs_overflow_infinity (TREE_TYPE (expr)))
|
min = TYPE_MAX_VALUE (TREE_TYPE (expr));
|
min = TYPE_MAX_VALUE (TREE_TYPE (expr));
|
else if (supports_overflow_infinity (TREE_TYPE (expr)))
|
else if (supports_overflow_infinity (TREE_TYPE (expr)))
|
min = positive_overflow_infinity (TREE_TYPE (expr));
|
min = positive_overflow_infinity (TREE_TYPE (expr));
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
if (is_overflow_infinity (vr0.max))
|
if (is_overflow_infinity (vr0.max))
|
max = positive_overflow_infinity (TREE_TYPE (expr));
|
max = positive_overflow_infinity (TREE_TYPE (expr));
|
else if (!vrp_val_is_min (vr0.max))
|
else if (!vrp_val_is_min (vr0.max))
|
max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max);
|
max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max);
|
else if (!needs_overflow_infinity (TREE_TYPE (expr)))
|
else if (!needs_overflow_infinity (TREE_TYPE (expr)))
|
max = TYPE_MAX_VALUE (TREE_TYPE (expr));
|
max = TYPE_MAX_VALUE (TREE_TYPE (expr));
|
else if (supports_overflow_infinity (TREE_TYPE (expr)))
|
else if (supports_overflow_infinity (TREE_TYPE (expr)))
|
max = positive_overflow_infinity (TREE_TYPE (expr));
|
max = positive_overflow_infinity (TREE_TYPE (expr));
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
cmp = compare_values (min, max);
|
cmp = compare_values (min, max);
|
|
|
/* If a VR_ANTI_RANGEs contains zero, then we have
|
/* If a VR_ANTI_RANGEs contains zero, then we have
|
~[-INF, min(MIN, MAX)]. */
|
~[-INF, min(MIN, MAX)]. */
|
if (vr0.type == VR_ANTI_RANGE)
|
if (vr0.type == VR_ANTI_RANGE)
|
{
|
{
|
if (range_includes_zero_p (&vr0))
|
if (range_includes_zero_p (&vr0))
|
{
|
{
|
/* Take the lower of the two values. */
|
/* Take the lower of the two values. */
|
if (cmp != 1)
|
if (cmp != 1)
|
max = min;
|
max = min;
|
|
|
/* Create ~[-INF, min (abs(MIN), abs(MAX))]
|
/* Create ~[-INF, min (abs(MIN), abs(MAX))]
|
or ~[-INF + 1, min (abs(MIN), abs(MAX))] when
|
or ~[-INF + 1, min (abs(MIN), abs(MAX))] when
|
flag_wrapv is set and the original anti-range doesn't include
|
flag_wrapv is set and the original anti-range doesn't include
|
TYPE_MIN_VALUE, remember -TYPE_MIN_VALUE = TYPE_MIN_VALUE. */
|
TYPE_MIN_VALUE, remember -TYPE_MIN_VALUE = TYPE_MIN_VALUE. */
|
if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (expr)))
|
if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (expr)))
|
{
|
{
|
tree type_min_value = TYPE_MIN_VALUE (TREE_TYPE (expr));
|
tree type_min_value = TYPE_MIN_VALUE (TREE_TYPE (expr));
|
|
|
min = (vr0.min != type_min_value
|
min = (vr0.min != type_min_value
|
? int_const_binop (PLUS_EXPR, type_min_value,
|
? int_const_binop (PLUS_EXPR, type_min_value,
|
integer_one_node, 0)
|
integer_one_node, 0)
|
: type_min_value);
|
: type_min_value);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (overflow_infinity_range_p (&vr0))
|
if (overflow_infinity_range_p (&vr0))
|
min = negative_overflow_infinity (TREE_TYPE (expr));
|
min = negative_overflow_infinity (TREE_TYPE (expr));
|
else
|
else
|
min = TYPE_MIN_VALUE (TREE_TYPE (expr));
|
min = TYPE_MIN_VALUE (TREE_TYPE (expr));
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* All else has failed, so create the range [0, INF], even for
|
/* All else has failed, so create the range [0, INF], even for
|
flag_wrapv since TYPE_MIN_VALUE is in the original
|
flag_wrapv since TYPE_MIN_VALUE is in the original
|
anti-range. */
|
anti-range. */
|
vr0.type = VR_RANGE;
|
vr0.type = VR_RANGE;
|
min = build_int_cst (TREE_TYPE (expr), 0);
|
min = build_int_cst (TREE_TYPE (expr), 0);
|
if (needs_overflow_infinity (TREE_TYPE (expr)))
|
if (needs_overflow_infinity (TREE_TYPE (expr)))
|
{
|
{
|
if (supports_overflow_infinity (TREE_TYPE (expr)))
|
if (supports_overflow_infinity (TREE_TYPE (expr)))
|
max = positive_overflow_infinity (TREE_TYPE (expr));
|
max = positive_overflow_infinity (TREE_TYPE (expr));
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
else
|
else
|
max = TYPE_MAX_VALUE (TREE_TYPE (expr));
|
max = TYPE_MAX_VALUE (TREE_TYPE (expr));
|
}
|
}
|
}
|
}
|
|
|
/* If the range contains zero then we know that the minimum value in the
|
/* If the range contains zero then we know that the minimum value in the
|
range will be zero. */
|
range will be zero. */
|
else if (range_includes_zero_p (&vr0))
|
else if (range_includes_zero_p (&vr0))
|
{
|
{
|
if (cmp == 1)
|
if (cmp == 1)
|
max = min;
|
max = min;
|
min = build_int_cst (TREE_TYPE (expr), 0);
|
min = build_int_cst (TREE_TYPE (expr), 0);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* If the range was reversed, swap MIN and MAX. */
|
/* If the range was reversed, swap MIN and MAX. */
|
if (cmp == 1)
|
if (cmp == 1)
|
{
|
{
|
tree t = min;
|
tree t = min;
|
min = max;
|
min = max;
|
max = t;
|
max = t;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Otherwise, operate on each end of the range. */
|
/* Otherwise, operate on each end of the range. */
|
min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min);
|
min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min);
|
max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max);
|
max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max);
|
|
|
if (needs_overflow_infinity (TREE_TYPE (expr)))
|
if (needs_overflow_infinity (TREE_TYPE (expr)))
|
{
|
{
|
gcc_assert (code != NEGATE_EXPR && code != ABS_EXPR);
|
gcc_assert (code != NEGATE_EXPR && code != ABS_EXPR);
|
|
|
/* If both sides have overflowed, we don't know
|
/* If both sides have overflowed, we don't know
|
anything. */
|
anything. */
|
if ((is_overflow_infinity (vr0.min)
|
if ((is_overflow_infinity (vr0.min)
|
|| TREE_OVERFLOW (min))
|
|| TREE_OVERFLOW (min))
|
&& (is_overflow_infinity (vr0.max)
|
&& (is_overflow_infinity (vr0.max)
|
|| TREE_OVERFLOW (max)))
|
|| TREE_OVERFLOW (max)))
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
|
|
if (is_overflow_infinity (vr0.min))
|
if (is_overflow_infinity (vr0.min))
|
min = vr0.min;
|
min = vr0.min;
|
else if (TREE_OVERFLOW (min))
|
else if (TREE_OVERFLOW (min))
|
{
|
{
|
if (supports_overflow_infinity (TREE_TYPE (expr)))
|
if (supports_overflow_infinity (TREE_TYPE (expr)))
|
min = (tree_int_cst_sgn (min) >= 0
|
min = (tree_int_cst_sgn (min) >= 0
|
? positive_overflow_infinity (TREE_TYPE (min))
|
? positive_overflow_infinity (TREE_TYPE (min))
|
: negative_overflow_infinity (TREE_TYPE (min)));
|
: negative_overflow_infinity (TREE_TYPE (min)));
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
if (is_overflow_infinity (vr0.max))
|
if (is_overflow_infinity (vr0.max))
|
max = vr0.max;
|
max = vr0.max;
|
else if (TREE_OVERFLOW (max))
|
else if (TREE_OVERFLOW (max))
|
{
|
{
|
if (supports_overflow_infinity (TREE_TYPE (expr)))
|
if (supports_overflow_infinity (TREE_TYPE (expr)))
|
max = (tree_int_cst_sgn (max) >= 0
|
max = (tree_int_cst_sgn (max) >= 0
|
? positive_overflow_infinity (TREE_TYPE (max))
|
? positive_overflow_infinity (TREE_TYPE (max))
|
: negative_overflow_infinity (TREE_TYPE (max)));
|
: negative_overflow_infinity (TREE_TYPE (max)));
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
cmp = compare_values (min, max);
|
cmp = compare_values (min, max);
|
if (cmp == -2 || cmp == 1)
|
if (cmp == -2 || cmp == 1)
|
{
|
{
|
/* If the new range has its limits swapped around (MIN > MAX),
|
/* If the new range has its limits swapped around (MIN > MAX),
|
then the operation caused one of them to wrap around, mark
|
then the operation caused one of them to wrap around, mark
|
the new range VARYING. */
|
the new range VARYING. */
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
}
|
}
|
else
|
else
|
set_value_range (vr, vr0.type, min, max, NULL);
|
set_value_range (vr, vr0.type, min, max, NULL);
|
}
|
}
|
|
|
|
|
/* Extract range information from a comparison expression EXPR based
|
/* Extract range information from a comparison expression EXPR based
|
on the range of its operand and the expression code. */
|
on the range of its operand and the expression code. */
|
|
|
static void
|
static void
|
extract_range_from_comparison (value_range_t *vr, tree expr)
|
extract_range_from_comparison (value_range_t *vr, tree expr)
|
{
|
{
|
bool sop = false;
|
bool sop = false;
|
tree val = vrp_evaluate_conditional_warnv (expr, false, &sop);
|
tree val = vrp_evaluate_conditional_warnv (expr, false, &sop);
|
|
|
/* A disadvantage of using a special infinity as an overflow
|
/* A disadvantage of using a special infinity as an overflow
|
representation is that we lose the ability to record overflow
|
representation is that we lose the ability to record overflow
|
when we don't have an infinity. So we have to ignore a result
|
when we don't have an infinity. So we have to ignore a result
|
which relies on overflow. */
|
which relies on overflow. */
|
|
|
if (val && !is_overflow_infinity (val) && !sop)
|
if (val && !is_overflow_infinity (val) && !sop)
|
{
|
{
|
/* Since this expression was found on the RHS of an assignment,
|
/* Since this expression was found on the RHS of an assignment,
|
its type may be different from _Bool. Convert VAL to EXPR's
|
its type may be different from _Bool. Convert VAL to EXPR's
|
type. */
|
type. */
|
val = fold_convert (TREE_TYPE (expr), val);
|
val = fold_convert (TREE_TYPE (expr), val);
|
if (is_gimple_min_invariant (val))
|
if (is_gimple_min_invariant (val))
|
set_value_range_to_value (vr, val, vr->equiv);
|
set_value_range_to_value (vr, val, vr->equiv);
|
else
|
else
|
set_value_range (vr, VR_RANGE, val, val, vr->equiv);
|
set_value_range (vr, VR_RANGE, val, val, vr->equiv);
|
}
|
}
|
else
|
else
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
}
|
}
|
|
|
|
|
/* Try to compute a useful range out of expression EXPR and store it
|
/* Try to compute a useful range out of expression EXPR and store it
|
in *VR. */
|
in *VR. */
|
|
|
static void
|
static void
|
extract_range_from_expr (value_range_t *vr, tree expr)
|
extract_range_from_expr (value_range_t *vr, tree expr)
|
{
|
{
|
enum tree_code code = TREE_CODE (expr);
|
enum tree_code code = TREE_CODE (expr);
|
|
|
if (code == ASSERT_EXPR)
|
if (code == ASSERT_EXPR)
|
extract_range_from_assert (vr, expr);
|
extract_range_from_assert (vr, expr);
|
else if (code == SSA_NAME)
|
else if (code == SSA_NAME)
|
extract_range_from_ssa_name (vr, expr);
|
extract_range_from_ssa_name (vr, expr);
|
else if (TREE_CODE_CLASS (code) == tcc_binary
|
else if (TREE_CODE_CLASS (code) == tcc_binary
|
|| code == TRUTH_ANDIF_EXPR
|
|| code == TRUTH_ANDIF_EXPR
|
|| code == TRUTH_ORIF_EXPR
|
|| code == TRUTH_ORIF_EXPR
|
|| code == TRUTH_AND_EXPR
|
|| code == TRUTH_AND_EXPR
|
|| code == TRUTH_OR_EXPR
|
|| code == TRUTH_OR_EXPR
|
|| code == TRUTH_XOR_EXPR)
|
|| code == TRUTH_XOR_EXPR)
|
extract_range_from_binary_expr (vr, expr);
|
extract_range_from_binary_expr (vr, expr);
|
else if (TREE_CODE_CLASS (code) == tcc_unary)
|
else if (TREE_CODE_CLASS (code) == tcc_unary)
|
extract_range_from_unary_expr (vr, expr);
|
extract_range_from_unary_expr (vr, expr);
|
else if (TREE_CODE_CLASS (code) == tcc_comparison)
|
else if (TREE_CODE_CLASS (code) == tcc_comparison)
|
extract_range_from_comparison (vr, expr);
|
extract_range_from_comparison (vr, expr);
|
else if (is_gimple_min_invariant (expr))
|
else if (is_gimple_min_invariant (expr))
|
set_value_range_to_value (vr, expr, NULL);
|
set_value_range_to_value (vr, expr, NULL);
|
else
|
else
|
set_value_range_to_varying (vr);
|
set_value_range_to_varying (vr);
|
|
|
/* If we got a varying range from the tests above, try a final
|
/* If we got a varying range from the tests above, try a final
|
time to derive a nonnegative or nonzero range. This time
|
time to derive a nonnegative or nonzero range. This time
|
relying primarily on generic routines in fold in conjunction
|
relying primarily on generic routines in fold in conjunction
|
with range data. */
|
with range data. */
|
if (vr->type == VR_VARYING)
|
if (vr->type == VR_VARYING)
|
{
|
{
|
bool sop = false;
|
bool sop = false;
|
|
|
if (INTEGRAL_TYPE_P (TREE_TYPE (expr))
|
if (INTEGRAL_TYPE_P (TREE_TYPE (expr))
|
&& vrp_expr_computes_nonnegative (expr, &sop))
|
&& vrp_expr_computes_nonnegative (expr, &sop))
|
set_value_range_to_nonnegative (vr, TREE_TYPE (expr),
|
set_value_range_to_nonnegative (vr, TREE_TYPE (expr),
|
sop || is_overflow_infinity (expr));
|
sop || is_overflow_infinity (expr));
|
else if (vrp_expr_computes_nonzero (expr, &sop)
|
else if (vrp_expr_computes_nonzero (expr, &sop)
|
&& !sop)
|
&& !sop)
|
set_value_range_to_nonnull (vr, TREE_TYPE (expr));
|
set_value_range_to_nonnull (vr, TREE_TYPE (expr));
|
}
|
}
|
}
|
}
|
|
|
/* Given a range VR, a LOOP and a variable VAR, determine whether it
|
/* Given a range VR, a LOOP and a variable VAR, determine whether it
|
would be profitable to adjust VR using scalar evolution information
|
would be profitable to adjust VR using scalar evolution information
|
for VAR. If so, update VR with the new limits. */
|
for VAR. If so, update VR with the new limits. */
|
|
|
static void
|
static void
|
adjust_range_with_scev (value_range_t *vr, struct loop *loop, tree stmt,
|
adjust_range_with_scev (value_range_t *vr, struct loop *loop, tree stmt,
|
tree var)
|
tree var)
|
{
|
{
|
tree init, step, chrec, tmin, tmax, min, max, type;
|
tree init, step, chrec, tmin, tmax, min, max, type;
|
enum ev_direction dir;
|
enum ev_direction dir;
|
|
|
/* TODO. Don't adjust anti-ranges. An anti-range may provide
|
/* TODO. Don't adjust anti-ranges. An anti-range may provide
|
better opportunities than a regular range, but I'm not sure. */
|
better opportunities than a regular range, but I'm not sure. */
|
if (vr->type == VR_ANTI_RANGE)
|
if (vr->type == VR_ANTI_RANGE)
|
return;
|
return;
|
|
|
chrec = instantiate_parameters (loop, analyze_scalar_evolution (loop, var));
|
chrec = instantiate_parameters (loop, analyze_scalar_evolution (loop, var));
|
if (TREE_CODE (chrec) != POLYNOMIAL_CHREC)
|
if (TREE_CODE (chrec) != POLYNOMIAL_CHREC)
|
return;
|
return;
|
|
|
init = initial_condition_in_loop_num (chrec, loop->num);
|
init = initial_condition_in_loop_num (chrec, loop->num);
|
step = evolution_part_in_loop_num (chrec, loop->num);
|
step = evolution_part_in_loop_num (chrec, loop->num);
|
|
|
/* If STEP is symbolic, we can't know whether INIT will be the
|
/* If STEP is symbolic, we can't know whether INIT will be the
|
minimum or maximum value in the range. Also, unless INIT is
|
minimum or maximum value in the range. Also, unless INIT is
|
a simple expression, compare_values and possibly other functions
|
a simple expression, compare_values and possibly other functions
|
in tree-vrp won't be able to handle it. */
|
in tree-vrp won't be able to handle it. */
|
if (step == NULL_TREE
|
if (step == NULL_TREE
|
|| !is_gimple_min_invariant (step)
|
|| !is_gimple_min_invariant (step)
|
|| !valid_value_p (init))
|
|| !valid_value_p (init))
|
return;
|
return;
|
|
|
dir = scev_direction (chrec);
|
dir = scev_direction (chrec);
|
if (/* Do not adjust ranges if we do not know whether the iv increases
|
if (/* Do not adjust ranges if we do not know whether the iv increases
|
or decreases, ... */
|
or decreases, ... */
|
dir == EV_DIR_UNKNOWN
|
dir == EV_DIR_UNKNOWN
|
/* ... or if it may wrap. */
|
/* ... or if it may wrap. */
|
|| scev_probably_wraps_p (init, step, stmt,
|
|| scev_probably_wraps_p (init, step, stmt,
|
current_loops->parray[CHREC_VARIABLE (chrec)],
|
current_loops->parray[CHREC_VARIABLE (chrec)],
|
true))
|
true))
|
return;
|
return;
|
|
|
/* We use TYPE_MIN_VALUE and TYPE_MAX_VALUE here instead of
|
/* We use TYPE_MIN_VALUE and TYPE_MAX_VALUE here instead of
|
negative_overflow_infinity and positive_overflow_infinity,
|
negative_overflow_infinity and positive_overflow_infinity,
|
because we have concluded that the loop probably does not
|
because we have concluded that the loop probably does not
|
wrap. */
|
wrap. */
|
|
|
type = TREE_TYPE (var);
|
type = TREE_TYPE (var);
|
if (POINTER_TYPE_P (type) || !TYPE_MIN_VALUE (type))
|
if (POINTER_TYPE_P (type) || !TYPE_MIN_VALUE (type))
|
tmin = lower_bound_in_type (type, type);
|
tmin = lower_bound_in_type (type, type);
|
else
|
else
|
tmin = TYPE_MIN_VALUE (type);
|
tmin = TYPE_MIN_VALUE (type);
|
if (POINTER_TYPE_P (type) || !TYPE_MAX_VALUE (type))
|
if (POINTER_TYPE_P (type) || !TYPE_MAX_VALUE (type))
|
tmax = upper_bound_in_type (type, type);
|
tmax = upper_bound_in_type (type, type);
|
else
|
else
|
tmax = TYPE_MAX_VALUE (type);
|
tmax = TYPE_MAX_VALUE (type);
|
|
|
if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED)
|
if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED)
|
{
|
{
|
min = tmin;
|
min = tmin;
|
max = tmax;
|
max = tmax;
|
|
|
/* For VARYING or UNDEFINED ranges, just about anything we get
|
/* For VARYING or UNDEFINED ranges, just about anything we get
|
from scalar evolutions should be better. */
|
from scalar evolutions should be better. */
|
|
|
if (dir == EV_DIR_DECREASES)
|
if (dir == EV_DIR_DECREASES)
|
max = init;
|
max = init;
|
else
|
else
|
min = init;
|
min = init;
|
|
|
/* If we would create an invalid range, then just assume we
|
/* If we would create an invalid range, then just assume we
|
know absolutely nothing. This may be over-conservative,
|
know absolutely nothing. This may be over-conservative,
|
but it's clearly safe, and should happen only in unreachable
|
but it's clearly safe, and should happen only in unreachable
|
parts of code, or for invalid programs. */
|
parts of code, or for invalid programs. */
|
if (compare_values (min, max) == 1)
|
if (compare_values (min, max) == 1)
|
return;
|
return;
|
|
|
set_value_range (vr, VR_RANGE, min, max, vr->equiv);
|
set_value_range (vr, VR_RANGE, min, max, vr->equiv);
|
}
|
}
|
else if (vr->type == VR_RANGE)
|
else if (vr->type == VR_RANGE)
|
{
|
{
|
min = vr->min;
|
min = vr->min;
|
max = vr->max;
|
max = vr->max;
|
|
|
if (dir == EV_DIR_DECREASES)
|
if (dir == EV_DIR_DECREASES)
|
{
|
{
|
/* INIT is the maximum value. If INIT is lower than VR->MAX
|
/* INIT is the maximum value. If INIT is lower than VR->MAX
|
but no smaller than VR->MIN, set VR->MAX to INIT. */
|
but no smaller than VR->MIN, set VR->MAX to INIT. */
|
if (compare_values (init, max) == -1)
|
if (compare_values (init, max) == -1)
|
{
|
{
|
max = init;
|
max = init;
|
|
|
/* If we just created an invalid range with the minimum
|
/* If we just created an invalid range with the minimum
|
greater than the maximum, we fail conservatively.
|
greater than the maximum, we fail conservatively.
|
This should happen only in unreachable
|
This should happen only in unreachable
|
parts of code, or for invalid programs. */
|
parts of code, or for invalid programs. */
|
if (compare_values (min, max) == 1)
|
if (compare_values (min, max) == 1)
|
return;
|
return;
|
}
|
}
|
|
|
/* According to the loop information, the variable does not
|
/* According to the loop information, the variable does not
|
overflow. If we think it does, probably because of an
|
overflow. If we think it does, probably because of an
|
overflow due to arithmetic on a different INF value,
|
overflow due to arithmetic on a different INF value,
|
reset now. */
|
reset now. */
|
if (is_negative_overflow_infinity (min))
|
if (is_negative_overflow_infinity (min))
|
min = tmin;
|
min = tmin;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* If INIT is bigger than VR->MIN, set VR->MIN to INIT. */
|
/* If INIT is bigger than VR->MIN, set VR->MIN to INIT. */
|
if (compare_values (init, min) == 1)
|
if (compare_values (init, min) == 1)
|
{
|
{
|
min = init;
|
min = init;
|
|
|
/* Again, avoid creating invalid range by failing. */
|
/* Again, avoid creating invalid range by failing. */
|
if (compare_values (min, max) == 1)
|
if (compare_values (min, max) == 1)
|
return;
|
return;
|
}
|
}
|
|
|
if (is_positive_overflow_infinity (max))
|
if (is_positive_overflow_infinity (max))
|
max = tmax;
|
max = tmax;
|
}
|
}
|
|
|
set_value_range (vr, VR_RANGE, min, max, vr->equiv);
|
set_value_range (vr, VR_RANGE, min, max, vr->equiv);
|
}
|
}
|
}
|
}
|
|
|
/* Return true if VAR may overflow at STMT. This checks any available
|
/* Return true if VAR may overflow at STMT. This checks any available
|
loop information to see if we can determine that VAR does not
|
loop information to see if we can determine that VAR does not
|
overflow. */
|
overflow. */
|
|
|
static bool
|
static bool
|
vrp_var_may_overflow (tree var, tree stmt)
|
vrp_var_may_overflow (tree var, tree stmt)
|
{
|
{
|
struct loop *l;
|
struct loop *l;
|
tree chrec, init, step;
|
tree chrec, init, step;
|
|
|
if (current_loops == NULL)
|
if (current_loops == NULL)
|
return true;
|
return true;
|
|
|
l = loop_containing_stmt (stmt);
|
l = loop_containing_stmt (stmt);
|
if (l == NULL)
|
if (l == NULL)
|
return true;
|
return true;
|
|
|
chrec = instantiate_parameters (l, analyze_scalar_evolution (l, var));
|
chrec = instantiate_parameters (l, analyze_scalar_evolution (l, var));
|
if (TREE_CODE (chrec) != POLYNOMIAL_CHREC)
|
if (TREE_CODE (chrec) != POLYNOMIAL_CHREC)
|
return true;
|
return true;
|
|
|
init = initial_condition_in_loop_num (chrec, l->num);
|
init = initial_condition_in_loop_num (chrec, l->num);
|
step = evolution_part_in_loop_num (chrec, l->num);
|
step = evolution_part_in_loop_num (chrec, l->num);
|
|
|
if (step == NULL_TREE
|
if (step == NULL_TREE
|
|| !is_gimple_min_invariant (step)
|
|| !is_gimple_min_invariant (step)
|
|| !valid_value_p (init))
|
|| !valid_value_p (init))
|
return true;
|
return true;
|
|
|
/* If we get here, we know something useful about VAR based on the
|
/* If we get here, we know something useful about VAR based on the
|
loop information. If it wraps, it may overflow. */
|
loop information. If it wraps, it may overflow. */
|
|
|
if (scev_probably_wraps_p (init, step, stmt,
|
if (scev_probably_wraps_p (init, step, stmt,
|
current_loops->parray[CHREC_VARIABLE (chrec)],
|
current_loops->parray[CHREC_VARIABLE (chrec)],
|
true))
|
true))
|
return true;
|
return true;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS) != 0)
|
if (dump_file && (dump_flags & TDF_DETAILS) != 0)
|
{
|
{
|
print_generic_expr (dump_file, var, 0);
|
print_generic_expr (dump_file, var, 0);
|
fprintf (dump_file, ": loop information indicates does not overflow\n");
|
fprintf (dump_file, ": loop information indicates does not overflow\n");
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Given two numeric value ranges VR0, VR1 and a comparison code COMP:
|
/* Given two numeric value ranges VR0, VR1 and a comparison code COMP:
|
|
|
- Return BOOLEAN_TRUE_NODE if VR0 COMP VR1 always returns true for
|
- Return BOOLEAN_TRUE_NODE if VR0 COMP VR1 always returns true for
|
all the values in the ranges.
|
all the values in the ranges.
|
|
|
- Return BOOLEAN_FALSE_NODE if the comparison always returns false.
|
- Return BOOLEAN_FALSE_NODE if the comparison always returns false.
|
|
|
- Return NULL_TREE if it is not always possible to determine the
|
- Return NULL_TREE if it is not always possible to determine the
|
value of the comparison.
|
value of the comparison.
|
|
|
Also set *STRICT_OVERFLOW_P to indicate whether a range with an
|
Also set *STRICT_OVERFLOW_P to indicate whether a range with an
|
overflow infinity was used in the test. */
|
overflow infinity was used in the test. */
|
|
|
|
|
static tree
|
static tree
|
compare_ranges (enum tree_code comp, value_range_t *vr0, value_range_t *vr1,
|
compare_ranges (enum tree_code comp, value_range_t *vr0, value_range_t *vr1,
|
bool *strict_overflow_p)
|
bool *strict_overflow_p)
|
{
|
{
|
/* VARYING or UNDEFINED ranges cannot be compared. */
|
/* VARYING or UNDEFINED ranges cannot be compared. */
|
if (vr0->type == VR_VARYING
|
if (vr0->type == VR_VARYING
|
|| vr0->type == VR_UNDEFINED
|
|| vr0->type == VR_UNDEFINED
|
|| vr1->type == VR_VARYING
|
|| vr1->type == VR_VARYING
|
|| vr1->type == VR_UNDEFINED)
|
|| vr1->type == VR_UNDEFINED)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* Anti-ranges need to be handled separately. */
|
/* Anti-ranges need to be handled separately. */
|
if (vr0->type == VR_ANTI_RANGE || vr1->type == VR_ANTI_RANGE)
|
if (vr0->type == VR_ANTI_RANGE || vr1->type == VR_ANTI_RANGE)
|
{
|
{
|
/* If both are anti-ranges, then we cannot compute any
|
/* If both are anti-ranges, then we cannot compute any
|
comparison. */
|
comparison. */
|
if (vr0->type == VR_ANTI_RANGE && vr1->type == VR_ANTI_RANGE)
|
if (vr0->type == VR_ANTI_RANGE && vr1->type == VR_ANTI_RANGE)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* These comparisons are never statically computable. */
|
/* These comparisons are never statically computable. */
|
if (comp == GT_EXPR
|
if (comp == GT_EXPR
|
|| comp == GE_EXPR
|
|| comp == GE_EXPR
|
|| comp == LT_EXPR
|
|| comp == LT_EXPR
|
|| comp == LE_EXPR)
|
|| comp == LE_EXPR)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* Equality can be computed only between a range and an
|
/* Equality can be computed only between a range and an
|
anti-range. ~[VAL1, VAL2] == [VAL1, VAL2] is always false. */
|
anti-range. ~[VAL1, VAL2] == [VAL1, VAL2] is always false. */
|
if (vr0->type == VR_RANGE)
|
if (vr0->type == VR_RANGE)
|
{
|
{
|
/* To simplify processing, make VR0 the anti-range. */
|
/* To simplify processing, make VR0 the anti-range. */
|
value_range_t *tmp = vr0;
|
value_range_t *tmp = vr0;
|
vr0 = vr1;
|
vr0 = vr1;
|
vr1 = tmp;
|
vr1 = tmp;
|
}
|
}
|
|
|
gcc_assert (comp == NE_EXPR || comp == EQ_EXPR);
|
gcc_assert (comp == NE_EXPR || comp == EQ_EXPR);
|
|
|
if (compare_values_warnv (vr0->min, vr1->min, strict_overflow_p) == 0
|
if (compare_values_warnv (vr0->min, vr1->min, strict_overflow_p) == 0
|
&& compare_values_warnv (vr0->max, vr1->max, strict_overflow_p) == 0)
|
&& compare_values_warnv (vr0->max, vr1->max, strict_overflow_p) == 0)
|
return (comp == NE_EXPR) ? boolean_true_node : boolean_false_node;
|
return (comp == NE_EXPR) ? boolean_true_node : boolean_false_node;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
if (!usable_range_p (vr0, strict_overflow_p)
|
if (!usable_range_p (vr0, strict_overflow_p)
|
|| !usable_range_p (vr1, strict_overflow_p))
|
|| !usable_range_p (vr1, strict_overflow_p))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* Simplify processing. If COMP is GT_EXPR or GE_EXPR, switch the
|
/* Simplify processing. If COMP is GT_EXPR or GE_EXPR, switch the
|
operands around and change the comparison code. */
|
operands around and change the comparison code. */
|
if (comp == GT_EXPR || comp == GE_EXPR)
|
if (comp == GT_EXPR || comp == GE_EXPR)
|
{
|
{
|
value_range_t *tmp;
|
value_range_t *tmp;
|
comp = (comp == GT_EXPR) ? LT_EXPR : LE_EXPR;
|
comp = (comp == GT_EXPR) ? LT_EXPR : LE_EXPR;
|
tmp = vr0;
|
tmp = vr0;
|
vr0 = vr1;
|
vr0 = vr1;
|
vr1 = tmp;
|
vr1 = tmp;
|
}
|
}
|
|
|
if (comp == EQ_EXPR)
|
if (comp == EQ_EXPR)
|
{
|
{
|
/* Equality may only be computed if both ranges represent
|
/* Equality may only be computed if both ranges represent
|
exactly one value. */
|
exactly one value. */
|
if (compare_values_warnv (vr0->min, vr0->max, strict_overflow_p) == 0
|
if (compare_values_warnv (vr0->min, vr0->max, strict_overflow_p) == 0
|
&& compare_values_warnv (vr1->min, vr1->max, strict_overflow_p) == 0)
|
&& compare_values_warnv (vr1->min, vr1->max, strict_overflow_p) == 0)
|
{
|
{
|
int cmp_min = compare_values_warnv (vr0->min, vr1->min,
|
int cmp_min = compare_values_warnv (vr0->min, vr1->min,
|
strict_overflow_p);
|
strict_overflow_p);
|
int cmp_max = compare_values_warnv (vr0->max, vr1->max,
|
int cmp_max = compare_values_warnv (vr0->max, vr1->max,
|
strict_overflow_p);
|
strict_overflow_p);
|
if (cmp_min == 0 && cmp_max == 0)
|
if (cmp_min == 0 && cmp_max == 0)
|
return boolean_true_node;
|
return boolean_true_node;
|
else if (cmp_min != -2 && cmp_max != -2)
|
else if (cmp_min != -2 && cmp_max != -2)
|
return boolean_false_node;
|
return boolean_false_node;
|
}
|
}
|
/* If [V0_MIN, V1_MAX] < [V1_MIN, V1_MAX] then V0 != V1. */
|
/* If [V0_MIN, V1_MAX] < [V1_MIN, V1_MAX] then V0 != V1. */
|
else if (compare_values_warnv (vr0->min, vr1->max,
|
else if (compare_values_warnv (vr0->min, vr1->max,
|
strict_overflow_p) == 1
|
strict_overflow_p) == 1
|
|| compare_values_warnv (vr1->min, vr0->max,
|
|| compare_values_warnv (vr1->min, vr0->max,
|
strict_overflow_p) == 1)
|
strict_overflow_p) == 1)
|
return boolean_false_node;
|
return boolean_false_node;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
else if (comp == NE_EXPR)
|
else if (comp == NE_EXPR)
|
{
|
{
|
int cmp1, cmp2;
|
int cmp1, cmp2;
|
|
|
/* If VR0 is completely to the left or completely to the right
|
/* If VR0 is completely to the left or completely to the right
|
of VR1, they are always different. Notice that we need to
|
of VR1, they are always different. Notice that we need to
|
make sure that both comparisons yield similar results to
|
make sure that both comparisons yield similar results to
|
avoid comparing values that cannot be compared at
|
avoid comparing values that cannot be compared at
|
compile-time. */
|
compile-time. */
|
cmp1 = compare_values_warnv (vr0->max, vr1->min, strict_overflow_p);
|
cmp1 = compare_values_warnv (vr0->max, vr1->min, strict_overflow_p);
|
cmp2 = compare_values_warnv (vr0->min, vr1->max, strict_overflow_p);
|
cmp2 = compare_values_warnv (vr0->min, vr1->max, strict_overflow_p);
|
if ((cmp1 == -1 && cmp2 == -1) || (cmp1 == 1 && cmp2 == 1))
|
if ((cmp1 == -1 && cmp2 == -1) || (cmp1 == 1 && cmp2 == 1))
|
return boolean_true_node;
|
return boolean_true_node;
|
|
|
/* If VR0 and VR1 represent a single value and are identical,
|
/* If VR0 and VR1 represent a single value and are identical,
|
return false. */
|
return false. */
|
else if (compare_values_warnv (vr0->min, vr0->max,
|
else if (compare_values_warnv (vr0->min, vr0->max,
|
strict_overflow_p) == 0
|
strict_overflow_p) == 0
|
&& compare_values_warnv (vr1->min, vr1->max,
|
&& compare_values_warnv (vr1->min, vr1->max,
|
strict_overflow_p) == 0
|
strict_overflow_p) == 0
|
&& compare_values_warnv (vr0->min, vr1->min,
|
&& compare_values_warnv (vr0->min, vr1->min,
|
strict_overflow_p) == 0
|
strict_overflow_p) == 0
|
&& compare_values_warnv (vr0->max, vr1->max,
|
&& compare_values_warnv (vr0->max, vr1->max,
|
strict_overflow_p) == 0)
|
strict_overflow_p) == 0)
|
return boolean_false_node;
|
return boolean_false_node;
|
|
|
/* Otherwise, they may or may not be different. */
|
/* Otherwise, they may or may not be different. */
|
else
|
else
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
else if (comp == LT_EXPR || comp == LE_EXPR)
|
else if (comp == LT_EXPR || comp == LE_EXPR)
|
{
|
{
|
int tst;
|
int tst;
|
|
|
/* If VR0 is to the left of VR1, return true. */
|
/* If VR0 is to the left of VR1, return true. */
|
tst = compare_values_warnv (vr0->max, vr1->min, strict_overflow_p);
|
tst = compare_values_warnv (vr0->max, vr1->min, strict_overflow_p);
|
if ((comp == LT_EXPR && tst == -1)
|
if ((comp == LT_EXPR && tst == -1)
|
|| (comp == LE_EXPR && (tst == -1 || tst == 0)))
|
|| (comp == LE_EXPR && (tst == -1 || tst == 0)))
|
{
|
{
|
if (overflow_infinity_range_p (vr0)
|
if (overflow_infinity_range_p (vr0)
|
|| overflow_infinity_range_p (vr1))
|
|| overflow_infinity_range_p (vr1))
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
return boolean_true_node;
|
return boolean_true_node;
|
}
|
}
|
|
|
/* If VR0 is to the right of VR1, return false. */
|
/* If VR0 is to the right of VR1, return false. */
|
tst = compare_values_warnv (vr0->min, vr1->max, strict_overflow_p);
|
tst = compare_values_warnv (vr0->min, vr1->max, strict_overflow_p);
|
if ((comp == LT_EXPR && (tst == 0 || tst == 1))
|
if ((comp == LT_EXPR && (tst == 0 || tst == 1))
|
|| (comp == LE_EXPR && tst == 1))
|
|| (comp == LE_EXPR && tst == 1))
|
{
|
{
|
if (overflow_infinity_range_p (vr0)
|
if (overflow_infinity_range_p (vr0)
|
|| overflow_infinity_range_p (vr1))
|
|| overflow_infinity_range_p (vr1))
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
return boolean_false_node;
|
return boolean_false_node;
|
}
|
}
|
|
|
/* Otherwise, we don't know. */
|
/* Otherwise, we don't know. */
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
|
|
/* Given a value range VR, a value VAL and a comparison code COMP, return
|
/* Given a value range VR, a value VAL and a comparison code COMP, return
|
BOOLEAN_TRUE_NODE if VR COMP VAL always returns true for all the
|
BOOLEAN_TRUE_NODE if VR COMP VAL always returns true for all the
|
values in VR. Return BOOLEAN_FALSE_NODE if the comparison
|
values in VR. Return BOOLEAN_FALSE_NODE if the comparison
|
always returns false. Return NULL_TREE if it is not always
|
always returns false. Return NULL_TREE if it is not always
|
possible to determine the value of the comparison. Also set
|
possible to determine the value of the comparison. Also set
|
*STRICT_OVERFLOW_P to indicate whether a range with an overflow
|
*STRICT_OVERFLOW_P to indicate whether a range with an overflow
|
infinity was used in the test. */
|
infinity was used in the test. */
|
|
|
static tree
|
static tree
|
compare_range_with_value (enum tree_code comp, value_range_t *vr, tree val,
|
compare_range_with_value (enum tree_code comp, value_range_t *vr, tree val,
|
bool *strict_overflow_p)
|
bool *strict_overflow_p)
|
{
|
{
|
if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED)
|
if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* Anti-ranges need to be handled separately. */
|
/* Anti-ranges need to be handled separately. */
|
if (vr->type == VR_ANTI_RANGE)
|
if (vr->type == VR_ANTI_RANGE)
|
{
|
{
|
/* For anti-ranges, the only predicates that we can compute at
|
/* For anti-ranges, the only predicates that we can compute at
|
compile time are equality and inequality. */
|
compile time are equality and inequality. */
|
if (comp == GT_EXPR
|
if (comp == GT_EXPR
|
|| comp == GE_EXPR
|
|| comp == GE_EXPR
|
|| comp == LT_EXPR
|
|| comp == LT_EXPR
|
|| comp == LE_EXPR)
|
|| comp == LE_EXPR)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* ~[VAL_1, VAL_2] OP VAL is known if VAL_1 <= VAL <= VAL_2. */
|
/* ~[VAL_1, VAL_2] OP VAL is known if VAL_1 <= VAL <= VAL_2. */
|
if (value_inside_range (val, vr) == 1)
|
if (value_inside_range (val, vr) == 1)
|
return (comp == NE_EXPR) ? boolean_true_node : boolean_false_node;
|
return (comp == NE_EXPR) ? boolean_true_node : boolean_false_node;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
if (!usable_range_p (vr, strict_overflow_p))
|
if (!usable_range_p (vr, strict_overflow_p))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
if (comp == EQ_EXPR)
|
if (comp == EQ_EXPR)
|
{
|
{
|
/* EQ_EXPR may only be computed if VR represents exactly
|
/* EQ_EXPR may only be computed if VR represents exactly
|
one value. */
|
one value. */
|
if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0)
|
if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0)
|
{
|
{
|
int cmp = compare_values_warnv (vr->min, val, strict_overflow_p);
|
int cmp = compare_values_warnv (vr->min, val, strict_overflow_p);
|
if (cmp == 0)
|
if (cmp == 0)
|
return boolean_true_node;
|
return boolean_true_node;
|
else if (cmp == -1 || cmp == 1 || cmp == 2)
|
else if (cmp == -1 || cmp == 1 || cmp == 2)
|
return boolean_false_node;
|
return boolean_false_node;
|
}
|
}
|
else if (compare_values_warnv (val, vr->min, strict_overflow_p) == -1
|
else if (compare_values_warnv (val, vr->min, strict_overflow_p) == -1
|
|| compare_values_warnv (vr->max, val, strict_overflow_p) == -1)
|
|| compare_values_warnv (vr->max, val, strict_overflow_p) == -1)
|
return boolean_false_node;
|
return boolean_false_node;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
else if (comp == NE_EXPR)
|
else if (comp == NE_EXPR)
|
{
|
{
|
/* If VAL is not inside VR, then they are always different. */
|
/* If VAL is not inside VR, then they are always different. */
|
if (compare_values_warnv (vr->max, val, strict_overflow_p) == -1
|
if (compare_values_warnv (vr->max, val, strict_overflow_p) == -1
|
|| compare_values_warnv (vr->min, val, strict_overflow_p) == 1)
|
|| compare_values_warnv (vr->min, val, strict_overflow_p) == 1)
|
return boolean_true_node;
|
return boolean_true_node;
|
|
|
/* If VR represents exactly one value equal to VAL, then return
|
/* If VR represents exactly one value equal to VAL, then return
|
false. */
|
false. */
|
if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0
|
if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0
|
&& compare_values_warnv (vr->min, val, strict_overflow_p) == 0)
|
&& compare_values_warnv (vr->min, val, strict_overflow_p) == 0)
|
return boolean_false_node;
|
return boolean_false_node;
|
|
|
/* Otherwise, they may or may not be different. */
|
/* Otherwise, they may or may not be different. */
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
else if (comp == LT_EXPR || comp == LE_EXPR)
|
else if (comp == LT_EXPR || comp == LE_EXPR)
|
{
|
{
|
int tst;
|
int tst;
|
|
|
/* If VR is to the left of VAL, return true. */
|
/* If VR is to the left of VAL, return true. */
|
tst = compare_values_warnv (vr->max, val, strict_overflow_p);
|
tst = compare_values_warnv (vr->max, val, strict_overflow_p);
|
if ((comp == LT_EXPR && tst == -1)
|
if ((comp == LT_EXPR && tst == -1)
|
|| (comp == LE_EXPR && (tst == -1 || tst == 0)))
|
|| (comp == LE_EXPR && (tst == -1 || tst == 0)))
|
{
|
{
|
if (overflow_infinity_range_p (vr))
|
if (overflow_infinity_range_p (vr))
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
return boolean_true_node;
|
return boolean_true_node;
|
}
|
}
|
|
|
/* If VR is to the right of VAL, return false. */
|
/* If VR is to the right of VAL, return false. */
|
tst = compare_values_warnv (vr->min, val, strict_overflow_p);
|
tst = compare_values_warnv (vr->min, val, strict_overflow_p);
|
if ((comp == LT_EXPR && (tst == 0 || tst == 1))
|
if ((comp == LT_EXPR && (tst == 0 || tst == 1))
|
|| (comp == LE_EXPR && tst == 1))
|
|| (comp == LE_EXPR && tst == 1))
|
{
|
{
|
if (overflow_infinity_range_p (vr))
|
if (overflow_infinity_range_p (vr))
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
return boolean_false_node;
|
return boolean_false_node;
|
}
|
}
|
|
|
/* Otherwise, we don't know. */
|
/* Otherwise, we don't know. */
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
else if (comp == GT_EXPR || comp == GE_EXPR)
|
else if (comp == GT_EXPR || comp == GE_EXPR)
|
{
|
{
|
int tst;
|
int tst;
|
|
|
/* If VR is to the right of VAL, return true. */
|
/* If VR is to the right of VAL, return true. */
|
tst = compare_values_warnv (vr->min, val, strict_overflow_p);
|
tst = compare_values_warnv (vr->min, val, strict_overflow_p);
|
if ((comp == GT_EXPR && tst == 1)
|
if ((comp == GT_EXPR && tst == 1)
|
|| (comp == GE_EXPR && (tst == 0 || tst == 1)))
|
|| (comp == GE_EXPR && (tst == 0 || tst == 1)))
|
{
|
{
|
if (overflow_infinity_range_p (vr))
|
if (overflow_infinity_range_p (vr))
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
return boolean_true_node;
|
return boolean_true_node;
|
}
|
}
|
|
|
/* If VR is to the left of VAL, return false. */
|
/* If VR is to the left of VAL, return false. */
|
tst = compare_values_warnv (vr->max, val, strict_overflow_p);
|
tst = compare_values_warnv (vr->max, val, strict_overflow_p);
|
if ((comp == GT_EXPR && (tst == -1 || tst == 0))
|
if ((comp == GT_EXPR && (tst == -1 || tst == 0))
|
|| (comp == GE_EXPR && tst == -1))
|
|| (comp == GE_EXPR && tst == -1))
|
{
|
{
|
if (overflow_infinity_range_p (vr))
|
if (overflow_infinity_range_p (vr))
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
return boolean_false_node;
|
return boolean_false_node;
|
}
|
}
|
|
|
/* Otherwise, we don't know. */
|
/* Otherwise, we don't know. */
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
|
|
/* Debugging dumps. */
|
/* Debugging dumps. */
|
|
|
void dump_value_range (FILE *, value_range_t *);
|
void dump_value_range (FILE *, value_range_t *);
|
void debug_value_range (value_range_t *);
|
void debug_value_range (value_range_t *);
|
void dump_all_value_ranges (FILE *);
|
void dump_all_value_ranges (FILE *);
|
void debug_all_value_ranges (void);
|
void debug_all_value_ranges (void);
|
void dump_vr_equiv (FILE *, bitmap);
|
void dump_vr_equiv (FILE *, bitmap);
|
void debug_vr_equiv (bitmap);
|
void debug_vr_equiv (bitmap);
|
|
|
|
|
/* Dump value range VR to FILE. */
|
/* Dump value range VR to FILE. */
|
|
|
void
|
void
|
dump_value_range (FILE *file, value_range_t *vr)
|
dump_value_range (FILE *file, value_range_t *vr)
|
{
|
{
|
if (vr == NULL)
|
if (vr == NULL)
|
fprintf (file, "[]");
|
fprintf (file, "[]");
|
else if (vr->type == VR_UNDEFINED)
|
else if (vr->type == VR_UNDEFINED)
|
fprintf (file, "UNDEFINED");
|
fprintf (file, "UNDEFINED");
|
else if (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE)
|
else if (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE)
|
{
|
{
|
tree type = TREE_TYPE (vr->min);
|
tree type = TREE_TYPE (vr->min);
|
|
|
fprintf (file, "%s[", (vr->type == VR_ANTI_RANGE) ? "~" : "");
|
fprintf (file, "%s[", (vr->type == VR_ANTI_RANGE) ? "~" : "");
|
|
|
if (is_negative_overflow_infinity (vr->min))
|
if (is_negative_overflow_infinity (vr->min))
|
fprintf (file, "-INF(OVF)");
|
fprintf (file, "-INF(OVF)");
|
else if (INTEGRAL_TYPE_P (type)
|
else if (INTEGRAL_TYPE_P (type)
|
&& !TYPE_UNSIGNED (type)
|
&& !TYPE_UNSIGNED (type)
|
&& vrp_val_is_min (vr->min))
|
&& vrp_val_is_min (vr->min))
|
fprintf (file, "-INF");
|
fprintf (file, "-INF");
|
else
|
else
|
print_generic_expr (file, vr->min, 0);
|
print_generic_expr (file, vr->min, 0);
|
|
|
fprintf (file, ", ");
|
fprintf (file, ", ");
|
|
|
if (is_positive_overflow_infinity (vr->max))
|
if (is_positive_overflow_infinity (vr->max))
|
fprintf (file, "+INF(OVF)");
|
fprintf (file, "+INF(OVF)");
|
else if (INTEGRAL_TYPE_P (type)
|
else if (INTEGRAL_TYPE_P (type)
|
&& vrp_val_is_max (vr->max))
|
&& vrp_val_is_max (vr->max))
|
fprintf (file, "+INF");
|
fprintf (file, "+INF");
|
else
|
else
|
print_generic_expr (file, vr->max, 0);
|
print_generic_expr (file, vr->max, 0);
|
|
|
fprintf (file, "]");
|
fprintf (file, "]");
|
|
|
if (vr->equiv)
|
if (vr->equiv)
|
{
|
{
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned i, c = 0;
|
unsigned i, c = 0;
|
|
|
fprintf (file, " EQUIVALENCES: { ");
|
fprintf (file, " EQUIVALENCES: { ");
|
|
|
EXECUTE_IF_SET_IN_BITMAP (vr->equiv, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (vr->equiv, 0, i, bi)
|
{
|
{
|
print_generic_expr (file, ssa_name (i), 0);
|
print_generic_expr (file, ssa_name (i), 0);
|
fprintf (file, " ");
|
fprintf (file, " ");
|
c++;
|
c++;
|
}
|
}
|
|
|
fprintf (file, "} (%u elements)", c);
|
fprintf (file, "} (%u elements)", c);
|
}
|
}
|
}
|
}
|
else if (vr->type == VR_VARYING)
|
else if (vr->type == VR_VARYING)
|
fprintf (file, "VARYING");
|
fprintf (file, "VARYING");
|
else
|
else
|
fprintf (file, "INVALID RANGE");
|
fprintf (file, "INVALID RANGE");
|
}
|
}
|
|
|
|
|
/* Dump value range VR to stderr. */
|
/* Dump value range VR to stderr. */
|
|
|
void
|
void
|
debug_value_range (value_range_t *vr)
|
debug_value_range (value_range_t *vr)
|
{
|
{
|
dump_value_range (stderr, vr);
|
dump_value_range (stderr, vr);
|
fprintf (stderr, "\n");
|
fprintf (stderr, "\n");
|
}
|
}
|
|
|
|
|
/* Dump value ranges of all SSA_NAMEs to FILE. */
|
/* Dump value ranges of all SSA_NAMEs to FILE. */
|
|
|
void
|
void
|
dump_all_value_ranges (FILE *file)
|
dump_all_value_ranges (FILE *file)
|
{
|
{
|
size_t i;
|
size_t i;
|
|
|
for (i = 0; i < num_ssa_names; i++)
|
for (i = 0; i < num_ssa_names; i++)
|
{
|
{
|
if (vr_value[i])
|
if (vr_value[i])
|
{
|
{
|
print_generic_expr (file, ssa_name (i), 0);
|
print_generic_expr (file, ssa_name (i), 0);
|
fprintf (file, ": ");
|
fprintf (file, ": ");
|
dump_value_range (file, vr_value[i]);
|
dump_value_range (file, vr_value[i]);
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
}
|
}
|
}
|
}
|
|
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
}
|
}
|
|
|
|
|
/* Dump all value ranges to stderr. */
|
/* Dump all value ranges to stderr. */
|
|
|
void
|
void
|
debug_all_value_ranges (void)
|
debug_all_value_ranges (void)
|
{
|
{
|
dump_all_value_ranges (stderr);
|
dump_all_value_ranges (stderr);
|
}
|
}
|
|
|
|
|
/* Given a COND_EXPR COND of the form 'V OP W', and an SSA name V,
|
/* Given a COND_EXPR COND of the form 'V OP W', and an SSA name V,
|
create a new SSA name N and return the assertion assignment
|
create a new SSA name N and return the assertion assignment
|
'V = ASSERT_EXPR <V, V OP W>'. */
|
'V = ASSERT_EXPR <V, V OP W>'. */
|
|
|
static tree
|
static tree
|
build_assert_expr_for (tree cond, tree v)
|
build_assert_expr_for (tree cond, tree v)
|
{
|
{
|
tree n, assertion;
|
tree n, assertion;
|
|
|
gcc_assert (TREE_CODE (v) == SSA_NAME);
|
gcc_assert (TREE_CODE (v) == SSA_NAME);
|
n = duplicate_ssa_name (v, NULL_TREE);
|
n = duplicate_ssa_name (v, NULL_TREE);
|
|
|
if (COMPARISON_CLASS_P (cond))
|
if (COMPARISON_CLASS_P (cond))
|
{
|
{
|
tree a = build2 (ASSERT_EXPR, TREE_TYPE (v), v, cond);
|
tree a = build2 (ASSERT_EXPR, TREE_TYPE (v), v, cond);
|
assertion = build2 (MODIFY_EXPR, TREE_TYPE (v), n, a);
|
assertion = build2 (MODIFY_EXPR, TREE_TYPE (v), n, a);
|
}
|
}
|
else if (TREE_CODE (cond) == TRUTH_NOT_EXPR)
|
else if (TREE_CODE (cond) == TRUTH_NOT_EXPR)
|
{
|
{
|
/* Given !V, build the assignment N = false. */
|
/* Given !V, build the assignment N = false. */
|
tree op0 = TREE_OPERAND (cond, 0);
|
tree op0 = TREE_OPERAND (cond, 0);
|
gcc_assert (op0 == v);
|
gcc_assert (op0 == v);
|
assertion = build2 (MODIFY_EXPR, TREE_TYPE (v), n, boolean_false_node);
|
assertion = build2 (MODIFY_EXPR, TREE_TYPE (v), n, boolean_false_node);
|
}
|
}
|
else if (TREE_CODE (cond) == SSA_NAME)
|
else if (TREE_CODE (cond) == SSA_NAME)
|
{
|
{
|
/* Given V, build the assignment N = true. */
|
/* Given V, build the assignment N = true. */
|
gcc_assert (v == cond);
|
gcc_assert (v == cond);
|
assertion = build2 (MODIFY_EXPR, TREE_TYPE (v), n, boolean_true_node);
|
assertion = build2 (MODIFY_EXPR, TREE_TYPE (v), n, boolean_true_node);
|
}
|
}
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
|
|
SSA_NAME_DEF_STMT (n) = assertion;
|
SSA_NAME_DEF_STMT (n) = assertion;
|
|
|
/* The new ASSERT_EXPR, creates a new SSA name that replaces the
|
/* The new ASSERT_EXPR, creates a new SSA name that replaces the
|
operand of the ASSERT_EXPR. Register the new name and the old one
|
operand of the ASSERT_EXPR. Register the new name and the old one
|
in the replacement table so that we can fix the SSA web after
|
in the replacement table so that we can fix the SSA web after
|
adding all the ASSERT_EXPRs. */
|
adding all the ASSERT_EXPRs. */
|
register_new_name_mapping (n, v);
|
register_new_name_mapping (n, v);
|
|
|
return assertion;
|
return assertion;
|
}
|
}
|
|
|
|
|
/* Return false if EXPR is a predicate expression involving floating
|
/* Return false if EXPR is a predicate expression involving floating
|
point values. */
|
point values. */
|
|
|
static inline bool
|
static inline bool
|
fp_predicate (tree expr)
|
fp_predicate (tree expr)
|
{
|
{
|
return (COMPARISON_CLASS_P (expr)
|
return (COMPARISON_CLASS_P (expr)
|
&& FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0))));
|
&& FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0))));
|
}
|
}
|
|
|
|
|
/* If the range of values taken by OP can be inferred after STMT executes,
|
/* If the range of values taken by OP can be inferred after STMT executes,
|
return the comparison code (COMP_CODE_P) and value (VAL_P) that
|
return the comparison code (COMP_CODE_P) and value (VAL_P) that
|
describes the inferred range. Return true if a range could be
|
describes the inferred range. Return true if a range could be
|
inferred. */
|
inferred. */
|
|
|
static bool
|
static bool
|
infer_value_range (tree stmt, tree op, enum tree_code *comp_code_p, tree *val_p)
|
infer_value_range (tree stmt, tree op, enum tree_code *comp_code_p, tree *val_p)
|
{
|
{
|
*val_p = NULL_TREE;
|
*val_p = NULL_TREE;
|
*comp_code_p = ERROR_MARK;
|
*comp_code_p = ERROR_MARK;
|
|
|
/* Do not attempt to infer anything in names that flow through
|
/* Do not attempt to infer anything in names that flow through
|
abnormal edges. */
|
abnormal edges. */
|
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op))
|
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op))
|
return false;
|
return false;
|
|
|
/* Similarly, don't infer anything from statements that may throw
|
/* Similarly, don't infer anything from statements that may throw
|
exceptions. */
|
exceptions. */
|
if (tree_could_throw_p (stmt))
|
if (tree_could_throw_p (stmt))
|
return false;
|
return false;
|
|
|
/* If STMT is the last statement of a basic block with no
|
/* If STMT is the last statement of a basic block with no
|
successors, there is no point inferring anything about any of its
|
successors, there is no point inferring anything about any of its
|
operands. We would not be able to find a proper insertion point
|
operands. We would not be able to find a proper insertion point
|
for the assertion, anyway. */
|
for the assertion, anyway. */
|
if (stmt_ends_bb_p (stmt) && EDGE_COUNT (bb_for_stmt (stmt)->succs) == 0)
|
if (stmt_ends_bb_p (stmt) && EDGE_COUNT (bb_for_stmt (stmt)->succs) == 0)
|
return false;
|
return false;
|
|
|
/* We can only assume that a pointer dereference will yield
|
/* We can only assume that a pointer dereference will yield
|
non-NULL if -fdelete-null-pointer-checks is enabled. */
|
non-NULL if -fdelete-null-pointer-checks is enabled. */
|
if (flag_delete_null_pointer_checks && POINTER_TYPE_P (TREE_TYPE (op)))
|
if (flag_delete_null_pointer_checks && POINTER_TYPE_P (TREE_TYPE (op)))
|
{
|
{
|
bool is_store;
|
bool is_store;
|
unsigned num_uses, num_derefs;
|
unsigned num_uses, num_derefs;
|
|
|
count_uses_and_derefs (op, stmt, &num_uses, &num_derefs, &is_store);
|
count_uses_and_derefs (op, stmt, &num_uses, &num_derefs, &is_store);
|
if (num_derefs > 0)
|
if (num_derefs > 0)
|
{
|
{
|
*val_p = build_int_cst (TREE_TYPE (op), 0);
|
*val_p = build_int_cst (TREE_TYPE (op), 0);
|
*comp_code_p = NE_EXPR;
|
*comp_code_p = NE_EXPR;
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
void dump_asserts_for (FILE *, tree);
|
void dump_asserts_for (FILE *, tree);
|
void debug_asserts_for (tree);
|
void debug_asserts_for (tree);
|
void dump_all_asserts (FILE *);
|
void dump_all_asserts (FILE *);
|
void debug_all_asserts (void);
|
void debug_all_asserts (void);
|
|
|
/* Dump all the registered assertions for NAME to FILE. */
|
/* Dump all the registered assertions for NAME to FILE. */
|
|
|
void
|
void
|
dump_asserts_for (FILE *file, tree name)
|
dump_asserts_for (FILE *file, tree name)
|
{
|
{
|
assert_locus_t loc;
|
assert_locus_t loc;
|
|
|
fprintf (file, "Assertions to be inserted for ");
|
fprintf (file, "Assertions to be inserted for ");
|
print_generic_expr (file, name, 0);
|
print_generic_expr (file, name, 0);
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
|
|
loc = asserts_for[SSA_NAME_VERSION (name)];
|
loc = asserts_for[SSA_NAME_VERSION (name)];
|
while (loc)
|
while (loc)
|
{
|
{
|
fprintf (file, "\t");
|
fprintf (file, "\t");
|
print_generic_expr (file, bsi_stmt (loc->si), 0);
|
print_generic_expr (file, bsi_stmt (loc->si), 0);
|
fprintf (file, "\n\tBB #%d", loc->bb->index);
|
fprintf (file, "\n\tBB #%d", loc->bb->index);
|
if (loc->e)
|
if (loc->e)
|
{
|
{
|
fprintf (file, "\n\tEDGE %d->%d", loc->e->src->index,
|
fprintf (file, "\n\tEDGE %d->%d", loc->e->src->index,
|
loc->e->dest->index);
|
loc->e->dest->index);
|
dump_edge_info (file, loc->e, 0);
|
dump_edge_info (file, loc->e, 0);
|
}
|
}
|
fprintf (file, "\n\tPREDICATE: ");
|
fprintf (file, "\n\tPREDICATE: ");
|
print_generic_expr (file, name, 0);
|
print_generic_expr (file, name, 0);
|
fprintf (file, " %s ", tree_code_name[(int)loc->comp_code]);
|
fprintf (file, " %s ", tree_code_name[(int)loc->comp_code]);
|
print_generic_expr (file, loc->val, 0);
|
print_generic_expr (file, loc->val, 0);
|
fprintf (file, "\n\n");
|
fprintf (file, "\n\n");
|
loc = loc->next;
|
loc = loc->next;
|
}
|
}
|
|
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
}
|
}
|
|
|
|
|
/* Dump all the registered assertions for NAME to stderr. */
|
/* Dump all the registered assertions for NAME to stderr. */
|
|
|
void
|
void
|
debug_asserts_for (tree name)
|
debug_asserts_for (tree name)
|
{
|
{
|
dump_asserts_for (stderr, name);
|
dump_asserts_for (stderr, name);
|
}
|
}
|
|
|
|
|
/* Dump all the registered assertions for all the names to FILE. */
|
/* Dump all the registered assertions for all the names to FILE. */
|
|
|
void
|
void
|
dump_all_asserts (FILE *file)
|
dump_all_asserts (FILE *file)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
fprintf (file, "\nASSERT_EXPRs to be inserted\n\n");
|
fprintf (file, "\nASSERT_EXPRs to be inserted\n\n");
|
EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi)
|
dump_asserts_for (file, ssa_name (i));
|
dump_asserts_for (file, ssa_name (i));
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
}
|
}
|
|
|
|
|
/* Dump all the registered assertions for all the names to stderr. */
|
/* Dump all the registered assertions for all the names to stderr. */
|
|
|
void
|
void
|
debug_all_asserts (void)
|
debug_all_asserts (void)
|
{
|
{
|
dump_all_asserts (stderr);
|
dump_all_asserts (stderr);
|
}
|
}
|
|
|
|
|
/* If NAME doesn't have an ASSERT_EXPR registered for asserting
|
/* If NAME doesn't have an ASSERT_EXPR registered for asserting
|
'NAME COMP_CODE VAL' at a location that dominates block BB or
|
'NAME COMP_CODE VAL' at a location that dominates block BB or
|
E->DEST, then register this location as a possible insertion point
|
E->DEST, then register this location as a possible insertion point
|
for ASSERT_EXPR <NAME, NAME COMP_CODE VAL>.
|
for ASSERT_EXPR <NAME, NAME COMP_CODE VAL>.
|
|
|
BB, E and SI provide the exact insertion point for the new
|
BB, E and SI provide the exact insertion point for the new
|
ASSERT_EXPR. If BB is NULL, then the ASSERT_EXPR is to be inserted
|
ASSERT_EXPR. If BB is NULL, then the ASSERT_EXPR is to be inserted
|
on edge E. Otherwise, if E is NULL, the ASSERT_EXPR is inserted on
|
on edge E. Otherwise, if E is NULL, the ASSERT_EXPR is inserted on
|
BB. If SI points to a COND_EXPR or a SWITCH_EXPR statement, then E
|
BB. If SI points to a COND_EXPR or a SWITCH_EXPR statement, then E
|
must not be NULL. */
|
must not be NULL. */
|
|
|
static void
|
static void
|
register_new_assert_for (tree name,
|
register_new_assert_for (tree name,
|
enum tree_code comp_code,
|
enum tree_code comp_code,
|
tree val,
|
tree val,
|
basic_block bb,
|
basic_block bb,
|
edge e,
|
edge e,
|
block_stmt_iterator si)
|
block_stmt_iterator si)
|
{
|
{
|
assert_locus_t n, loc, last_loc;
|
assert_locus_t n, loc, last_loc;
|
bool found;
|
bool found;
|
basic_block dest_bb;
|
basic_block dest_bb;
|
|
|
#if defined ENABLE_CHECKING
|
#if defined ENABLE_CHECKING
|
gcc_assert (bb == NULL || e == NULL);
|
gcc_assert (bb == NULL || e == NULL);
|
|
|
if (e == NULL)
|
if (e == NULL)
|
gcc_assert (TREE_CODE (bsi_stmt (si)) != COND_EXPR
|
gcc_assert (TREE_CODE (bsi_stmt (si)) != COND_EXPR
|
&& TREE_CODE (bsi_stmt (si)) != SWITCH_EXPR);
|
&& TREE_CODE (bsi_stmt (si)) != SWITCH_EXPR);
|
#endif
|
#endif
|
|
|
/* The new assertion A will be inserted at BB or E. We need to
|
/* The new assertion A will be inserted at BB or E. We need to
|
determine if the new location is dominated by a previously
|
determine if the new location is dominated by a previously
|
registered location for A. If we are doing an edge insertion,
|
registered location for A. If we are doing an edge insertion,
|
assume that A will be inserted at E->DEST. Note that this is not
|
assume that A will be inserted at E->DEST. Note that this is not
|
necessarily true.
|
necessarily true.
|
|
|
If E is a critical edge, it will be split. But even if E is
|
If E is a critical edge, it will be split. But even if E is
|
split, the new block will dominate the same set of blocks that
|
split, the new block will dominate the same set of blocks that
|
E->DEST dominates.
|
E->DEST dominates.
|
|
|
The reverse, however, is not true, blocks dominated by E->DEST
|
The reverse, however, is not true, blocks dominated by E->DEST
|
will not be dominated by the new block created to split E. So,
|
will not be dominated by the new block created to split E. So,
|
if the insertion location is on a critical edge, we will not use
|
if the insertion location is on a critical edge, we will not use
|
the new location to move another assertion previously registered
|
the new location to move another assertion previously registered
|
at a block dominated by E->DEST. */
|
at a block dominated by E->DEST. */
|
dest_bb = (bb) ? bb : e->dest;
|
dest_bb = (bb) ? bb : e->dest;
|
|
|
/* If NAME already has an ASSERT_EXPR registered for COMP_CODE and
|
/* If NAME already has an ASSERT_EXPR registered for COMP_CODE and
|
VAL at a block dominating DEST_BB, then we don't need to insert a new
|
VAL at a block dominating DEST_BB, then we don't need to insert a new
|
one. Similarly, if the same assertion already exists at a block
|
one. Similarly, if the same assertion already exists at a block
|
dominated by DEST_BB and the new location is not on a critical
|
dominated by DEST_BB and the new location is not on a critical
|
edge, then update the existing location for the assertion (i.e.,
|
edge, then update the existing location for the assertion (i.e.,
|
move the assertion up in the dominance tree).
|
move the assertion up in the dominance tree).
|
|
|
Note, this is implemented as a simple linked list because there
|
Note, this is implemented as a simple linked list because there
|
should not be more than a handful of assertions registered per
|
should not be more than a handful of assertions registered per
|
name. If this becomes a performance problem, a table hashed by
|
name. If this becomes a performance problem, a table hashed by
|
COMP_CODE and VAL could be implemented. */
|
COMP_CODE and VAL could be implemented. */
|
loc = asserts_for[SSA_NAME_VERSION (name)];
|
loc = asserts_for[SSA_NAME_VERSION (name)];
|
last_loc = loc;
|
last_loc = loc;
|
found = false;
|
found = false;
|
while (loc)
|
while (loc)
|
{
|
{
|
if (loc->comp_code == comp_code
|
if (loc->comp_code == comp_code
|
&& (loc->val == val
|
&& (loc->val == val
|
|| operand_equal_p (loc->val, val, 0)))
|
|| operand_equal_p (loc->val, val, 0)))
|
{
|
{
|
/* If the assertion NAME COMP_CODE VAL has already been
|
/* If the assertion NAME COMP_CODE VAL has already been
|
registered at a basic block that dominates DEST_BB, then
|
registered at a basic block that dominates DEST_BB, then
|
we don't need to insert the same assertion again. Note
|
we don't need to insert the same assertion again. Note
|
that we don't check strict dominance here to avoid
|
that we don't check strict dominance here to avoid
|
replicating the same assertion inside the same basic
|
replicating the same assertion inside the same basic
|
block more than once (e.g., when a pointer is
|
block more than once (e.g., when a pointer is
|
dereferenced several times inside a block).
|
dereferenced several times inside a block).
|
|
|
An exception to this rule are edge insertions. If the
|
An exception to this rule are edge insertions. If the
|
new assertion is to be inserted on edge E, then it will
|
new assertion is to be inserted on edge E, then it will
|
dominate all the other insertions that we may want to
|
dominate all the other insertions that we may want to
|
insert in DEST_BB. So, if we are doing an edge
|
insert in DEST_BB. So, if we are doing an edge
|
insertion, don't do this dominance check. */
|
insertion, don't do this dominance check. */
|
if (e == NULL
|
if (e == NULL
|
&& dominated_by_p (CDI_DOMINATORS, dest_bb, loc->bb))
|
&& dominated_by_p (CDI_DOMINATORS, dest_bb, loc->bb))
|
return;
|
return;
|
|
|
/* Otherwise, if E is not a critical edge and DEST_BB
|
/* Otherwise, if E is not a critical edge and DEST_BB
|
dominates the existing location for the assertion, move
|
dominates the existing location for the assertion, move
|
the assertion up in the dominance tree by updating its
|
the assertion up in the dominance tree by updating its
|
location information. */
|
location information. */
|
if ((e == NULL || !EDGE_CRITICAL_P (e))
|
if ((e == NULL || !EDGE_CRITICAL_P (e))
|
&& dominated_by_p (CDI_DOMINATORS, loc->bb, dest_bb))
|
&& dominated_by_p (CDI_DOMINATORS, loc->bb, dest_bb))
|
{
|
{
|
loc->bb = dest_bb;
|
loc->bb = dest_bb;
|
loc->e = e;
|
loc->e = e;
|
loc->si = si;
|
loc->si = si;
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
/* Update the last node of the list and move to the next one. */
|
/* Update the last node of the list and move to the next one. */
|
last_loc = loc;
|
last_loc = loc;
|
loc = loc->next;
|
loc = loc->next;
|
}
|
}
|
|
|
/* If we didn't find an assertion already registered for
|
/* If we didn't find an assertion already registered for
|
NAME COMP_CODE VAL, add a new one at the end of the list of
|
NAME COMP_CODE VAL, add a new one at the end of the list of
|
assertions associated with NAME. */
|
assertions associated with NAME. */
|
n = XNEW (struct assert_locus_d);
|
n = XNEW (struct assert_locus_d);
|
n->bb = dest_bb;
|
n->bb = dest_bb;
|
n->e = e;
|
n->e = e;
|
n->si = si;
|
n->si = si;
|
n->comp_code = comp_code;
|
n->comp_code = comp_code;
|
n->val = val;
|
n->val = val;
|
n->next = NULL;
|
n->next = NULL;
|
|
|
if (last_loc)
|
if (last_loc)
|
last_loc->next = n;
|
last_loc->next = n;
|
else
|
else
|
asserts_for[SSA_NAME_VERSION (name)] = n;
|
asserts_for[SSA_NAME_VERSION (name)] = n;
|
|
|
bitmap_set_bit (need_assert_for, SSA_NAME_VERSION (name));
|
bitmap_set_bit (need_assert_for, SSA_NAME_VERSION (name));
|
}
|
}
|
|
|
|
|
/* Try to register an edge assertion for SSA name NAME on edge E for
|
/* Try to register an edge assertion for SSA name NAME on edge E for
|
the conditional jump pointed to by SI. Return true if an assertion
|
the conditional jump pointed to by SI. Return true if an assertion
|
for NAME could be registered. */
|
for NAME could be registered. */
|
|
|
static bool
|
static bool
|
register_edge_assert_for (tree name, edge e, block_stmt_iterator si)
|
register_edge_assert_for (tree name, edge e, block_stmt_iterator si)
|
{
|
{
|
tree val, stmt;
|
tree val, stmt;
|
enum tree_code comp_code;
|
enum tree_code comp_code;
|
|
|
stmt = bsi_stmt (si);
|
stmt = bsi_stmt (si);
|
|
|
/* Do not attempt to infer anything in names that flow through
|
/* Do not attempt to infer anything in names that flow through
|
abnormal edges. */
|
abnormal edges. */
|
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
|
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
|
return false;
|
return false;
|
|
|
/* If NAME was not found in the sub-graph reachable from E, then
|
/* If NAME was not found in the sub-graph reachable from E, then
|
there's nothing to do. */
|
there's nothing to do. */
|
if (!TEST_BIT (found_in_subgraph, SSA_NAME_VERSION (name)))
|
if (!TEST_BIT (found_in_subgraph, SSA_NAME_VERSION (name)))
|
return false;
|
return false;
|
|
|
/* We found a use of NAME in the sub-graph rooted at E->DEST.
|
/* We found a use of NAME in the sub-graph rooted at E->DEST.
|
Register an assertion for NAME according to the value that NAME
|
Register an assertion for NAME according to the value that NAME
|
takes on edge E. */
|
takes on edge E. */
|
if (TREE_CODE (stmt) == COND_EXPR)
|
if (TREE_CODE (stmt) == COND_EXPR)
|
{
|
{
|
/* If BB ends in a COND_EXPR then NAME then we should insert
|
/* If BB ends in a COND_EXPR then NAME then we should insert
|
the original predicate on EDGE_TRUE_VALUE and the
|
the original predicate on EDGE_TRUE_VALUE and the
|
opposite predicate on EDGE_FALSE_VALUE. */
|
opposite predicate on EDGE_FALSE_VALUE. */
|
tree cond = COND_EXPR_COND (stmt);
|
tree cond = COND_EXPR_COND (stmt);
|
bool is_else_edge = (e->flags & EDGE_FALSE_VALUE) != 0;
|
bool is_else_edge = (e->flags & EDGE_FALSE_VALUE) != 0;
|
|
|
/* Predicates may be a single SSA name or NAME OP VAL. */
|
/* Predicates may be a single SSA name or NAME OP VAL. */
|
if (cond == name)
|
if (cond == name)
|
{
|
{
|
/* If the predicate is a name, it must be NAME, in which
|
/* If the predicate is a name, it must be NAME, in which
|
case we create the predicate NAME == true or
|
case we create the predicate NAME == true or
|
NAME == false accordingly. */
|
NAME == false accordingly. */
|
comp_code = EQ_EXPR;
|
comp_code = EQ_EXPR;
|
val = (is_else_edge) ? boolean_false_node : boolean_true_node;
|
val = (is_else_edge) ? boolean_false_node : boolean_true_node;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Otherwise, we have a comparison of the form NAME COMP VAL
|
/* Otherwise, we have a comparison of the form NAME COMP VAL
|
or VAL COMP NAME. */
|
or VAL COMP NAME. */
|
if (name == TREE_OPERAND (cond, 1))
|
if (name == TREE_OPERAND (cond, 1))
|
{
|
{
|
/* If the predicate is of the form VAL COMP NAME, flip
|
/* If the predicate is of the form VAL COMP NAME, flip
|
COMP around because we need to register NAME as the
|
COMP around because we need to register NAME as the
|
first operand in the predicate. */
|
first operand in the predicate. */
|
comp_code = swap_tree_comparison (TREE_CODE (cond));
|
comp_code = swap_tree_comparison (TREE_CODE (cond));
|
val = TREE_OPERAND (cond, 0);
|
val = TREE_OPERAND (cond, 0);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* The comparison is of the form NAME COMP VAL, so the
|
/* The comparison is of the form NAME COMP VAL, so the
|
comparison code remains unchanged. */
|
comparison code remains unchanged. */
|
comp_code = TREE_CODE (cond);
|
comp_code = TREE_CODE (cond);
|
val = TREE_OPERAND (cond, 1);
|
val = TREE_OPERAND (cond, 1);
|
}
|
}
|
|
|
/* If we are inserting the assertion on the ELSE edge, we
|
/* If we are inserting the assertion on the ELSE edge, we
|
need to invert the sign comparison. */
|
need to invert the sign comparison. */
|
if (is_else_edge)
|
if (is_else_edge)
|
comp_code = invert_tree_comparison (comp_code, 0);
|
comp_code = invert_tree_comparison (comp_code, 0);
|
|
|
/* Do not register always-false predicates. FIXME, this
|
/* Do not register always-false predicates. FIXME, this
|
works around a limitation in fold() when dealing with
|
works around a limitation in fold() when dealing with
|
enumerations. Given 'enum { N1, N2 } x;', fold will not
|
enumerations. Given 'enum { N1, N2 } x;', fold will not
|
fold 'if (x > N2)' to 'if (0)'. */
|
fold 'if (x > N2)' to 'if (0)'. */
|
if ((comp_code == GT_EXPR || comp_code == LT_EXPR)
|
if ((comp_code == GT_EXPR || comp_code == LT_EXPR)
|
&& (INTEGRAL_TYPE_P (TREE_TYPE (val))
|
&& (INTEGRAL_TYPE_P (TREE_TYPE (val))
|
|| SCALAR_FLOAT_TYPE_P (TREE_TYPE (val))))
|
|| SCALAR_FLOAT_TYPE_P (TREE_TYPE (val))))
|
{
|
{
|
tree min = TYPE_MIN_VALUE (TREE_TYPE (val));
|
tree min = TYPE_MIN_VALUE (TREE_TYPE (val));
|
tree max = TYPE_MAX_VALUE (TREE_TYPE (val));
|
tree max = TYPE_MAX_VALUE (TREE_TYPE (val));
|
|
|
if (comp_code == GT_EXPR && compare_values (val, max) == 0)
|
if (comp_code == GT_EXPR && compare_values (val, max) == 0)
|
return false;
|
return false;
|
|
|
if (comp_code == LT_EXPR && compare_values (val, min) == 0)
|
if (comp_code == LT_EXPR && compare_values (val, min) == 0)
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* FIXME. Handle SWITCH_EXPR. */
|
/* FIXME. Handle SWITCH_EXPR. */
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
register_new_assert_for (name, comp_code, val, NULL, e, si);
|
register_new_assert_for (name, comp_code, val, NULL, e, si);
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
static bool find_assert_locations (basic_block bb);
|
static bool find_assert_locations (basic_block bb);
|
|
|
/* Determine whether the outgoing edges of BB should receive an
|
/* Determine whether the outgoing edges of BB should receive an
|
ASSERT_EXPR for each of the operands of BB's last statement. The
|
ASSERT_EXPR for each of the operands of BB's last statement. The
|
last statement of BB must be a COND_EXPR or a SWITCH_EXPR.
|
last statement of BB must be a COND_EXPR or a SWITCH_EXPR.
|
|
|
If any of the sub-graphs rooted at BB have an interesting use of
|
If any of the sub-graphs rooted at BB have an interesting use of
|
the predicate operands, an assert location node is added to the
|
the predicate operands, an assert location node is added to the
|
list of assertions for the corresponding operands. */
|
list of assertions for the corresponding operands. */
|
|
|
static bool
|
static bool
|
find_conditional_asserts (basic_block bb)
|
find_conditional_asserts (basic_block bb)
|
{
|
{
|
bool need_assert;
|
bool need_assert;
|
block_stmt_iterator last_si;
|
block_stmt_iterator last_si;
|
tree op, last;
|
tree op, last;
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
|
|
need_assert = false;
|
need_assert = false;
|
last_si = bsi_last (bb);
|
last_si = bsi_last (bb);
|
last = bsi_stmt (last_si);
|
last = bsi_stmt (last_si);
|
|
|
/* Look for uses of the operands in each of the sub-graphs
|
/* Look for uses of the operands in each of the sub-graphs
|
rooted at BB. We need to check each of the outgoing edges
|
rooted at BB. We need to check each of the outgoing edges
|
separately, so that we know what kind of ASSERT_EXPR to
|
separately, so that we know what kind of ASSERT_EXPR to
|
insert. */
|
insert. */
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
{
|
{
|
if (e->dest == bb)
|
if (e->dest == bb)
|
continue;
|
continue;
|
|
|
/* Remove the COND_EXPR operands from the FOUND_IN_SUBGRAPH bitmap.
|
/* Remove the COND_EXPR operands from the FOUND_IN_SUBGRAPH bitmap.
|
Otherwise, when we finish traversing each of the sub-graphs, we
|
Otherwise, when we finish traversing each of the sub-graphs, we
|
won't know whether the variables were found in the sub-graphs or
|
won't know whether the variables were found in the sub-graphs or
|
if they had been found in a block upstream from BB.
|
if they had been found in a block upstream from BB.
|
|
|
This is actually a bad idea is some cases, particularly jump
|
This is actually a bad idea is some cases, particularly jump
|
threading. Consider a CFG like the following:
|
threading. Consider a CFG like the following:
|
|
|
0
|
0
|
/|
|
/|
|
1 |
|
1 |
|
\|
|
\|
|
2
|
2
|
/ \
|
/ \
|
3 4
|
3 4
|
|
|
Assume that one or more operands in the conditional at the
|
Assume that one or more operands in the conditional at the
|
end of block 0 are used in a conditional in block 2, but not
|
end of block 0 are used in a conditional in block 2, but not
|
anywhere in block 1. In this case we will not insert any
|
anywhere in block 1. In this case we will not insert any
|
assert statements in block 1, which may cause us to miss
|
assert statements in block 1, which may cause us to miss
|
opportunities to optimize, particularly for jump threading. */
|
opportunities to optimize, particularly for jump threading. */
|
FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE)
|
FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE)
|
RESET_BIT (found_in_subgraph, SSA_NAME_VERSION (op));
|
RESET_BIT (found_in_subgraph, SSA_NAME_VERSION (op));
|
|
|
/* Traverse the strictly dominated sub-graph rooted at E->DEST
|
/* Traverse the strictly dominated sub-graph rooted at E->DEST
|
to determine if any of the operands in the conditional
|
to determine if any of the operands in the conditional
|
predicate are used. */
|
predicate are used. */
|
if (e->dest != bb)
|
if (e->dest != bb)
|
need_assert |= find_assert_locations (e->dest);
|
need_assert |= find_assert_locations (e->dest);
|
|
|
/* Register the necessary assertions for each operand in the
|
/* Register the necessary assertions for each operand in the
|
conditional predicate. */
|
conditional predicate. */
|
FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE)
|
FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE)
|
need_assert |= register_edge_assert_for (op, e, last_si);
|
need_assert |= register_edge_assert_for (op, e, last_si);
|
}
|
}
|
|
|
/* Finally, indicate that we have found the operands in the
|
/* Finally, indicate that we have found the operands in the
|
conditional. */
|
conditional. */
|
FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE)
|
FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE)
|
SET_BIT (found_in_subgraph, SSA_NAME_VERSION (op));
|
SET_BIT (found_in_subgraph, SSA_NAME_VERSION (op));
|
|
|
return need_assert;
|
return need_assert;
|
}
|
}
|
|
|
|
|
/* Traverse all the statements in block BB looking for statements that
|
/* Traverse all the statements in block BB looking for statements that
|
may generate useful assertions for the SSA names in their operand.
|
may generate useful assertions for the SSA names in their operand.
|
If a statement produces a useful assertion A for name N_i, then the
|
If a statement produces a useful assertion A for name N_i, then the
|
list of assertions already generated for N_i is scanned to
|
list of assertions already generated for N_i is scanned to
|
determine if A is actually needed.
|
determine if A is actually needed.
|
|
|
If N_i already had the assertion A at a location dominating the
|
If N_i already had the assertion A at a location dominating the
|
current location, then nothing needs to be done. Otherwise, the
|
current location, then nothing needs to be done. Otherwise, the
|
new location for A is recorded instead.
|
new location for A is recorded instead.
|
|
|
1- For every statement S in BB, all the variables used by S are
|
1- For every statement S in BB, all the variables used by S are
|
added to bitmap FOUND_IN_SUBGRAPH.
|
added to bitmap FOUND_IN_SUBGRAPH.
|
|
|
2- If statement S uses an operand N in a way that exposes a known
|
2- If statement S uses an operand N in a way that exposes a known
|
value range for N, then if N was not already generated by an
|
value range for N, then if N was not already generated by an
|
ASSERT_EXPR, create a new assert location for N. For instance,
|
ASSERT_EXPR, create a new assert location for N. For instance,
|
if N is a pointer and the statement dereferences it, we can
|
if N is a pointer and the statement dereferences it, we can
|
assume that N is not NULL.
|
assume that N is not NULL.
|
|
|
3- COND_EXPRs are a special case of #2. We can derive range
|
3- COND_EXPRs are a special case of #2. We can derive range
|
information from the predicate but need to insert different
|
information from the predicate but need to insert different
|
ASSERT_EXPRs for each of the sub-graphs rooted at the
|
ASSERT_EXPRs for each of the sub-graphs rooted at the
|
conditional block. If the last statement of BB is a conditional
|
conditional block. If the last statement of BB is a conditional
|
expression of the form 'X op Y', then
|
expression of the form 'X op Y', then
|
|
|
a) Remove X and Y from the set FOUND_IN_SUBGRAPH.
|
a) Remove X and Y from the set FOUND_IN_SUBGRAPH.
|
|
|
b) If the conditional is the only entry point to the sub-graph
|
b) If the conditional is the only entry point to the sub-graph
|
corresponding to the THEN_CLAUSE, recurse into it. On
|
corresponding to the THEN_CLAUSE, recurse into it. On
|
return, if X and/or Y are marked in FOUND_IN_SUBGRAPH, then
|
return, if X and/or Y are marked in FOUND_IN_SUBGRAPH, then
|
an ASSERT_EXPR is added for the corresponding variable.
|
an ASSERT_EXPR is added for the corresponding variable.
|
|
|
c) Repeat step (b) on the ELSE_CLAUSE.
|
c) Repeat step (b) on the ELSE_CLAUSE.
|
|
|
d) Mark X and Y in FOUND_IN_SUBGRAPH.
|
d) Mark X and Y in FOUND_IN_SUBGRAPH.
|
|
|
For instance,
|
For instance,
|
|
|
if (a == 9)
|
if (a == 9)
|
b = a;
|
b = a;
|
else
|
else
|
b = c + 1;
|
b = c + 1;
|
|
|
In this case, an assertion on the THEN clause is useful to
|
In this case, an assertion on the THEN clause is useful to
|
determine that 'a' is always 9 on that edge. However, an assertion
|
determine that 'a' is always 9 on that edge. However, an assertion
|
on the ELSE clause would be unnecessary.
|
on the ELSE clause would be unnecessary.
|
|
|
4- If BB does not end in a conditional expression, then we recurse
|
4- If BB does not end in a conditional expression, then we recurse
|
into BB's dominator children.
|
into BB's dominator children.
|
|
|
At the end of the recursive traversal, every SSA name will have a
|
At the end of the recursive traversal, every SSA name will have a
|
list of locations where ASSERT_EXPRs should be added. When a new
|
list of locations where ASSERT_EXPRs should be added. When a new
|
location for name N is found, it is registered by calling
|
location for name N is found, it is registered by calling
|
register_new_assert_for. That function keeps track of all the
|
register_new_assert_for. That function keeps track of all the
|
registered assertions to prevent adding unnecessary assertions.
|
registered assertions to prevent adding unnecessary assertions.
|
For instance, if a pointer P_4 is dereferenced more than once in a
|
For instance, if a pointer P_4 is dereferenced more than once in a
|
dominator tree, only the location dominating all the dereference of
|
dominator tree, only the location dominating all the dereference of
|
P_4 will receive an ASSERT_EXPR.
|
P_4 will receive an ASSERT_EXPR.
|
|
|
If this function returns true, then it means that there are names
|
If this function returns true, then it means that there are names
|
for which we need to generate ASSERT_EXPRs. Those assertions are
|
for which we need to generate ASSERT_EXPRs. Those assertions are
|
inserted by process_assert_insertions.
|
inserted by process_assert_insertions.
|
|
|
TODO. Handle SWITCH_EXPR. */
|
TODO. Handle SWITCH_EXPR. */
|
|
|
static bool
|
static bool
|
find_assert_locations (basic_block bb)
|
find_assert_locations (basic_block bb)
|
{
|
{
|
block_stmt_iterator si;
|
block_stmt_iterator si;
|
tree last, phi;
|
tree last, phi;
|
bool need_assert;
|
bool need_assert;
|
basic_block son;
|
basic_block son;
|
|
|
if (TEST_BIT (blocks_visited, bb->index))
|
if (TEST_BIT (blocks_visited, bb->index))
|
return false;
|
return false;
|
|
|
SET_BIT (blocks_visited, bb->index);
|
SET_BIT (blocks_visited, bb->index);
|
|
|
need_assert = false;
|
need_assert = false;
|
|
|
/* Traverse all PHI nodes in BB marking used operands. */
|
/* Traverse all PHI nodes in BB marking used operands. */
|
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
|
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
|
{
|
{
|
use_operand_p arg_p;
|
use_operand_p arg_p;
|
ssa_op_iter i;
|
ssa_op_iter i;
|
|
|
FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_USE)
|
FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_USE)
|
{
|
{
|
tree arg = USE_FROM_PTR (arg_p);
|
tree arg = USE_FROM_PTR (arg_p);
|
if (TREE_CODE (arg) == SSA_NAME)
|
if (TREE_CODE (arg) == SSA_NAME)
|
{
|
{
|
gcc_assert (is_gimple_reg (PHI_RESULT (phi)));
|
gcc_assert (is_gimple_reg (PHI_RESULT (phi)));
|
SET_BIT (found_in_subgraph, SSA_NAME_VERSION (arg));
|
SET_BIT (found_in_subgraph, SSA_NAME_VERSION (arg));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Traverse all the statements in BB marking used names and looking
|
/* Traverse all the statements in BB marking used names and looking
|
for statements that may infer assertions for their used operands. */
|
for statements that may infer assertions for their used operands. */
|
last = NULL_TREE;
|
last = NULL_TREE;
|
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
|
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
|
{
|
{
|
tree stmt, op;
|
tree stmt, op;
|
ssa_op_iter i;
|
ssa_op_iter i;
|
|
|
stmt = bsi_stmt (si);
|
stmt = bsi_stmt (si);
|
|
|
/* See if we can derive an assertion for any of STMT's operands. */
|
/* See if we can derive an assertion for any of STMT's operands. */
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE)
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE)
|
{
|
{
|
tree value;
|
tree value;
|
enum tree_code comp_code;
|
enum tree_code comp_code;
|
|
|
/* Mark OP in bitmap FOUND_IN_SUBGRAPH. If STMT is inside
|
/* Mark OP in bitmap FOUND_IN_SUBGRAPH. If STMT is inside
|
the sub-graph of a conditional block, when we return from
|
the sub-graph of a conditional block, when we return from
|
this recursive walk, our parent will use the
|
this recursive walk, our parent will use the
|
FOUND_IN_SUBGRAPH bitset to determine if one of the
|
FOUND_IN_SUBGRAPH bitset to determine if one of the
|
operands it was looking for was present in the sub-graph. */
|
operands it was looking for was present in the sub-graph. */
|
SET_BIT (found_in_subgraph, SSA_NAME_VERSION (op));
|
SET_BIT (found_in_subgraph, SSA_NAME_VERSION (op));
|
|
|
/* If OP is used in such a way that we can infer a value
|
/* If OP is used in such a way that we can infer a value
|
range for it, and we don't find a previous assertion for
|
range for it, and we don't find a previous assertion for
|
it, create a new assertion location node for OP. */
|
it, create a new assertion location node for OP. */
|
if (infer_value_range (stmt, op, &comp_code, &value))
|
if (infer_value_range (stmt, op, &comp_code, &value))
|
{
|
{
|
/* If we are able to infer a nonzero value range for OP,
|
/* If we are able to infer a nonzero value range for OP,
|
then walk backwards through the use-def chain to see if OP
|
then walk backwards through the use-def chain to see if OP
|
was set via a typecast.
|
was set via a typecast.
|
|
|
If so, then we can also infer a nonzero value range
|
If so, then we can also infer a nonzero value range
|
for the operand of the NOP_EXPR. */
|
for the operand of the NOP_EXPR. */
|
if (comp_code == NE_EXPR && integer_zerop (value))
|
if (comp_code == NE_EXPR && integer_zerop (value))
|
{
|
{
|
tree t = op;
|
tree t = op;
|
tree def_stmt = SSA_NAME_DEF_STMT (t);
|
tree def_stmt = SSA_NAME_DEF_STMT (t);
|
|
|
while (TREE_CODE (def_stmt) == MODIFY_EXPR
|
while (TREE_CODE (def_stmt) == MODIFY_EXPR
|
&& TREE_CODE (TREE_OPERAND (def_stmt, 1)) == NOP_EXPR
|
&& TREE_CODE (TREE_OPERAND (def_stmt, 1)) == NOP_EXPR
|
&& TREE_CODE (TREE_OPERAND (TREE_OPERAND (def_stmt, 1), 0)) == SSA_NAME
|
&& TREE_CODE (TREE_OPERAND (TREE_OPERAND (def_stmt, 1), 0)) == SSA_NAME
|
&& POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (def_stmt, 1), 0))))
|
&& POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (def_stmt, 1), 0))))
|
{
|
{
|
t = TREE_OPERAND (TREE_OPERAND (def_stmt, 1), 0);
|
t = TREE_OPERAND (TREE_OPERAND (def_stmt, 1), 0);
|
def_stmt = SSA_NAME_DEF_STMT (t);
|
def_stmt = SSA_NAME_DEF_STMT (t);
|
|
|
/* Note we want to register the assert for the
|
/* Note we want to register the assert for the
|
operand of the NOP_EXPR after SI, not after the
|
operand of the NOP_EXPR after SI, not after the
|
conversion. */
|
conversion. */
|
if (! has_single_use (t))
|
if (! has_single_use (t))
|
{
|
{
|
register_new_assert_for (t, comp_code, value,
|
register_new_assert_for (t, comp_code, value,
|
bb, NULL, si);
|
bb, NULL, si);
|
need_assert = true;
|
need_assert = true;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* If OP is used only once, namely in this STMT, don't
|
/* If OP is used only once, namely in this STMT, don't
|
bother creating an ASSERT_EXPR for it. Such an
|
bother creating an ASSERT_EXPR for it. Such an
|
ASSERT_EXPR would do nothing but increase compile time. */
|
ASSERT_EXPR would do nothing but increase compile time. */
|
if (!has_single_use (op))
|
if (!has_single_use (op))
|
{
|
{
|
register_new_assert_for (op, comp_code, value, bb, NULL, si);
|
register_new_assert_for (op, comp_code, value, bb, NULL, si);
|
need_assert = true;
|
need_assert = true;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Remember the last statement of the block. */
|
/* Remember the last statement of the block. */
|
last = stmt;
|
last = stmt;
|
}
|
}
|
|
|
/* If BB's last statement is a conditional expression
|
/* If BB's last statement is a conditional expression
|
involving integer operands, recurse into each of the sub-graphs
|
involving integer operands, recurse into each of the sub-graphs
|
rooted at BB to determine if we need to add ASSERT_EXPRs. */
|
rooted at BB to determine if we need to add ASSERT_EXPRs. */
|
if (last
|
if (last
|
&& TREE_CODE (last) == COND_EXPR
|
&& TREE_CODE (last) == COND_EXPR
|
&& !fp_predicate (COND_EXPR_COND (last))
|
&& !fp_predicate (COND_EXPR_COND (last))
|
&& !ZERO_SSA_OPERANDS (last, SSA_OP_USE))
|
&& !ZERO_SSA_OPERANDS (last, SSA_OP_USE))
|
need_assert |= find_conditional_asserts (bb);
|
need_assert |= find_conditional_asserts (bb);
|
|
|
/* Recurse into the dominator children of BB. */
|
/* Recurse into the dominator children of BB. */
|
for (son = first_dom_son (CDI_DOMINATORS, bb);
|
for (son = first_dom_son (CDI_DOMINATORS, bb);
|
son;
|
son;
|
son = next_dom_son (CDI_DOMINATORS, son))
|
son = next_dom_son (CDI_DOMINATORS, son))
|
need_assert |= find_assert_locations (son);
|
need_assert |= find_assert_locations (son);
|
|
|
return need_assert;
|
return need_assert;
|
}
|
}
|
|
|
|
|
/* Create an ASSERT_EXPR for NAME and insert it in the location
|
/* Create an ASSERT_EXPR for NAME and insert it in the location
|
indicated by LOC. Return true if we made any edge insertions. */
|
indicated by LOC. Return true if we made any edge insertions. */
|
|
|
static bool
|
static bool
|
process_assert_insertions_for (tree name, assert_locus_t loc)
|
process_assert_insertions_for (tree name, assert_locus_t loc)
|
{
|
{
|
/* Build the comparison expression NAME_i COMP_CODE VAL. */
|
/* Build the comparison expression NAME_i COMP_CODE VAL. */
|
tree stmt, cond, assert_expr;
|
tree stmt, cond, assert_expr;
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
|
|
cond = build2 (loc->comp_code, boolean_type_node, name, loc->val);
|
cond = build2 (loc->comp_code, boolean_type_node, name, loc->val);
|
assert_expr = build_assert_expr_for (cond, name);
|
assert_expr = build_assert_expr_for (cond, name);
|
|
|
if (loc->e)
|
if (loc->e)
|
{
|
{
|
/* We have been asked to insert the assertion on an edge. This
|
/* We have been asked to insert the assertion on an edge. This
|
is used only by COND_EXPR and SWITCH_EXPR assertions. */
|
is used only by COND_EXPR and SWITCH_EXPR assertions. */
|
#if defined ENABLE_CHECKING
|
#if defined ENABLE_CHECKING
|
gcc_assert (TREE_CODE (bsi_stmt (loc->si)) == COND_EXPR
|
gcc_assert (TREE_CODE (bsi_stmt (loc->si)) == COND_EXPR
|
|| TREE_CODE (bsi_stmt (loc->si)) == SWITCH_EXPR);
|
|| TREE_CODE (bsi_stmt (loc->si)) == SWITCH_EXPR);
|
#endif
|
#endif
|
|
|
bsi_insert_on_edge (loc->e, assert_expr);
|
bsi_insert_on_edge (loc->e, assert_expr);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Otherwise, we can insert right after LOC->SI iff the
|
/* Otherwise, we can insert right after LOC->SI iff the
|
statement must not be the last statement in the block. */
|
statement must not be the last statement in the block. */
|
stmt = bsi_stmt (loc->si);
|
stmt = bsi_stmt (loc->si);
|
if (!stmt_ends_bb_p (stmt))
|
if (!stmt_ends_bb_p (stmt))
|
{
|
{
|
bsi_insert_after (&loc->si, assert_expr, BSI_SAME_STMT);
|
bsi_insert_after (&loc->si, assert_expr, BSI_SAME_STMT);
|
return false;
|
return false;
|
}
|
}
|
|
|
/* If STMT must be the last statement in BB, we can only insert new
|
/* If STMT must be the last statement in BB, we can only insert new
|
assertions on the non-abnormal edge out of BB. Note that since
|
assertions on the non-abnormal edge out of BB. Note that since
|
STMT is not control flow, there may only be one non-abnormal edge
|
STMT is not control flow, there may only be one non-abnormal edge
|
out of BB. */
|
out of BB. */
|
FOR_EACH_EDGE (e, ei, loc->bb->succs)
|
FOR_EACH_EDGE (e, ei, loc->bb->succs)
|
if (!(e->flags & EDGE_ABNORMAL))
|
if (!(e->flags & EDGE_ABNORMAL))
|
{
|
{
|
bsi_insert_on_edge (e, assert_expr);
|
bsi_insert_on_edge (e, assert_expr);
|
return true;
|
return true;
|
}
|
}
|
|
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
|
|
/* Process all the insertions registered for every name N_i registered
|
/* Process all the insertions registered for every name N_i registered
|
in NEED_ASSERT_FOR. The list of assertions to be inserted are
|
in NEED_ASSERT_FOR. The list of assertions to be inserted are
|
found in ASSERTS_FOR[i]. */
|
found in ASSERTS_FOR[i]. */
|
|
|
static void
|
static void
|
process_assert_insertions (void)
|
process_assert_insertions (void)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
bool update_edges_p = false;
|
bool update_edges_p = false;
|
int num_asserts = 0;
|
int num_asserts = 0;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
dump_all_asserts (dump_file);
|
dump_all_asserts (dump_file);
|
|
|
EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi)
|
{
|
{
|
assert_locus_t loc = asserts_for[i];
|
assert_locus_t loc = asserts_for[i];
|
gcc_assert (loc);
|
gcc_assert (loc);
|
|
|
while (loc)
|
while (loc)
|
{
|
{
|
assert_locus_t next = loc->next;
|
assert_locus_t next = loc->next;
|
update_edges_p |= process_assert_insertions_for (ssa_name (i), loc);
|
update_edges_p |= process_assert_insertions_for (ssa_name (i), loc);
|
free (loc);
|
free (loc);
|
loc = next;
|
loc = next;
|
num_asserts++;
|
num_asserts++;
|
}
|
}
|
}
|
}
|
|
|
if (update_edges_p)
|
if (update_edges_p)
|
bsi_commit_edge_inserts ();
|
bsi_commit_edge_inserts ();
|
|
|
if (dump_file && (dump_flags & TDF_STATS))
|
if (dump_file && (dump_flags & TDF_STATS))
|
fprintf (dump_file, "\nNumber of ASSERT_EXPR expressions inserted: %d\n\n",
|
fprintf (dump_file, "\nNumber of ASSERT_EXPR expressions inserted: %d\n\n",
|
num_asserts);
|
num_asserts);
|
}
|
}
|
|
|
|
|
/* Traverse the flowgraph looking for conditional jumps to insert range
|
/* Traverse the flowgraph looking for conditional jumps to insert range
|
expressions. These range expressions are meant to provide information
|
expressions. These range expressions are meant to provide information
|
to optimizations that need to reason in terms of value ranges. They
|
to optimizations that need to reason in terms of value ranges. They
|
will not be expanded into RTL. For instance, given:
|
will not be expanded into RTL. For instance, given:
|
|
|
x = ...
|
x = ...
|
y = ...
|
y = ...
|
if (x < y)
|
if (x < y)
|
y = x - 2;
|
y = x - 2;
|
else
|
else
|
x = y + 3;
|
x = y + 3;
|
|
|
this pass will transform the code into:
|
this pass will transform the code into:
|
|
|
x = ...
|
x = ...
|
y = ...
|
y = ...
|
if (x < y)
|
if (x < y)
|
{
|
{
|
x = ASSERT_EXPR <x, x < y>
|
x = ASSERT_EXPR <x, x < y>
|
y = x - 2
|
y = x - 2
|
}
|
}
|
else
|
else
|
{
|
{
|
y = ASSERT_EXPR <y, x <= y>
|
y = ASSERT_EXPR <y, x <= y>
|
x = y + 3
|
x = y + 3
|
}
|
}
|
|
|
The idea is that once copy and constant propagation have run, other
|
The idea is that once copy and constant propagation have run, other
|
optimizations will be able to determine what ranges of values can 'x'
|
optimizations will be able to determine what ranges of values can 'x'
|
take in different paths of the code, simply by checking the reaching
|
take in different paths of the code, simply by checking the reaching
|
definition of 'x'. */
|
definition of 'x'. */
|
|
|
static void
|
static void
|
insert_range_assertions (void)
|
insert_range_assertions (void)
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
bool update_ssa_p;
|
bool update_ssa_p;
|
|
|
found_in_subgraph = sbitmap_alloc (num_ssa_names);
|
found_in_subgraph = sbitmap_alloc (num_ssa_names);
|
sbitmap_zero (found_in_subgraph);
|
sbitmap_zero (found_in_subgraph);
|
|
|
blocks_visited = sbitmap_alloc (last_basic_block);
|
blocks_visited = sbitmap_alloc (last_basic_block);
|
sbitmap_zero (blocks_visited);
|
sbitmap_zero (blocks_visited);
|
|
|
need_assert_for = BITMAP_ALLOC (NULL);
|
need_assert_for = BITMAP_ALLOC (NULL);
|
asserts_for = XNEWVEC (assert_locus_t, num_ssa_names);
|
asserts_for = XNEWVEC (assert_locus_t, num_ssa_names);
|
memset (asserts_for, 0, num_ssa_names * sizeof (assert_locus_t));
|
memset (asserts_for, 0, num_ssa_names * sizeof (assert_locus_t));
|
|
|
calculate_dominance_info (CDI_DOMINATORS);
|
calculate_dominance_info (CDI_DOMINATORS);
|
|
|
update_ssa_p = false;
|
update_ssa_p = false;
|
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
|
FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
|
if (find_assert_locations (e->dest))
|
if (find_assert_locations (e->dest))
|
update_ssa_p = true;
|
update_ssa_p = true;
|
|
|
if (update_ssa_p)
|
if (update_ssa_p)
|
{
|
{
|
process_assert_insertions ();
|
process_assert_insertions ();
|
update_ssa (TODO_update_ssa_no_phi);
|
update_ssa (TODO_update_ssa_no_phi);
|
}
|
}
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "\nSSA form after inserting ASSERT_EXPRs\n");
|
fprintf (dump_file, "\nSSA form after inserting ASSERT_EXPRs\n");
|
dump_function_to_file (current_function_decl, dump_file, dump_flags);
|
dump_function_to_file (current_function_decl, dump_file, dump_flags);
|
}
|
}
|
|
|
sbitmap_free (found_in_subgraph);
|
sbitmap_free (found_in_subgraph);
|
free (asserts_for);
|
free (asserts_for);
|
BITMAP_FREE (need_assert_for);
|
BITMAP_FREE (need_assert_for);
|
}
|
}
|
|
|
|
|
/* Convert range assertion expressions into the implied copies and
|
/* Convert range assertion expressions into the implied copies and
|
copy propagate away the copies. Doing the trivial copy propagation
|
copy propagate away the copies. Doing the trivial copy propagation
|
here avoids the need to run the full copy propagation pass after
|
here avoids the need to run the full copy propagation pass after
|
VRP.
|
VRP.
|
|
|
FIXME, this will eventually lead to copy propagation removing the
|
FIXME, this will eventually lead to copy propagation removing the
|
names that had useful range information attached to them. For
|
names that had useful range information attached to them. For
|
instance, if we had the assertion N_i = ASSERT_EXPR <N_j, N_j > 3>,
|
instance, if we had the assertion N_i = ASSERT_EXPR <N_j, N_j > 3>,
|
then N_i will have the range [3, +INF].
|
then N_i will have the range [3, +INF].
|
|
|
However, by converting the assertion into the implied copy
|
However, by converting the assertion into the implied copy
|
operation N_i = N_j, we will then copy-propagate N_j into the uses
|
operation N_i = N_j, we will then copy-propagate N_j into the uses
|
of N_i and lose the range information. We may want to hold on to
|
of N_i and lose the range information. We may want to hold on to
|
ASSERT_EXPRs a little while longer as the ranges could be used in
|
ASSERT_EXPRs a little while longer as the ranges could be used in
|
things like jump threading.
|
things like jump threading.
|
|
|
The problem with keeping ASSERT_EXPRs around is that passes after
|
The problem with keeping ASSERT_EXPRs around is that passes after
|
VRP need to handle them appropriately.
|
VRP need to handle them appropriately.
|
|
|
Another approach would be to make the range information a first
|
Another approach would be to make the range information a first
|
class property of the SSA_NAME so that it can be queried from
|
class property of the SSA_NAME so that it can be queried from
|
any pass. This is made somewhat more complex by the need for
|
any pass. This is made somewhat more complex by the need for
|
multiple ranges to be associated with one SSA_NAME. */
|
multiple ranges to be associated with one SSA_NAME. */
|
|
|
static void
|
static void
|
remove_range_assertions (void)
|
remove_range_assertions (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
block_stmt_iterator si;
|
block_stmt_iterator si;
|
|
|
/* Note that the BSI iterator bump happens at the bottom of the
|
/* Note that the BSI iterator bump happens at the bottom of the
|
loop and no bump is necessary if we're removing the statement
|
loop and no bump is necessary if we're removing the statement
|
referenced by the current BSI. */
|
referenced by the current BSI. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
for (si = bsi_start (bb); !bsi_end_p (si);)
|
for (si = bsi_start (bb); !bsi_end_p (si);)
|
{
|
{
|
tree stmt = bsi_stmt (si);
|
tree stmt = bsi_stmt (si);
|
tree use_stmt;
|
tree use_stmt;
|
|
|
if (TREE_CODE (stmt) == MODIFY_EXPR
|
if (TREE_CODE (stmt) == MODIFY_EXPR
|
&& TREE_CODE (TREE_OPERAND (stmt, 1)) == ASSERT_EXPR)
|
&& TREE_CODE (TREE_OPERAND (stmt, 1)) == ASSERT_EXPR)
|
{
|
{
|
tree rhs = TREE_OPERAND (stmt, 1), var;
|
tree rhs = TREE_OPERAND (stmt, 1), var;
|
tree cond = fold (ASSERT_EXPR_COND (rhs));
|
tree cond = fold (ASSERT_EXPR_COND (rhs));
|
use_operand_p use_p;
|
use_operand_p use_p;
|
imm_use_iterator iter;
|
imm_use_iterator iter;
|
|
|
gcc_assert (cond != boolean_false_node);
|
gcc_assert (cond != boolean_false_node);
|
|
|
/* Propagate the RHS into every use of the LHS. */
|
/* Propagate the RHS into every use of the LHS. */
|
var = ASSERT_EXPR_VAR (rhs);
|
var = ASSERT_EXPR_VAR (rhs);
|
FOR_EACH_IMM_USE_STMT (use_stmt, iter, TREE_OPERAND (stmt, 0))
|
FOR_EACH_IMM_USE_STMT (use_stmt, iter, TREE_OPERAND (stmt, 0))
|
FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
|
FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
|
{
|
{
|
SET_USE (use_p, var);
|
SET_USE (use_p, var);
|
gcc_assert (TREE_CODE (var) == SSA_NAME);
|
gcc_assert (TREE_CODE (var) == SSA_NAME);
|
}
|
}
|
|
|
/* And finally, remove the copy, it is not needed. */
|
/* And finally, remove the copy, it is not needed. */
|
bsi_remove (&si, true);
|
bsi_remove (&si, true);
|
}
|
}
|
else
|
else
|
bsi_next (&si);
|
bsi_next (&si);
|
}
|
}
|
|
|
sbitmap_free (blocks_visited);
|
sbitmap_free (blocks_visited);
|
}
|
}
|
|
|
|
|
/* Return true if STMT is interesting for VRP. */
|
/* Return true if STMT is interesting for VRP. */
|
|
|
static bool
|
static bool
|
stmt_interesting_for_vrp (tree stmt)
|
stmt_interesting_for_vrp (tree stmt)
|
{
|
{
|
if (TREE_CODE (stmt) == PHI_NODE
|
if (TREE_CODE (stmt) == PHI_NODE
|
&& is_gimple_reg (PHI_RESULT (stmt))
|
&& is_gimple_reg (PHI_RESULT (stmt))
|
&& (INTEGRAL_TYPE_P (TREE_TYPE (PHI_RESULT (stmt)))
|
&& (INTEGRAL_TYPE_P (TREE_TYPE (PHI_RESULT (stmt)))
|
|| POINTER_TYPE_P (TREE_TYPE (PHI_RESULT (stmt)))))
|
|| POINTER_TYPE_P (TREE_TYPE (PHI_RESULT (stmt)))))
|
return true;
|
return true;
|
else if (TREE_CODE (stmt) == MODIFY_EXPR)
|
else if (TREE_CODE (stmt) == MODIFY_EXPR)
|
{
|
{
|
tree lhs = TREE_OPERAND (stmt, 0);
|
tree lhs = TREE_OPERAND (stmt, 0);
|
tree rhs = TREE_OPERAND (stmt, 1);
|
tree rhs = TREE_OPERAND (stmt, 1);
|
|
|
/* In general, assignments with virtual operands are not useful
|
/* In general, assignments with virtual operands are not useful
|
for deriving ranges, with the obvious exception of calls to
|
for deriving ranges, with the obvious exception of calls to
|
builtin functions. */
|
builtin functions. */
|
if (TREE_CODE (lhs) == SSA_NAME
|
if (TREE_CODE (lhs) == SSA_NAME
|
&& (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
|
&& (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
|
|| POINTER_TYPE_P (TREE_TYPE (lhs)))
|
|| POINTER_TYPE_P (TREE_TYPE (lhs)))
|
&& ((TREE_CODE (rhs) == CALL_EXPR
|
&& ((TREE_CODE (rhs) == CALL_EXPR
|
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == ADDR_EXPR
|
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == ADDR_EXPR
|
&& DECL_P (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0))
|
&& DECL_P (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0))
|
&& DECL_IS_BUILTIN (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0)))
|
&& DECL_IS_BUILTIN (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0)))
|
|| ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)))
|
|| ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)))
|
return true;
|
return true;
|
}
|
}
|
else if (TREE_CODE (stmt) == COND_EXPR || TREE_CODE (stmt) == SWITCH_EXPR)
|
else if (TREE_CODE (stmt) == COND_EXPR || TREE_CODE (stmt) == SWITCH_EXPR)
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Initialize local data structures for VRP. */
|
/* Initialize local data structures for VRP. */
|
|
|
static void
|
static void
|
vrp_initialize (void)
|
vrp_initialize (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
vr_value = XNEWVEC (value_range_t *, num_ssa_names);
|
vr_value = XNEWVEC (value_range_t *, num_ssa_names);
|
memset (vr_value, 0, num_ssa_names * sizeof (value_range_t *));
|
memset (vr_value, 0, num_ssa_names * sizeof (value_range_t *));
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
block_stmt_iterator si;
|
block_stmt_iterator si;
|
tree phi;
|
tree phi;
|
|
|
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
|
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
|
{
|
{
|
if (!stmt_interesting_for_vrp (phi))
|
if (!stmt_interesting_for_vrp (phi))
|
{
|
{
|
tree lhs = PHI_RESULT (phi);
|
tree lhs = PHI_RESULT (phi);
|
set_value_range_to_varying (get_value_range (lhs));
|
set_value_range_to_varying (get_value_range (lhs));
|
DONT_SIMULATE_AGAIN (phi) = true;
|
DONT_SIMULATE_AGAIN (phi) = true;
|
}
|
}
|
else
|
else
|
DONT_SIMULATE_AGAIN (phi) = false;
|
DONT_SIMULATE_AGAIN (phi) = false;
|
}
|
}
|
|
|
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
|
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
|
{
|
{
|
tree stmt = bsi_stmt (si);
|
tree stmt = bsi_stmt (si);
|
|
|
if (!stmt_interesting_for_vrp (stmt))
|
if (!stmt_interesting_for_vrp (stmt))
|
{
|
{
|
ssa_op_iter i;
|
ssa_op_iter i;
|
tree def;
|
tree def;
|
FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
|
FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
|
set_value_range_to_varying (get_value_range (def));
|
set_value_range_to_varying (get_value_range (def));
|
DONT_SIMULATE_AGAIN (stmt) = true;
|
DONT_SIMULATE_AGAIN (stmt) = true;
|
}
|
}
|
else
|
else
|
{
|
{
|
DONT_SIMULATE_AGAIN (stmt) = false;
|
DONT_SIMULATE_AGAIN (stmt) = false;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Visit assignment STMT. If it produces an interesting range, record
|
/* Visit assignment STMT. If it produces an interesting range, record
|
the SSA name in *OUTPUT_P. */
|
the SSA name in *OUTPUT_P. */
|
|
|
static enum ssa_prop_result
|
static enum ssa_prop_result
|
vrp_visit_assignment (tree stmt, tree *output_p)
|
vrp_visit_assignment (tree stmt, tree *output_p)
|
{
|
{
|
tree lhs, rhs, def;
|
tree lhs, rhs, def;
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
|
|
lhs = TREE_OPERAND (stmt, 0);
|
lhs = TREE_OPERAND (stmt, 0);
|
rhs = TREE_OPERAND (stmt, 1);
|
rhs = TREE_OPERAND (stmt, 1);
|
|
|
/* We only keep track of ranges in integral and pointer types. */
|
/* We only keep track of ranges in integral and pointer types. */
|
if (TREE_CODE (lhs) == SSA_NAME
|
if (TREE_CODE (lhs) == SSA_NAME
|
&& ((INTEGRAL_TYPE_P (TREE_TYPE (lhs))
|
&& ((INTEGRAL_TYPE_P (TREE_TYPE (lhs))
|
/* It is valid to have NULL MIN/MAX values on a type. See
|
/* It is valid to have NULL MIN/MAX values on a type. See
|
build_range_type. */
|
build_range_type. */
|
&& TYPE_MIN_VALUE (TREE_TYPE (lhs))
|
&& TYPE_MIN_VALUE (TREE_TYPE (lhs))
|
&& TYPE_MAX_VALUE (TREE_TYPE (lhs)))
|
&& TYPE_MAX_VALUE (TREE_TYPE (lhs)))
|
|| POINTER_TYPE_P (TREE_TYPE (lhs))))
|
|| POINTER_TYPE_P (TREE_TYPE (lhs))))
|
{
|
{
|
struct loop *l;
|
struct loop *l;
|
value_range_t new_vr = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
|
value_range_t new_vr = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
|
|
|
extract_range_from_expr (&new_vr, rhs);
|
extract_range_from_expr (&new_vr, rhs);
|
|
|
/* If STMT is inside a loop, we may be able to know something
|
/* If STMT is inside a loop, we may be able to know something
|
else about the range of LHS by examining scalar evolution
|
else about the range of LHS by examining scalar evolution
|
information. */
|
information. */
|
if (current_loops && (l = loop_containing_stmt (stmt)))
|
if (current_loops && (l = loop_containing_stmt (stmt)))
|
adjust_range_with_scev (&new_vr, l, stmt, lhs);
|
adjust_range_with_scev (&new_vr, l, stmt, lhs);
|
|
|
if (update_value_range (lhs, &new_vr))
|
if (update_value_range (lhs, &new_vr))
|
{
|
{
|
*output_p = lhs;
|
*output_p = lhs;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Found new range for ");
|
fprintf (dump_file, "Found new range for ");
|
print_generic_expr (dump_file, lhs, 0);
|
print_generic_expr (dump_file, lhs, 0);
|
fprintf (dump_file, ": ");
|
fprintf (dump_file, ": ");
|
dump_value_range (dump_file, &new_vr);
|
dump_value_range (dump_file, &new_vr);
|
fprintf (dump_file, "\n\n");
|
fprintf (dump_file, "\n\n");
|
}
|
}
|
|
|
if (new_vr.type == VR_VARYING)
|
if (new_vr.type == VR_VARYING)
|
return SSA_PROP_VARYING;
|
return SSA_PROP_VARYING;
|
|
|
return SSA_PROP_INTERESTING;
|
return SSA_PROP_INTERESTING;
|
}
|
}
|
|
|
return SSA_PROP_NOT_INTERESTING;
|
return SSA_PROP_NOT_INTERESTING;
|
}
|
}
|
|
|
/* Every other statement produces no useful ranges. */
|
/* Every other statement produces no useful ranges. */
|
FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
|
FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
|
set_value_range_to_varying (get_value_range (def));
|
set_value_range_to_varying (get_value_range (def));
|
|
|
return SSA_PROP_VARYING;
|
return SSA_PROP_VARYING;
|
}
|
}
|
|
|
|
|
/* Compare all the value ranges for names equivalent to VAR with VAL
|
/* Compare all the value ranges for names equivalent to VAR with VAL
|
using comparison code COMP. Return the same value returned by
|
using comparison code COMP. Return the same value returned by
|
compare_range_with_value, including the setting of
|
compare_range_with_value, including the setting of
|
*STRICT_OVERFLOW_P. */
|
*STRICT_OVERFLOW_P. */
|
|
|
static tree
|
static tree
|
compare_name_with_value (enum tree_code comp, tree var, tree val,
|
compare_name_with_value (enum tree_code comp, tree var, tree val,
|
bool *strict_overflow_p)
|
bool *strict_overflow_p)
|
{
|
{
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned i;
|
unsigned i;
|
bitmap e;
|
bitmap e;
|
tree retval, t;
|
tree retval, t;
|
int used_strict_overflow;
|
int used_strict_overflow;
|
|
|
t = retval = NULL_TREE;
|
t = retval = NULL_TREE;
|
|
|
/* Get the set of equivalences for VAR. */
|
/* Get the set of equivalences for VAR. */
|
e = get_value_range (var)->equiv;
|
e = get_value_range (var)->equiv;
|
|
|
/* Add VAR to its own set of equivalences so that VAR's value range
|
/* Add VAR to its own set of equivalences so that VAR's value range
|
is processed by this loop (otherwise, we would have to replicate
|
is processed by this loop (otherwise, we would have to replicate
|
the body of the loop just to check VAR's value range). */
|
the body of the loop just to check VAR's value range). */
|
bitmap_set_bit (e, SSA_NAME_VERSION (var));
|
bitmap_set_bit (e, SSA_NAME_VERSION (var));
|
|
|
/* Start at -1. Set it to 0 if we do a comparison without relying
|
/* Start at -1. Set it to 0 if we do a comparison without relying
|
on overflow, or 1 if all comparisons rely on overflow. */
|
on overflow, or 1 if all comparisons rely on overflow. */
|
used_strict_overflow = -1;
|
used_strict_overflow = -1;
|
|
|
EXECUTE_IF_SET_IN_BITMAP (e, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (e, 0, i, bi)
|
{
|
{
|
bool sop;
|
bool sop;
|
|
|
value_range_t equiv_vr = *(vr_value[i]);
|
value_range_t equiv_vr = *(vr_value[i]);
|
|
|
/* If name N_i does not have a valid range, use N_i as its own
|
/* If name N_i does not have a valid range, use N_i as its own
|
range. This allows us to compare against names that may
|
range. This allows us to compare against names that may
|
have N_i in their ranges. */
|
have N_i in their ranges. */
|
if (equiv_vr.type == VR_VARYING || equiv_vr.type == VR_UNDEFINED)
|
if (equiv_vr.type == VR_VARYING || equiv_vr.type == VR_UNDEFINED)
|
{
|
{
|
equiv_vr.type = VR_RANGE;
|
equiv_vr.type = VR_RANGE;
|
equiv_vr.min = ssa_name (i);
|
equiv_vr.min = ssa_name (i);
|
equiv_vr.max = ssa_name (i);
|
equiv_vr.max = ssa_name (i);
|
}
|
}
|
|
|
sop = false;
|
sop = false;
|
t = compare_range_with_value (comp, &equiv_vr, val, &sop);
|
t = compare_range_with_value (comp, &equiv_vr, val, &sop);
|
if (t)
|
if (t)
|
{
|
{
|
/* If we get different answers from different members
|
/* If we get different answers from different members
|
of the equivalence set this check must be in a dead
|
of the equivalence set this check must be in a dead
|
code region. Folding it to a trap representation
|
code region. Folding it to a trap representation
|
would be correct here. For now just return don't-know. */
|
would be correct here. For now just return don't-know. */
|
if (retval != NULL
|
if (retval != NULL
|
&& t != retval)
|
&& t != retval)
|
{
|
{
|
retval = NULL_TREE;
|
retval = NULL_TREE;
|
break;
|
break;
|
}
|
}
|
retval = t;
|
retval = t;
|
|
|
if (!sop)
|
if (!sop)
|
used_strict_overflow = 0;
|
used_strict_overflow = 0;
|
else if (used_strict_overflow < 0)
|
else if (used_strict_overflow < 0)
|
used_strict_overflow = 1;
|
used_strict_overflow = 1;
|
}
|
}
|
}
|
}
|
|
|
/* Remove VAR from its own equivalence set. */
|
/* Remove VAR from its own equivalence set. */
|
bitmap_clear_bit (e, SSA_NAME_VERSION (var));
|
bitmap_clear_bit (e, SSA_NAME_VERSION (var));
|
|
|
if (retval)
|
if (retval)
|
{
|
{
|
if (used_strict_overflow > 0)
|
if (used_strict_overflow > 0)
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
return retval;
|
return retval;
|
}
|
}
|
|
|
/* We couldn't find a non-NULL value for the predicate. */
|
/* We couldn't find a non-NULL value for the predicate. */
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
|
|
/* Given a comparison code COMP and names N1 and N2, compare all the
|
/* Given a comparison code COMP and names N1 and N2, compare all the
|
ranges equivalent to N1 against all the ranges equivalent to N2
|
ranges equivalent to N1 against all the ranges equivalent to N2
|
to determine the value of N1 COMP N2. Return the same value
|
to determine the value of N1 COMP N2. Return the same value
|
returned by compare_ranges. Set *STRICT_OVERFLOW_P to indicate
|
returned by compare_ranges. Set *STRICT_OVERFLOW_P to indicate
|
whether we relied on an overflow infinity in the comparison. */
|
whether we relied on an overflow infinity in the comparison. */
|
|
|
|
|
static tree
|
static tree
|
compare_names (enum tree_code comp, tree n1, tree n2,
|
compare_names (enum tree_code comp, tree n1, tree n2,
|
bool *strict_overflow_p)
|
bool *strict_overflow_p)
|
{
|
{
|
tree t, retval;
|
tree t, retval;
|
bitmap e1, e2;
|
bitmap e1, e2;
|
bitmap_iterator bi1, bi2;
|
bitmap_iterator bi1, bi2;
|
unsigned i1, i2;
|
unsigned i1, i2;
|
int used_strict_overflow;
|
int used_strict_overflow;
|
|
|
/* Compare the ranges of every name equivalent to N1 against the
|
/* Compare the ranges of every name equivalent to N1 against the
|
ranges of every name equivalent to N2. */
|
ranges of every name equivalent to N2. */
|
e1 = get_value_range (n1)->equiv;
|
e1 = get_value_range (n1)->equiv;
|
e2 = get_value_range (n2)->equiv;
|
e2 = get_value_range (n2)->equiv;
|
|
|
/* Add N1 and N2 to their own set of equivalences to avoid
|
/* Add N1 and N2 to their own set of equivalences to avoid
|
duplicating the body of the loop just to check N1 and N2
|
duplicating the body of the loop just to check N1 and N2
|
ranges. */
|
ranges. */
|
bitmap_set_bit (e1, SSA_NAME_VERSION (n1));
|
bitmap_set_bit (e1, SSA_NAME_VERSION (n1));
|
bitmap_set_bit (e2, SSA_NAME_VERSION (n2));
|
bitmap_set_bit (e2, SSA_NAME_VERSION (n2));
|
|
|
/* If the equivalence sets have a common intersection, then the two
|
/* If the equivalence sets have a common intersection, then the two
|
names can be compared without checking their ranges. */
|
names can be compared without checking their ranges. */
|
if (bitmap_intersect_p (e1, e2))
|
if (bitmap_intersect_p (e1, e2))
|
{
|
{
|
bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
|
bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
|
bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
|
bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
|
|
|
return (comp == EQ_EXPR || comp == GE_EXPR || comp == LE_EXPR)
|
return (comp == EQ_EXPR || comp == GE_EXPR || comp == LE_EXPR)
|
? boolean_true_node
|
? boolean_true_node
|
: boolean_false_node;
|
: boolean_false_node;
|
}
|
}
|
|
|
/* Start at -1. Set it to 0 if we do a comparison without relying
|
/* Start at -1. Set it to 0 if we do a comparison without relying
|
on overflow, or 1 if all comparisons rely on overflow. */
|
on overflow, or 1 if all comparisons rely on overflow. */
|
used_strict_overflow = -1;
|
used_strict_overflow = -1;
|
|
|
/* Otherwise, compare all the equivalent ranges. First, add N1 and
|
/* Otherwise, compare all the equivalent ranges. First, add N1 and
|
N2 to their own set of equivalences to avoid duplicating the body
|
N2 to their own set of equivalences to avoid duplicating the body
|
of the loop just to check N1 and N2 ranges. */
|
of the loop just to check N1 and N2 ranges. */
|
EXECUTE_IF_SET_IN_BITMAP (e1, 0, i1, bi1)
|
EXECUTE_IF_SET_IN_BITMAP (e1, 0, i1, bi1)
|
{
|
{
|
value_range_t vr1 = *(vr_value[i1]);
|
value_range_t vr1 = *(vr_value[i1]);
|
|
|
/* If the range is VARYING or UNDEFINED, use the name itself. */
|
/* If the range is VARYING or UNDEFINED, use the name itself. */
|
if (vr1.type == VR_VARYING || vr1.type == VR_UNDEFINED)
|
if (vr1.type == VR_VARYING || vr1.type == VR_UNDEFINED)
|
{
|
{
|
vr1.type = VR_RANGE;
|
vr1.type = VR_RANGE;
|
vr1.min = ssa_name (i1);
|
vr1.min = ssa_name (i1);
|
vr1.max = ssa_name (i1);
|
vr1.max = ssa_name (i1);
|
}
|
}
|
|
|
t = retval = NULL_TREE;
|
t = retval = NULL_TREE;
|
EXECUTE_IF_SET_IN_BITMAP (e2, 0, i2, bi2)
|
EXECUTE_IF_SET_IN_BITMAP (e2, 0, i2, bi2)
|
{
|
{
|
bool sop = false;
|
bool sop = false;
|
|
|
value_range_t vr2 = *(vr_value[i2]);
|
value_range_t vr2 = *(vr_value[i2]);
|
|
|
if (vr2.type == VR_VARYING || vr2.type == VR_UNDEFINED)
|
if (vr2.type == VR_VARYING || vr2.type == VR_UNDEFINED)
|
{
|
{
|
vr2.type = VR_RANGE;
|
vr2.type = VR_RANGE;
|
vr2.min = ssa_name (i2);
|
vr2.min = ssa_name (i2);
|
vr2.max = ssa_name (i2);
|
vr2.max = ssa_name (i2);
|
}
|
}
|
|
|
t = compare_ranges (comp, &vr1, &vr2, &sop);
|
t = compare_ranges (comp, &vr1, &vr2, &sop);
|
if (t)
|
if (t)
|
{
|
{
|
/* If we get different answers from different members
|
/* If we get different answers from different members
|
of the equivalence set this check must be in a dead
|
of the equivalence set this check must be in a dead
|
code region. Folding it to a trap representation
|
code region. Folding it to a trap representation
|
would be correct here. For now just return don't-know. */
|
would be correct here. For now just return don't-know. */
|
if (retval != NULL
|
if (retval != NULL
|
&& t != retval)
|
&& t != retval)
|
{
|
{
|
bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
|
bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
|
bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
|
bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
retval = t;
|
retval = t;
|
|
|
if (!sop)
|
if (!sop)
|
used_strict_overflow = 0;
|
used_strict_overflow = 0;
|
else if (used_strict_overflow < 0)
|
else if (used_strict_overflow < 0)
|
used_strict_overflow = 1;
|
used_strict_overflow = 1;
|
}
|
}
|
}
|
}
|
|
|
if (retval)
|
if (retval)
|
{
|
{
|
bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
|
bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
|
bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
|
bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
|
if (used_strict_overflow > 0)
|
if (used_strict_overflow > 0)
|
*strict_overflow_p = true;
|
*strict_overflow_p = true;
|
return retval;
|
return retval;
|
}
|
}
|
}
|
}
|
|
|
/* None of the equivalent ranges are useful in computing this
|
/* None of the equivalent ranges are useful in computing this
|
comparison. */
|
comparison. */
|
bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
|
bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
|
bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
|
bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
|
|
/* Given a conditional predicate COND, try to determine if COND yields
|
/* Given a conditional predicate COND, try to determine if COND yields
|
true or false based on the value ranges of its operands. Return
|
true or false based on the value ranges of its operands. Return
|
BOOLEAN_TRUE_NODE if the conditional always evaluates to true,
|
BOOLEAN_TRUE_NODE if the conditional always evaluates to true,
|
BOOLEAN_FALSE_NODE if the conditional always evaluates to false, and,
|
BOOLEAN_FALSE_NODE if the conditional always evaluates to false, and,
|
NULL if the conditional cannot be evaluated at compile time.
|
NULL if the conditional cannot be evaluated at compile time.
|
|
|
If USE_EQUIV_P is true, the ranges of all the names equivalent with
|
If USE_EQUIV_P is true, the ranges of all the names equivalent with
|
the operands in COND are used when trying to compute its value.
|
the operands in COND are used when trying to compute its value.
|
This is only used during final substitution. During propagation,
|
This is only used during final substitution. During propagation,
|
we only check the range of each variable and not its equivalents.
|
we only check the range of each variable and not its equivalents.
|
|
|
Set *STRICT_OVERFLOW_P to indicate whether we relied on an overflow
|
Set *STRICT_OVERFLOW_P to indicate whether we relied on an overflow
|
infinity to produce the result. */
|
infinity to produce the result. */
|
|
|
static tree
|
static tree
|
vrp_evaluate_conditional_warnv (tree cond, bool use_equiv_p,
|
vrp_evaluate_conditional_warnv (tree cond, bool use_equiv_p,
|
bool *strict_overflow_p)
|
bool *strict_overflow_p)
|
{
|
{
|
gcc_assert (TREE_CODE (cond) == SSA_NAME
|
gcc_assert (TREE_CODE (cond) == SSA_NAME
|
|| TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison);
|
|| TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison);
|
|
|
if (TREE_CODE (cond) == SSA_NAME)
|
if (TREE_CODE (cond) == SSA_NAME)
|
{
|
{
|
value_range_t *vr;
|
value_range_t *vr;
|
tree retval;
|
tree retval;
|
|
|
if (use_equiv_p)
|
if (use_equiv_p)
|
retval = compare_name_with_value (NE_EXPR, cond, boolean_false_node,
|
retval = compare_name_with_value (NE_EXPR, cond, boolean_false_node,
|
strict_overflow_p);
|
strict_overflow_p);
|
else
|
else
|
{
|
{
|
value_range_t *vr = get_value_range (cond);
|
value_range_t *vr = get_value_range (cond);
|
retval = compare_range_with_value (NE_EXPR, vr, boolean_false_node,
|
retval = compare_range_with_value (NE_EXPR, vr, boolean_false_node,
|
strict_overflow_p);
|
strict_overflow_p);
|
}
|
}
|
|
|
/* If COND has a known boolean range, return it. */
|
/* If COND has a known boolean range, return it. */
|
if (retval)
|
if (retval)
|
return retval;
|
return retval;
|
|
|
/* Otherwise, if COND has a symbolic range of exactly one value,
|
/* Otherwise, if COND has a symbolic range of exactly one value,
|
return it. */
|
return it. */
|
vr = get_value_range (cond);
|
vr = get_value_range (cond);
|
if (vr->type == VR_RANGE && vr->min == vr->max)
|
if (vr->type == VR_RANGE && vr->min == vr->max)
|
return vr->min;
|
return vr->min;
|
}
|
}
|
else
|
else
|
{
|
{
|
tree op0 = TREE_OPERAND (cond, 0);
|
tree op0 = TREE_OPERAND (cond, 0);
|
tree op1 = TREE_OPERAND (cond, 1);
|
tree op1 = TREE_OPERAND (cond, 1);
|
|
|
/* We only deal with integral and pointer types. */
|
/* We only deal with integral and pointer types. */
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (op0))
|
if (!INTEGRAL_TYPE_P (TREE_TYPE (op0))
|
&& !POINTER_TYPE_P (TREE_TYPE (op0)))
|
&& !POINTER_TYPE_P (TREE_TYPE (op0)))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
if (use_equiv_p)
|
if (use_equiv_p)
|
{
|
{
|
if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME)
|
if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME)
|
return compare_names (TREE_CODE (cond), op0, op1,
|
return compare_names (TREE_CODE (cond), op0, op1,
|
strict_overflow_p);
|
strict_overflow_p);
|
else if (TREE_CODE (op0) == SSA_NAME)
|
else if (TREE_CODE (op0) == SSA_NAME)
|
return compare_name_with_value (TREE_CODE (cond), op0, op1,
|
return compare_name_with_value (TREE_CODE (cond), op0, op1,
|
strict_overflow_p);
|
strict_overflow_p);
|
else if (TREE_CODE (op1) == SSA_NAME)
|
else if (TREE_CODE (op1) == SSA_NAME)
|
return (compare_name_with_value
|
return (compare_name_with_value
|
(swap_tree_comparison (TREE_CODE (cond)), op1, op0,
|
(swap_tree_comparison (TREE_CODE (cond)), op1, op0,
|
strict_overflow_p));
|
strict_overflow_p));
|
}
|
}
|
else
|
else
|
{
|
{
|
value_range_t *vr0, *vr1;
|
value_range_t *vr0, *vr1;
|
|
|
vr0 = (TREE_CODE (op0) == SSA_NAME) ? get_value_range (op0) : NULL;
|
vr0 = (TREE_CODE (op0) == SSA_NAME) ? get_value_range (op0) : NULL;
|
vr1 = (TREE_CODE (op1) == SSA_NAME) ? get_value_range (op1) : NULL;
|
vr1 = (TREE_CODE (op1) == SSA_NAME) ? get_value_range (op1) : NULL;
|
|
|
if (vr0 && vr1)
|
if (vr0 && vr1)
|
return compare_ranges (TREE_CODE (cond), vr0, vr1,
|
return compare_ranges (TREE_CODE (cond), vr0, vr1,
|
strict_overflow_p);
|
strict_overflow_p);
|
else if (vr0 && vr1 == NULL)
|
else if (vr0 && vr1 == NULL)
|
return compare_range_with_value (TREE_CODE (cond), vr0, op1,
|
return compare_range_with_value (TREE_CODE (cond), vr0, op1,
|
strict_overflow_p);
|
strict_overflow_p);
|
else if (vr0 == NULL && vr1)
|
else if (vr0 == NULL && vr1)
|
return (compare_range_with_value
|
return (compare_range_with_value
|
(swap_tree_comparison (TREE_CODE (cond)), vr1, op0,
|
(swap_tree_comparison (TREE_CODE (cond)), vr1, op0,
|
strict_overflow_p));
|
strict_overflow_p));
|
}
|
}
|
}
|
}
|
|
|
/* Anything else cannot be computed statically. */
|
/* Anything else cannot be computed statically. */
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Given COND within STMT, try to simplify it based on value range
|
/* Given COND within STMT, try to simplify it based on value range
|
information. Return NULL if the conditional can not be evaluated.
|
information. Return NULL if the conditional can not be evaluated.
|
The ranges of all the names equivalent with the operands in COND
|
The ranges of all the names equivalent with the operands in COND
|
will be used when trying to compute the value. If the result is
|
will be used when trying to compute the value. If the result is
|
based on undefined signed overflow, issue a warning if
|
based on undefined signed overflow, issue a warning if
|
appropriate. */
|
appropriate. */
|
|
|
tree
|
tree
|
vrp_evaluate_conditional (tree cond, tree stmt)
|
vrp_evaluate_conditional (tree cond, tree stmt)
|
{
|
{
|
bool sop;
|
bool sop;
|
tree ret;
|
tree ret;
|
|
|
sop = false;
|
sop = false;
|
ret = vrp_evaluate_conditional_warnv (cond, true, &sop);
|
ret = vrp_evaluate_conditional_warnv (cond, true, &sop);
|
|
|
if (ret && sop)
|
if (ret && sop)
|
{
|
{
|
enum warn_strict_overflow_code wc;
|
enum warn_strict_overflow_code wc;
|
const char* warnmsg;
|
const char* warnmsg;
|
|
|
if (is_gimple_min_invariant (ret))
|
if (is_gimple_min_invariant (ret))
|
{
|
{
|
wc = WARN_STRICT_OVERFLOW_CONDITIONAL;
|
wc = WARN_STRICT_OVERFLOW_CONDITIONAL;
|
warnmsg = G_("assuming signed overflow does not occur when "
|
warnmsg = G_("assuming signed overflow does not occur when "
|
"simplifying conditional to constant");
|
"simplifying conditional to constant");
|
}
|
}
|
else
|
else
|
{
|
{
|
wc = WARN_STRICT_OVERFLOW_COMPARISON;
|
wc = WARN_STRICT_OVERFLOW_COMPARISON;
|
warnmsg = G_("assuming signed overflow does not occur when "
|
warnmsg = G_("assuming signed overflow does not occur when "
|
"simplifying conditional");
|
"simplifying conditional");
|
}
|
}
|
|
|
if (issue_strict_overflow_warning (wc))
|
if (issue_strict_overflow_warning (wc))
|
{
|
{
|
location_t locus;
|
location_t locus;
|
|
|
if (!EXPR_HAS_LOCATION (stmt))
|
if (!EXPR_HAS_LOCATION (stmt))
|
locus = input_location;
|
locus = input_location;
|
else
|
else
|
locus = EXPR_LOCATION (stmt);
|
locus = EXPR_LOCATION (stmt);
|
warning (OPT_Wstrict_overflow, "%H%s", &locus, warnmsg);
|
warning (OPT_Wstrict_overflow, "%H%s", &locus, warnmsg);
|
}
|
}
|
}
|
}
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
|
|
/* Visit conditional statement STMT. If we can determine which edge
|
/* Visit conditional statement STMT. If we can determine which edge
|
will be taken out of STMT's basic block, record it in
|
will be taken out of STMT's basic block, record it in
|
*TAKEN_EDGE_P and return SSA_PROP_INTERESTING. Otherwise, return
|
*TAKEN_EDGE_P and return SSA_PROP_INTERESTING. Otherwise, return
|
SSA_PROP_VARYING. */
|
SSA_PROP_VARYING. */
|
|
|
static enum ssa_prop_result
|
static enum ssa_prop_result
|
vrp_visit_cond_stmt (tree stmt, edge *taken_edge_p)
|
vrp_visit_cond_stmt (tree stmt, edge *taken_edge_p)
|
{
|
{
|
tree cond, val;
|
tree cond, val;
|
bool sop;
|
bool sop;
|
|
|
*taken_edge_p = NULL;
|
*taken_edge_p = NULL;
|
|
|
/* FIXME. Handle SWITCH_EXPRs. But first, the assert pass needs to
|
/* FIXME. Handle SWITCH_EXPRs. But first, the assert pass needs to
|
add ASSERT_EXPRs for them. */
|
add ASSERT_EXPRs for them. */
|
if (TREE_CODE (stmt) == SWITCH_EXPR)
|
if (TREE_CODE (stmt) == SWITCH_EXPR)
|
return SSA_PROP_VARYING;
|
return SSA_PROP_VARYING;
|
|
|
cond = COND_EXPR_COND (stmt);
|
cond = COND_EXPR_COND (stmt);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
tree use;
|
tree use;
|
ssa_op_iter i;
|
ssa_op_iter i;
|
|
|
fprintf (dump_file, "\nVisiting conditional with predicate: ");
|
fprintf (dump_file, "\nVisiting conditional with predicate: ");
|
print_generic_expr (dump_file, cond, 0);
|
print_generic_expr (dump_file, cond, 0);
|
fprintf (dump_file, "\nWith known ranges\n");
|
fprintf (dump_file, "\nWith known ranges\n");
|
|
|
FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE)
|
FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE)
|
{
|
{
|
fprintf (dump_file, "\t");
|
fprintf (dump_file, "\t");
|
print_generic_expr (dump_file, use, 0);
|
print_generic_expr (dump_file, use, 0);
|
fprintf (dump_file, ": ");
|
fprintf (dump_file, ": ");
|
dump_value_range (dump_file, vr_value[SSA_NAME_VERSION (use)]);
|
dump_value_range (dump_file, vr_value[SSA_NAME_VERSION (use)]);
|
}
|
}
|
|
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
|
|
/* Compute the value of the predicate COND by checking the known
|
/* Compute the value of the predicate COND by checking the known
|
ranges of each of its operands.
|
ranges of each of its operands.
|
|
|
Note that we cannot evaluate all the equivalent ranges here
|
Note that we cannot evaluate all the equivalent ranges here
|
because those ranges may not yet be final and with the current
|
because those ranges may not yet be final and with the current
|
propagation strategy, we cannot determine when the value ranges
|
propagation strategy, we cannot determine when the value ranges
|
of the names in the equivalence set have changed.
|
of the names in the equivalence set have changed.
|
|
|
For instance, given the following code fragment
|
For instance, given the following code fragment
|
|
|
i_5 = PHI <8, i_13>
|
i_5 = PHI <8, i_13>
|
...
|
...
|
i_14 = ASSERT_EXPR <i_5, i_5 != 0>
|
i_14 = ASSERT_EXPR <i_5, i_5 != 0>
|
if (i_14 == 1)
|
if (i_14 == 1)
|
...
|
...
|
|
|
Assume that on the first visit to i_14, i_5 has the temporary
|
Assume that on the first visit to i_14, i_5 has the temporary
|
range [8, 8] because the second argument to the PHI function is
|
range [8, 8] because the second argument to the PHI function is
|
not yet executable. We derive the range ~[0, 0] for i_14 and the
|
not yet executable. We derive the range ~[0, 0] for i_14 and the
|
equivalence set { i_5 }. So, when we visit 'if (i_14 == 1)' for
|
equivalence set { i_5 }. So, when we visit 'if (i_14 == 1)' for
|
the first time, since i_14 is equivalent to the range [8, 8], we
|
the first time, since i_14 is equivalent to the range [8, 8], we
|
determine that the predicate is always false.
|
determine that the predicate is always false.
|
|
|
On the next round of propagation, i_13 is determined to be
|
On the next round of propagation, i_13 is determined to be
|
VARYING, which causes i_5 to drop down to VARYING. So, another
|
VARYING, which causes i_5 to drop down to VARYING. So, another
|
visit to i_14 is scheduled. In this second visit, we compute the
|
visit to i_14 is scheduled. In this second visit, we compute the
|
exact same range and equivalence set for i_14, namely ~[0, 0] and
|
exact same range and equivalence set for i_14, namely ~[0, 0] and
|
{ i_5 }. But we did not have the previous range for i_5
|
{ i_5 }. But we did not have the previous range for i_5
|
registered, so vrp_visit_assignment thinks that the range for
|
registered, so vrp_visit_assignment thinks that the range for
|
i_14 has not changed. Therefore, the predicate 'if (i_14 == 1)'
|
i_14 has not changed. Therefore, the predicate 'if (i_14 == 1)'
|
is not visited again, which stops propagation from visiting
|
is not visited again, which stops propagation from visiting
|
statements in the THEN clause of that if().
|
statements in the THEN clause of that if().
|
|
|
To properly fix this we would need to keep the previous range
|
To properly fix this we would need to keep the previous range
|
value for the names in the equivalence set. This way we would've
|
value for the names in the equivalence set. This way we would've
|
discovered that from one visit to the other i_5 changed from
|
discovered that from one visit to the other i_5 changed from
|
range [8, 8] to VR_VARYING.
|
range [8, 8] to VR_VARYING.
|
|
|
However, fixing this apparent limitation may not be worth the
|
However, fixing this apparent limitation may not be worth the
|
additional checking. Testing on several code bases (GCC, DLV,
|
additional checking. Testing on several code bases (GCC, DLV,
|
MICO, TRAMP3D and SPEC2000) showed that doing this results in
|
MICO, TRAMP3D and SPEC2000) showed that doing this results in
|
4 more predicates folded in SPEC. */
|
4 more predicates folded in SPEC. */
|
sop = false;
|
sop = false;
|
val = vrp_evaluate_conditional_warnv (cond, false, &sop);
|
val = vrp_evaluate_conditional_warnv (cond, false, &sop);
|
if (val)
|
if (val)
|
{
|
{
|
if (!sop)
|
if (!sop)
|
*taken_edge_p = find_taken_edge (bb_for_stmt (stmt), val);
|
*taken_edge_p = find_taken_edge (bb_for_stmt (stmt), val);
|
else
|
else
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"\nIgnoring predicate evaluation because "
|
"\nIgnoring predicate evaluation because "
|
"it assumes that signed overflow is undefined");
|
"it assumes that signed overflow is undefined");
|
val = NULL_TREE;
|
val = NULL_TREE;
|
}
|
}
|
}
|
}
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "\nPredicate evaluates to: ");
|
fprintf (dump_file, "\nPredicate evaluates to: ");
|
if (val == NULL_TREE)
|
if (val == NULL_TREE)
|
fprintf (dump_file, "DON'T KNOW\n");
|
fprintf (dump_file, "DON'T KNOW\n");
|
else
|
else
|
print_generic_stmt (dump_file, val, 0);
|
print_generic_stmt (dump_file, val, 0);
|
}
|
}
|
|
|
return (*taken_edge_p) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING;
|
return (*taken_edge_p) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING;
|
}
|
}
|
|
|
|
|
/* Evaluate statement STMT. If the statement produces a useful range,
|
/* Evaluate statement STMT. If the statement produces a useful range,
|
return SSA_PROP_INTERESTING and record the SSA name with the
|
return SSA_PROP_INTERESTING and record the SSA name with the
|
interesting range into *OUTPUT_P.
|
interesting range into *OUTPUT_P.
|
|
|
If STMT is a conditional branch and we can determine its truth
|
If STMT is a conditional branch and we can determine its truth
|
value, the taken edge is recorded in *TAKEN_EDGE_P.
|
value, the taken edge is recorded in *TAKEN_EDGE_P.
|
|
|
If STMT produces a varying value, return SSA_PROP_VARYING. */
|
If STMT produces a varying value, return SSA_PROP_VARYING. */
|
|
|
static enum ssa_prop_result
|
static enum ssa_prop_result
|
vrp_visit_stmt (tree stmt, edge *taken_edge_p, tree *output_p)
|
vrp_visit_stmt (tree stmt, edge *taken_edge_p, tree *output_p)
|
{
|
{
|
tree def;
|
tree def;
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
stmt_ann_t ann;
|
stmt_ann_t ann;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "\nVisiting statement:\n");
|
fprintf (dump_file, "\nVisiting statement:\n");
|
print_generic_stmt (dump_file, stmt, dump_flags);
|
print_generic_stmt (dump_file, stmt, dump_flags);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
|
|
ann = stmt_ann (stmt);
|
ann = stmt_ann (stmt);
|
if (TREE_CODE (stmt) == MODIFY_EXPR)
|
if (TREE_CODE (stmt) == MODIFY_EXPR)
|
{
|
{
|
tree rhs = TREE_OPERAND (stmt, 1);
|
tree rhs = TREE_OPERAND (stmt, 1);
|
|
|
/* In general, assignments with virtual operands are not useful
|
/* In general, assignments with virtual operands are not useful
|
for deriving ranges, with the obvious exception of calls to
|
for deriving ranges, with the obvious exception of calls to
|
builtin functions. */
|
builtin functions. */
|
if ((TREE_CODE (rhs) == CALL_EXPR
|
if ((TREE_CODE (rhs) == CALL_EXPR
|
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == ADDR_EXPR
|
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == ADDR_EXPR
|
&& DECL_P (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0))
|
&& DECL_P (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0))
|
&& DECL_IS_BUILTIN (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0)))
|
&& DECL_IS_BUILTIN (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0)))
|
|| ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
|
|| ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
|
return vrp_visit_assignment (stmt, output_p);
|
return vrp_visit_assignment (stmt, output_p);
|
}
|
}
|
else if (TREE_CODE (stmt) == COND_EXPR || TREE_CODE (stmt) == SWITCH_EXPR)
|
else if (TREE_CODE (stmt) == COND_EXPR || TREE_CODE (stmt) == SWITCH_EXPR)
|
return vrp_visit_cond_stmt (stmt, taken_edge_p);
|
return vrp_visit_cond_stmt (stmt, taken_edge_p);
|
|
|
/* All other statements produce nothing of interest for VRP, so mark
|
/* All other statements produce nothing of interest for VRP, so mark
|
their outputs varying and prevent further simulation. */
|
their outputs varying and prevent further simulation. */
|
FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
|
FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
|
set_value_range_to_varying (get_value_range (def));
|
set_value_range_to_varying (get_value_range (def));
|
|
|
return SSA_PROP_VARYING;
|
return SSA_PROP_VARYING;
|
}
|
}
|
|
|
|
|
/* Meet operation for value ranges. Given two value ranges VR0 and
|
/* Meet operation for value ranges. Given two value ranges VR0 and
|
VR1, store in VR0 the result of meeting VR0 and VR1.
|
VR1, store in VR0 the result of meeting VR0 and VR1.
|
|
|
The meeting rules are as follows:
|
The meeting rules are as follows:
|
|
|
1- If VR0 and VR1 have an empty intersection, set VR0 to VR_VARYING.
|
1- If VR0 and VR1 have an empty intersection, set VR0 to VR_VARYING.
|
|
|
2- If VR0 and VR1 have a non-empty intersection, set VR0 to the
|
2- If VR0 and VR1 have a non-empty intersection, set VR0 to the
|
union of VR0 and VR1. */
|
union of VR0 and VR1. */
|
|
|
static void
|
static void
|
vrp_meet (value_range_t *vr0, value_range_t *vr1)
|
vrp_meet (value_range_t *vr0, value_range_t *vr1)
|
{
|
{
|
if (vr0->type == VR_UNDEFINED)
|
if (vr0->type == VR_UNDEFINED)
|
{
|
{
|
copy_value_range (vr0, vr1);
|
copy_value_range (vr0, vr1);
|
return;
|
return;
|
}
|
}
|
|
|
if (vr1->type == VR_UNDEFINED)
|
if (vr1->type == VR_UNDEFINED)
|
{
|
{
|
/* Nothing to do. VR0 already has the resulting range. */
|
/* Nothing to do. VR0 already has the resulting range. */
|
return;
|
return;
|
}
|
}
|
|
|
if (vr0->type == VR_VARYING)
|
if (vr0->type == VR_VARYING)
|
{
|
{
|
/* Nothing to do. VR0 already has the resulting range. */
|
/* Nothing to do. VR0 already has the resulting range. */
|
return;
|
return;
|
}
|
}
|
|
|
if (vr1->type == VR_VARYING)
|
if (vr1->type == VR_VARYING)
|
{
|
{
|
set_value_range_to_varying (vr0);
|
set_value_range_to_varying (vr0);
|
return;
|
return;
|
}
|
}
|
|
|
if (vr0->type == VR_RANGE && vr1->type == VR_RANGE)
|
if (vr0->type == VR_RANGE && vr1->type == VR_RANGE)
|
{
|
{
|
/* If VR0 and VR1 have a non-empty intersection, compute the
|
/* If VR0 and VR1 have a non-empty intersection, compute the
|
union of both ranges. */
|
union of both ranges. */
|
if (value_ranges_intersect_p (vr0, vr1))
|
if (value_ranges_intersect_p (vr0, vr1))
|
{
|
{
|
int cmp;
|
int cmp;
|
tree min, max;
|
tree min, max;
|
|
|
/* The lower limit of the new range is the minimum of the
|
/* The lower limit of the new range is the minimum of the
|
two ranges. If they cannot be compared, the result is
|
two ranges. If they cannot be compared, the result is
|
VARYING. */
|
VARYING. */
|
cmp = compare_values (vr0->min, vr1->min);
|
cmp = compare_values (vr0->min, vr1->min);
|
if (cmp == 0 || cmp == 1)
|
if (cmp == 0 || cmp == 1)
|
min = vr1->min;
|
min = vr1->min;
|
else if (cmp == -1)
|
else if (cmp == -1)
|
min = vr0->min;
|
min = vr0->min;
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr0);
|
set_value_range_to_varying (vr0);
|
return;
|
return;
|
}
|
}
|
|
|
/* Similarly, the upper limit of the new range is the
|
/* Similarly, the upper limit of the new range is the
|
maximum of the two ranges. If they cannot be compared,
|
maximum of the two ranges. If they cannot be compared,
|
the result is VARYING. */
|
the result is VARYING. */
|
cmp = compare_values (vr0->max, vr1->max);
|
cmp = compare_values (vr0->max, vr1->max);
|
if (cmp == 0 || cmp == -1)
|
if (cmp == 0 || cmp == -1)
|
max = vr1->max;
|
max = vr1->max;
|
else if (cmp == 1)
|
else if (cmp == 1)
|
max = vr0->max;
|
max = vr0->max;
|
else
|
else
|
{
|
{
|
set_value_range_to_varying (vr0);
|
set_value_range_to_varying (vr0);
|
return;
|
return;
|
}
|
}
|
|
|
/* Check for useless ranges. */
|
/* Check for useless ranges. */
|
if (INTEGRAL_TYPE_P (TREE_TYPE (min))
|
if (INTEGRAL_TYPE_P (TREE_TYPE (min))
|
&& ((vrp_val_is_min (min) || is_overflow_infinity (min))
|
&& ((vrp_val_is_min (min) || is_overflow_infinity (min))
|
&& (vrp_val_is_max (max) || is_overflow_infinity (max))))
|
&& (vrp_val_is_max (max) || is_overflow_infinity (max))))
|
{
|
{
|
set_value_range_to_varying (vr0);
|
set_value_range_to_varying (vr0);
|
return;
|
return;
|
}
|
}
|
|
|
/* The resulting set of equivalences is the intersection of
|
/* The resulting set of equivalences is the intersection of
|
the two sets. */
|
the two sets. */
|
if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv)
|
if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv)
|
bitmap_and_into (vr0->equiv, vr1->equiv);
|
bitmap_and_into (vr0->equiv, vr1->equiv);
|
else if (vr0->equiv && !vr1->equiv)
|
else if (vr0->equiv && !vr1->equiv)
|
bitmap_clear (vr0->equiv);
|
bitmap_clear (vr0->equiv);
|
|
|
set_value_range (vr0, vr0->type, min, max, vr0->equiv);
|
set_value_range (vr0, vr0->type, min, max, vr0->equiv);
|
}
|
}
|
else
|
else
|
goto no_meet;
|
goto no_meet;
|
}
|
}
|
else if (vr0->type == VR_ANTI_RANGE && vr1->type == VR_ANTI_RANGE)
|
else if (vr0->type == VR_ANTI_RANGE && vr1->type == VR_ANTI_RANGE)
|
{
|
{
|
/* Two anti-ranges meet only if they are both identical. */
|
/* Two anti-ranges meet only if they are both identical. */
|
if (compare_values (vr0->min, vr1->min) == 0
|
if (compare_values (vr0->min, vr1->min) == 0
|
&& compare_values (vr0->max, vr1->max) == 0
|
&& compare_values (vr0->max, vr1->max) == 0
|
&& compare_values (vr0->min, vr0->max) == 0)
|
&& compare_values (vr0->min, vr0->max) == 0)
|
{
|
{
|
/* The resulting set of equivalences is the intersection of
|
/* The resulting set of equivalences is the intersection of
|
the two sets. */
|
the two sets. */
|
if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv)
|
if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv)
|
bitmap_and_into (vr0->equiv, vr1->equiv);
|
bitmap_and_into (vr0->equiv, vr1->equiv);
|
else if (vr0->equiv && !vr1->equiv)
|
else if (vr0->equiv && !vr1->equiv)
|
bitmap_clear (vr0->equiv);
|
bitmap_clear (vr0->equiv);
|
}
|
}
|
else
|
else
|
goto no_meet;
|
goto no_meet;
|
}
|
}
|
else if (vr0->type == VR_ANTI_RANGE || vr1->type == VR_ANTI_RANGE)
|
else if (vr0->type == VR_ANTI_RANGE || vr1->type == VR_ANTI_RANGE)
|
{
|
{
|
/* A numeric range [VAL1, VAL2] and an anti-range ~[VAL3, VAL4]
|
/* A numeric range [VAL1, VAL2] and an anti-range ~[VAL3, VAL4]
|
meet only if the ranges have an empty intersection. The
|
meet only if the ranges have an empty intersection. The
|
result of the meet operation is the anti-range. */
|
result of the meet operation is the anti-range. */
|
if (!symbolic_range_p (vr0)
|
if (!symbolic_range_p (vr0)
|
&& !symbolic_range_p (vr1)
|
&& !symbolic_range_p (vr1)
|
&& !value_ranges_intersect_p (vr0, vr1))
|
&& !value_ranges_intersect_p (vr0, vr1))
|
{
|
{
|
/* Copy most of VR1 into VR0. Don't copy VR1's equivalence
|
/* Copy most of VR1 into VR0. Don't copy VR1's equivalence
|
set. We need to compute the intersection of the two
|
set. We need to compute the intersection of the two
|
equivalence sets. */
|
equivalence sets. */
|
if (vr1->type == VR_ANTI_RANGE)
|
if (vr1->type == VR_ANTI_RANGE)
|
set_value_range (vr0, vr1->type, vr1->min, vr1->max, vr0->equiv);
|
set_value_range (vr0, vr1->type, vr1->min, vr1->max, vr0->equiv);
|
|
|
/* The resulting set of equivalences is the intersection of
|
/* The resulting set of equivalences is the intersection of
|
the two sets. */
|
the two sets. */
|
if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv)
|
if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv)
|
bitmap_and_into (vr0->equiv, vr1->equiv);
|
bitmap_and_into (vr0->equiv, vr1->equiv);
|
else if (vr0->equiv && !vr1->equiv)
|
else if (vr0->equiv && !vr1->equiv)
|
bitmap_clear (vr0->equiv);
|
bitmap_clear (vr0->equiv);
|
}
|
}
|
else
|
else
|
goto no_meet;
|
goto no_meet;
|
}
|
}
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
|
|
return;
|
return;
|
|
|
no_meet:
|
no_meet:
|
/* The two range VR0 and VR1 do not meet. Before giving up and
|
/* The two range VR0 and VR1 do not meet. Before giving up and
|
setting the result to VARYING, see if we can at least derive a
|
setting the result to VARYING, see if we can at least derive a
|
useful anti-range. FIXME, all this nonsense about distinguishing
|
useful anti-range. FIXME, all this nonsense about distinguishing
|
anti-ranges from ranges is necessary because of the odd
|
anti-ranges from ranges is necessary because of the odd
|
semantics of range_includes_zero_p and friends. */
|
semantics of range_includes_zero_p and friends. */
|
if (!symbolic_range_p (vr0)
|
if (!symbolic_range_p (vr0)
|
&& ((vr0->type == VR_RANGE && !range_includes_zero_p (vr0))
|
&& ((vr0->type == VR_RANGE && !range_includes_zero_p (vr0))
|
|| (vr0->type == VR_ANTI_RANGE && range_includes_zero_p (vr0)))
|
|| (vr0->type == VR_ANTI_RANGE && range_includes_zero_p (vr0)))
|
&& !symbolic_range_p (vr1)
|
&& !symbolic_range_p (vr1)
|
&& ((vr1->type == VR_RANGE && !range_includes_zero_p (vr1))
|
&& ((vr1->type == VR_RANGE && !range_includes_zero_p (vr1))
|
|| (vr1->type == VR_ANTI_RANGE && range_includes_zero_p (vr1))))
|
|| (vr1->type == VR_ANTI_RANGE && range_includes_zero_p (vr1))))
|
{
|
{
|
set_value_range_to_nonnull (vr0, TREE_TYPE (vr0->min));
|
set_value_range_to_nonnull (vr0, TREE_TYPE (vr0->min));
|
|
|
/* Since this meet operation did not result from the meeting of
|
/* Since this meet operation did not result from the meeting of
|
two equivalent names, VR0 cannot have any equivalences. */
|
two equivalent names, VR0 cannot have any equivalences. */
|
if (vr0->equiv)
|
if (vr0->equiv)
|
bitmap_clear (vr0->equiv);
|
bitmap_clear (vr0->equiv);
|
}
|
}
|
else
|
else
|
set_value_range_to_varying (vr0);
|
set_value_range_to_varying (vr0);
|
}
|
}
|
|
|
|
|
/* Visit all arguments for PHI node PHI that flow through executable
|
/* Visit all arguments for PHI node PHI that flow through executable
|
edges. If a valid value range can be derived from all the incoming
|
edges. If a valid value range can be derived from all the incoming
|
value ranges, set a new range for the LHS of PHI. */
|
value ranges, set a new range for the LHS of PHI. */
|
|
|
static enum ssa_prop_result
|
static enum ssa_prop_result
|
vrp_visit_phi_node (tree phi)
|
vrp_visit_phi_node (tree phi)
|
{
|
{
|
int i;
|
int i;
|
tree lhs = PHI_RESULT (phi);
|
tree lhs = PHI_RESULT (phi);
|
value_range_t *lhs_vr = get_value_range (lhs);
|
value_range_t *lhs_vr = get_value_range (lhs);
|
value_range_t vr_result = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
|
value_range_t vr_result = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
|
|
|
copy_value_range (&vr_result, lhs_vr);
|
copy_value_range (&vr_result, lhs_vr);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "\nVisiting PHI node: ");
|
fprintf (dump_file, "\nVisiting PHI node: ");
|
print_generic_expr (dump_file, phi, dump_flags);
|
print_generic_expr (dump_file, phi, dump_flags);
|
}
|
}
|
|
|
for (i = 0; i < PHI_NUM_ARGS (phi); i++)
|
for (i = 0; i < PHI_NUM_ARGS (phi); i++)
|
{
|
{
|
edge e = PHI_ARG_EDGE (phi, i);
|
edge e = PHI_ARG_EDGE (phi, i);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"\n Argument #%d (%d -> %d %sexecutable)\n",
|
"\n Argument #%d (%d -> %d %sexecutable)\n",
|
i, e->src->index, e->dest->index,
|
i, e->src->index, e->dest->index,
|
(e->flags & EDGE_EXECUTABLE) ? "" : "not ");
|
(e->flags & EDGE_EXECUTABLE) ? "" : "not ");
|
}
|
}
|
|
|
if (e->flags & EDGE_EXECUTABLE)
|
if (e->flags & EDGE_EXECUTABLE)
|
{
|
{
|
tree arg = PHI_ARG_DEF (phi, i);
|
tree arg = PHI_ARG_DEF (phi, i);
|
value_range_t vr_arg;
|
value_range_t vr_arg;
|
|
|
if (TREE_CODE (arg) == SSA_NAME)
|
if (TREE_CODE (arg) == SSA_NAME)
|
vr_arg = *(get_value_range (arg));
|
vr_arg = *(get_value_range (arg));
|
else
|
else
|
{
|
{
|
if (is_overflow_infinity (arg))
|
if (is_overflow_infinity (arg))
|
{
|
{
|
arg = copy_node (arg);
|
arg = copy_node (arg);
|
TREE_OVERFLOW (arg) = 0;
|
TREE_OVERFLOW (arg) = 0;
|
}
|
}
|
|
|
vr_arg.type = VR_RANGE;
|
vr_arg.type = VR_RANGE;
|
vr_arg.min = arg;
|
vr_arg.min = arg;
|
vr_arg.max = arg;
|
vr_arg.max = arg;
|
vr_arg.equiv = NULL;
|
vr_arg.equiv = NULL;
|
}
|
}
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "\t");
|
fprintf (dump_file, "\t");
|
print_generic_expr (dump_file, arg, dump_flags);
|
print_generic_expr (dump_file, arg, dump_flags);
|
fprintf (dump_file, "\n\tValue: ");
|
fprintf (dump_file, "\n\tValue: ");
|
dump_value_range (dump_file, &vr_arg);
|
dump_value_range (dump_file, &vr_arg);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
|
|
vrp_meet (&vr_result, &vr_arg);
|
vrp_meet (&vr_result, &vr_arg);
|
|
|
if (vr_result.type == VR_VARYING)
|
if (vr_result.type == VR_VARYING)
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (vr_result.type == VR_VARYING)
|
if (vr_result.type == VR_VARYING)
|
goto varying;
|
goto varying;
|
|
|
/* To prevent infinite iterations in the algorithm, derive ranges
|
/* To prevent infinite iterations in the algorithm, derive ranges
|
when the new value is slightly bigger or smaller than the
|
when the new value is slightly bigger or smaller than the
|
previous one. */
|
previous one. */
|
if (lhs_vr->type == VR_RANGE && vr_result.type == VR_RANGE)
|
if (lhs_vr->type == VR_RANGE && vr_result.type == VR_RANGE)
|
{
|
{
|
if (!POINTER_TYPE_P (TREE_TYPE (lhs)))
|
if (!POINTER_TYPE_P (TREE_TYPE (lhs)))
|
{
|
{
|
int cmp_min = compare_values (lhs_vr->min, vr_result.min);
|
int cmp_min = compare_values (lhs_vr->min, vr_result.min);
|
int cmp_max = compare_values (lhs_vr->max, vr_result.max);
|
int cmp_max = compare_values (lhs_vr->max, vr_result.max);
|
|
|
/* If the new minimum is smaller or larger than the previous
|
/* If the new minimum is smaller or larger than the previous
|
one, go all the way to -INF. In the first case, to avoid
|
one, go all the way to -INF. In the first case, to avoid
|
iterating millions of times to reach -INF, and in the
|
iterating millions of times to reach -INF, and in the
|
other case to avoid infinite bouncing between different
|
other case to avoid infinite bouncing between different
|
minimums. */
|
minimums. */
|
if (cmp_min > 0 || cmp_min < 0)
|
if (cmp_min > 0 || cmp_min < 0)
|
{
|
{
|
/* If we will end up with a (-INF, +INF) range, set it
|
/* If we will end up with a (-INF, +INF) range, set it
|
to VARYING. */
|
to VARYING. */
|
if (vrp_val_is_max (vr_result.max))
|
if (vrp_val_is_max (vr_result.max))
|
goto varying;
|
goto varying;
|
|
|
if (!needs_overflow_infinity (TREE_TYPE (vr_result.min))
|
if (!needs_overflow_infinity (TREE_TYPE (vr_result.min))
|
|| !vrp_var_may_overflow (lhs, phi))
|
|| !vrp_var_may_overflow (lhs, phi))
|
vr_result.min = TYPE_MIN_VALUE (TREE_TYPE (vr_result.min));
|
vr_result.min = TYPE_MIN_VALUE (TREE_TYPE (vr_result.min));
|
else if (supports_overflow_infinity (TREE_TYPE (vr_result.min)))
|
else if (supports_overflow_infinity (TREE_TYPE (vr_result.min)))
|
vr_result.min =
|
vr_result.min =
|
negative_overflow_infinity (TREE_TYPE (vr_result.min));
|
negative_overflow_infinity (TREE_TYPE (vr_result.min));
|
else
|
else
|
goto varying;
|
goto varying;
|
}
|
}
|
|
|
/* Similarly, if the new maximum is smaller or larger than
|
/* Similarly, if the new maximum is smaller or larger than
|
the previous one, go all the way to +INF. */
|
the previous one, go all the way to +INF. */
|
if (cmp_max < 0 || cmp_max > 0)
|
if (cmp_max < 0 || cmp_max > 0)
|
{
|
{
|
/* If we will end up with a (-INF, +INF) range, set it
|
/* If we will end up with a (-INF, +INF) range, set it
|
to VARYING. */
|
to VARYING. */
|
if (vrp_val_is_min (vr_result.min))
|
if (vrp_val_is_min (vr_result.min))
|
goto varying;
|
goto varying;
|
|
|
if (!needs_overflow_infinity (TREE_TYPE (vr_result.max))
|
if (!needs_overflow_infinity (TREE_TYPE (vr_result.max))
|
|| !vrp_var_may_overflow (lhs, phi))
|
|| !vrp_var_may_overflow (lhs, phi))
|
vr_result.max = TYPE_MAX_VALUE (TREE_TYPE (vr_result.max));
|
vr_result.max = TYPE_MAX_VALUE (TREE_TYPE (vr_result.max));
|
else if (supports_overflow_infinity (TREE_TYPE (vr_result.max)))
|
else if (supports_overflow_infinity (TREE_TYPE (vr_result.max)))
|
vr_result.max =
|
vr_result.max =
|
positive_overflow_infinity (TREE_TYPE (vr_result.max));
|
positive_overflow_infinity (TREE_TYPE (vr_result.max));
|
else
|
else
|
goto varying;
|
goto varying;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* If the new range is different than the previous value, keep
|
/* If the new range is different than the previous value, keep
|
iterating. */
|
iterating. */
|
if (update_value_range (lhs, &vr_result))
|
if (update_value_range (lhs, &vr_result))
|
return SSA_PROP_INTERESTING;
|
return SSA_PROP_INTERESTING;
|
|
|
/* Nothing changed, don't add outgoing edges. */
|
/* Nothing changed, don't add outgoing edges. */
|
return SSA_PROP_NOT_INTERESTING;
|
return SSA_PROP_NOT_INTERESTING;
|
|
|
/* No match found. Set the LHS to VARYING. */
|
/* No match found. Set the LHS to VARYING. */
|
varying:
|
varying:
|
set_value_range_to_varying (lhs_vr);
|
set_value_range_to_varying (lhs_vr);
|
return SSA_PROP_VARYING;
|
return SSA_PROP_VARYING;
|
}
|
}
|
|
|
/* Simplify a division or modulo operator to a right shift or
|
/* Simplify a division or modulo operator to a right shift or
|
bitwise and if the first operand is unsigned or is greater
|
bitwise and if the first operand is unsigned or is greater
|
than zero and the second operand is an exact power of two. */
|
than zero and the second operand is an exact power of two. */
|
|
|
static void
|
static void
|
simplify_div_or_mod_using_ranges (tree stmt, tree rhs, enum tree_code rhs_code)
|
simplify_div_or_mod_using_ranges (tree stmt, tree rhs, enum tree_code rhs_code)
|
{
|
{
|
tree val = NULL;
|
tree val = NULL;
|
tree op = TREE_OPERAND (rhs, 0);
|
tree op = TREE_OPERAND (rhs, 0);
|
value_range_t *vr = get_value_range (TREE_OPERAND (rhs, 0));
|
value_range_t *vr = get_value_range (TREE_OPERAND (rhs, 0));
|
|
|
if (TYPE_UNSIGNED (TREE_TYPE (op)))
|
if (TYPE_UNSIGNED (TREE_TYPE (op)))
|
{
|
{
|
val = integer_one_node;
|
val = integer_one_node;
|
}
|
}
|
else
|
else
|
{
|
{
|
bool sop = false;
|
bool sop = false;
|
|
|
val = compare_range_with_value (GT_EXPR, vr, integer_zero_node, &sop);
|
val = compare_range_with_value (GT_EXPR, vr, integer_zero_node, &sop);
|
|
|
if (val
|
if (val
|
&& sop
|
&& sop
|
&& integer_onep (val)
|
&& integer_onep (val)
|
&& issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC))
|
&& issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC))
|
{
|
{
|
location_t locus;
|
location_t locus;
|
|
|
if (!EXPR_HAS_LOCATION (stmt))
|
if (!EXPR_HAS_LOCATION (stmt))
|
locus = input_location;
|
locus = input_location;
|
else
|
else
|
locus = EXPR_LOCATION (stmt);
|
locus = EXPR_LOCATION (stmt);
|
warning (OPT_Wstrict_overflow,
|
warning (OPT_Wstrict_overflow,
|
("%Hassuming signed overflow does not occur when "
|
("%Hassuming signed overflow does not occur when "
|
"simplifying / or %% to >> or &"),
|
"simplifying / or %% to >> or &"),
|
&locus);
|
&locus);
|
}
|
}
|
}
|
}
|
|
|
if (val && integer_onep (val))
|
if (val && integer_onep (val))
|
{
|
{
|
tree t;
|
tree t;
|
tree op0 = TREE_OPERAND (rhs, 0);
|
tree op0 = TREE_OPERAND (rhs, 0);
|
tree op1 = TREE_OPERAND (rhs, 1);
|
tree op1 = TREE_OPERAND (rhs, 1);
|
|
|
if (rhs_code == TRUNC_DIV_EXPR)
|
if (rhs_code == TRUNC_DIV_EXPR)
|
{
|
{
|
t = build_int_cst (NULL_TREE, tree_log2 (op1));
|
t = build_int_cst (NULL_TREE, tree_log2 (op1));
|
t = build2 (RSHIFT_EXPR, TREE_TYPE (op0), op0, t);
|
t = build2 (RSHIFT_EXPR, TREE_TYPE (op0), op0, t);
|
}
|
}
|
else
|
else
|
{
|
{
|
t = build_int_cst (TREE_TYPE (op1), 1);
|
t = build_int_cst (TREE_TYPE (op1), 1);
|
t = int_const_binop (MINUS_EXPR, op1, t, 0);
|
t = int_const_binop (MINUS_EXPR, op1, t, 0);
|
t = fold_convert (TREE_TYPE (op0), t);
|
t = fold_convert (TREE_TYPE (op0), t);
|
t = build2 (BIT_AND_EXPR, TREE_TYPE (op0), op0, t);
|
t = build2 (BIT_AND_EXPR, TREE_TYPE (op0), op0, t);
|
}
|
}
|
|
|
TREE_OPERAND (stmt, 1) = t;
|
TREE_OPERAND (stmt, 1) = t;
|
update_stmt (stmt);
|
update_stmt (stmt);
|
}
|
}
|
}
|
}
|
|
|
/* If the operand to an ABS_EXPR is >= 0, then eliminate the
|
/* If the operand to an ABS_EXPR is >= 0, then eliminate the
|
ABS_EXPR. If the operand is <= 0, then simplify the
|
ABS_EXPR. If the operand is <= 0, then simplify the
|
ABS_EXPR into a NEGATE_EXPR. */
|
ABS_EXPR into a NEGATE_EXPR. */
|
|
|
static void
|
static void
|
simplify_abs_using_ranges (tree stmt, tree rhs)
|
simplify_abs_using_ranges (tree stmt, tree rhs)
|
{
|
{
|
tree val = NULL;
|
tree val = NULL;
|
tree op = TREE_OPERAND (rhs, 0);
|
tree op = TREE_OPERAND (rhs, 0);
|
tree type = TREE_TYPE (op);
|
tree type = TREE_TYPE (op);
|
value_range_t *vr = get_value_range (TREE_OPERAND (rhs, 0));
|
value_range_t *vr = get_value_range (TREE_OPERAND (rhs, 0));
|
|
|
if (TYPE_UNSIGNED (type))
|
if (TYPE_UNSIGNED (type))
|
{
|
{
|
val = integer_zero_node;
|
val = integer_zero_node;
|
}
|
}
|
else if (vr)
|
else if (vr)
|
{
|
{
|
bool sop = false;
|
bool sop = false;
|
|
|
val = compare_range_with_value (LE_EXPR, vr, integer_zero_node, &sop);
|
val = compare_range_with_value (LE_EXPR, vr, integer_zero_node, &sop);
|
if (!val)
|
if (!val)
|
{
|
{
|
sop = false;
|
sop = false;
|
val = compare_range_with_value (GE_EXPR, vr, integer_zero_node,
|
val = compare_range_with_value (GE_EXPR, vr, integer_zero_node,
|
&sop);
|
&sop);
|
|
|
if (val)
|
if (val)
|
{
|
{
|
if (integer_zerop (val))
|
if (integer_zerop (val))
|
val = integer_one_node;
|
val = integer_one_node;
|
else if (integer_onep (val))
|
else if (integer_onep (val))
|
val = integer_zero_node;
|
val = integer_zero_node;
|
}
|
}
|
}
|
}
|
|
|
if (val
|
if (val
|
&& (integer_onep (val) || integer_zerop (val)))
|
&& (integer_onep (val) || integer_zerop (val)))
|
{
|
{
|
tree t;
|
tree t;
|
|
|
if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC))
|
if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC))
|
{
|
{
|
location_t locus;
|
location_t locus;
|
|
|
if (!EXPR_HAS_LOCATION (stmt))
|
if (!EXPR_HAS_LOCATION (stmt))
|
locus = input_location;
|
locus = input_location;
|
else
|
else
|
locus = EXPR_LOCATION (stmt);
|
locus = EXPR_LOCATION (stmt);
|
warning (OPT_Wstrict_overflow,
|
warning (OPT_Wstrict_overflow,
|
("%Hassuming signed overflow does not occur when "
|
("%Hassuming signed overflow does not occur when "
|
"simplifying abs (X) to X or -X"),
|
"simplifying abs (X) to X or -X"),
|
&locus);
|
&locus);
|
}
|
}
|
|
|
if (integer_onep (val))
|
if (integer_onep (val))
|
t = build1 (NEGATE_EXPR, TREE_TYPE (op), op);
|
t = build1 (NEGATE_EXPR, TREE_TYPE (op), op);
|
else
|
else
|
t = op;
|
t = op;
|
|
|
TREE_OPERAND (stmt, 1) = t;
|
TREE_OPERAND (stmt, 1) = t;
|
update_stmt (stmt);
|
update_stmt (stmt);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* We are comparing trees OP0 and OP1 using COND_CODE. OP0 has
|
/* We are comparing trees OP0 and OP1 using COND_CODE. OP0 has
|
a known value range VR.
|
a known value range VR.
|
|
|
If there is one and only one value which will satisfy the
|
If there is one and only one value which will satisfy the
|
conditional, then return that value. Else return NULL. */
|
conditional, then return that value. Else return NULL. */
|
|
|
static tree
|
static tree
|
test_for_singularity (enum tree_code cond_code, tree op0,
|
test_for_singularity (enum tree_code cond_code, tree op0,
|
tree op1, value_range_t *vr)
|
tree op1, value_range_t *vr)
|
{
|
{
|
tree min = NULL;
|
tree min = NULL;
|
tree max = NULL;
|
tree max = NULL;
|
|
|
/* Extract minimum/maximum values which satisfy the
|
/* Extract minimum/maximum values which satisfy the
|
the conditional as it was written. */
|
the conditional as it was written. */
|
if (cond_code == LE_EXPR || cond_code == LT_EXPR)
|
if (cond_code == LE_EXPR || cond_code == LT_EXPR)
|
{
|
{
|
/* This should not be negative infinity; there is no overflow
|
/* This should not be negative infinity; there is no overflow
|
here. */
|
here. */
|
min = TYPE_MIN_VALUE (TREE_TYPE (op0));
|
min = TYPE_MIN_VALUE (TREE_TYPE (op0));
|
|
|
max = op1;
|
max = op1;
|
if (cond_code == LT_EXPR && !is_overflow_infinity (max))
|
if (cond_code == LT_EXPR && !is_overflow_infinity (max))
|
{
|
{
|
tree one = build_int_cst (TREE_TYPE (op0), 1);
|
tree one = build_int_cst (TREE_TYPE (op0), 1);
|
max = fold_build2 (MINUS_EXPR, TREE_TYPE (op0), max, one);
|
max = fold_build2 (MINUS_EXPR, TREE_TYPE (op0), max, one);
|
if (EXPR_P (max))
|
if (EXPR_P (max))
|
TREE_NO_WARNING (max) = 1;
|
TREE_NO_WARNING (max) = 1;
|
}
|
}
|
}
|
}
|
else if (cond_code == GE_EXPR || cond_code == GT_EXPR)
|
else if (cond_code == GE_EXPR || cond_code == GT_EXPR)
|
{
|
{
|
/* This should not be positive infinity; there is no overflow
|
/* This should not be positive infinity; there is no overflow
|
here. */
|
here. */
|
max = TYPE_MAX_VALUE (TREE_TYPE (op0));
|
max = TYPE_MAX_VALUE (TREE_TYPE (op0));
|
|
|
min = op1;
|
min = op1;
|
if (cond_code == GT_EXPR && !is_overflow_infinity (min))
|
if (cond_code == GT_EXPR && !is_overflow_infinity (min))
|
{
|
{
|
tree one = build_int_cst (TREE_TYPE (op0), 1);
|
tree one = build_int_cst (TREE_TYPE (op0), 1);
|
min = fold_build2 (PLUS_EXPR, TREE_TYPE (op0), min, one);
|
min = fold_build2 (PLUS_EXPR, TREE_TYPE (op0), min, one);
|
if (EXPR_P (min))
|
if (EXPR_P (min))
|
TREE_NO_WARNING (min) = 1;
|
TREE_NO_WARNING (min) = 1;
|
}
|
}
|
}
|
}
|
|
|
/* Now refine the minimum and maximum values using any
|
/* Now refine the minimum and maximum values using any
|
value range information we have for op0. */
|
value range information we have for op0. */
|
if (min && max)
|
if (min && max)
|
{
|
{
|
if (compare_values (vr->min, min) == -1)
|
if (compare_values (vr->min, min) == -1)
|
min = min;
|
min = min;
|
else
|
else
|
min = vr->min;
|
min = vr->min;
|
if (compare_values (vr->max, max) == 1)
|
if (compare_values (vr->max, max) == 1)
|
max = max;
|
max = max;
|
else
|
else
|
max = vr->max;
|
max = vr->max;
|
|
|
/* If the new min/max values have converged to a single value,
|
/* If the new min/max values have converged to a single value,
|
then there is only one value which can satisfy the condition,
|
then there is only one value which can satisfy the condition,
|
return that value. */
|
return that value. */
|
if (operand_equal_p (min, max, 0) && is_gimple_min_invariant (min))
|
if (operand_equal_p (min, max, 0) && is_gimple_min_invariant (min))
|
return min;
|
return min;
|
}
|
}
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Simplify a conditional using a relational operator to an equality
|
/* Simplify a conditional using a relational operator to an equality
|
test if the range information indicates only one value can satisfy
|
test if the range information indicates only one value can satisfy
|
the original conditional. */
|
the original conditional. */
|
|
|
static void
|
static void
|
simplify_cond_using_ranges (tree stmt)
|
simplify_cond_using_ranges (tree stmt)
|
{
|
{
|
tree cond = COND_EXPR_COND (stmt);
|
tree cond = COND_EXPR_COND (stmt);
|
tree op0 = TREE_OPERAND (cond, 0);
|
tree op0 = TREE_OPERAND (cond, 0);
|
tree op1 = TREE_OPERAND (cond, 1);
|
tree op1 = TREE_OPERAND (cond, 1);
|
enum tree_code cond_code = TREE_CODE (cond);
|
enum tree_code cond_code = TREE_CODE (cond);
|
|
|
if (cond_code != NE_EXPR
|
if (cond_code != NE_EXPR
|
&& cond_code != EQ_EXPR
|
&& cond_code != EQ_EXPR
|
&& TREE_CODE (op0) == SSA_NAME
|
&& TREE_CODE (op0) == SSA_NAME
|
&& INTEGRAL_TYPE_P (TREE_TYPE (op0))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (op0))
|
&& is_gimple_min_invariant (op1))
|
&& is_gimple_min_invariant (op1))
|
{
|
{
|
value_range_t *vr = get_value_range (op0);
|
value_range_t *vr = get_value_range (op0);
|
|
|
/* If we have range information for OP0, then we might be
|
/* If we have range information for OP0, then we might be
|
able to simplify this conditional. */
|
able to simplify this conditional. */
|
if (vr->type == VR_RANGE)
|
if (vr->type == VR_RANGE)
|
{
|
{
|
tree new = test_for_singularity (cond_code, op0, op1, vr);
|
tree new = test_for_singularity (cond_code, op0, op1, vr);
|
|
|
if (new)
|
if (new)
|
{
|
{
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Simplified relational ");
|
fprintf (dump_file, "Simplified relational ");
|
print_generic_expr (dump_file, cond, 0);
|
print_generic_expr (dump_file, cond, 0);
|
fprintf (dump_file, " into ");
|
fprintf (dump_file, " into ");
|
}
|
}
|
|
|
COND_EXPR_COND (stmt)
|
COND_EXPR_COND (stmt)
|
= build2 (EQ_EXPR, boolean_type_node, op0, new);
|
= build2 (EQ_EXPR, boolean_type_node, op0, new);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
print_generic_expr (dump_file, COND_EXPR_COND (stmt), 0);
|
print_generic_expr (dump_file, COND_EXPR_COND (stmt), 0);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
return;
|
return;
|
|
|
}
|
}
|
|
|
/* Try again after inverting the condition. We only deal
|
/* Try again after inverting the condition. We only deal
|
with integral types here, so no need to worry about
|
with integral types here, so no need to worry about
|
issues with inverting FP comparisons. */
|
issues with inverting FP comparisons. */
|
cond_code = invert_tree_comparison (cond_code, false);
|
cond_code = invert_tree_comparison (cond_code, false);
|
new = test_for_singularity (cond_code, op0, op1, vr);
|
new = test_for_singularity (cond_code, op0, op1, vr);
|
|
|
if (new)
|
if (new)
|
{
|
{
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Simplified relational ");
|
fprintf (dump_file, "Simplified relational ");
|
print_generic_expr (dump_file, cond, 0);
|
print_generic_expr (dump_file, cond, 0);
|
fprintf (dump_file, " into ");
|
fprintf (dump_file, " into ");
|
}
|
}
|
|
|
COND_EXPR_COND (stmt)
|
COND_EXPR_COND (stmt)
|
= build2 (NE_EXPR, boolean_type_node, op0, new);
|
= build2 (NE_EXPR, boolean_type_node, op0, new);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
print_generic_expr (dump_file, COND_EXPR_COND (stmt), 0);
|
print_generic_expr (dump_file, COND_EXPR_COND (stmt), 0);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
return;
|
return;
|
|
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Simplify STMT using ranges if possible. */
|
/* Simplify STMT using ranges if possible. */
|
|
|
void
|
void
|
simplify_stmt_using_ranges (tree stmt)
|
simplify_stmt_using_ranges (tree stmt)
|
{
|
{
|
if (TREE_CODE (stmt) == MODIFY_EXPR)
|
if (TREE_CODE (stmt) == MODIFY_EXPR)
|
{
|
{
|
tree rhs = TREE_OPERAND (stmt, 1);
|
tree rhs = TREE_OPERAND (stmt, 1);
|
enum tree_code rhs_code = TREE_CODE (rhs);
|
enum tree_code rhs_code = TREE_CODE (rhs);
|
|
|
/* Transform TRUNC_DIV_EXPR and TRUNC_MOD_EXPR into RSHIFT_EXPR
|
/* Transform TRUNC_DIV_EXPR and TRUNC_MOD_EXPR into RSHIFT_EXPR
|
and BIT_AND_EXPR respectively if the first operand is greater
|
and BIT_AND_EXPR respectively if the first operand is greater
|
than zero and the second operand is an exact power of two. */
|
than zero and the second operand is an exact power of two. */
|
if ((rhs_code == TRUNC_DIV_EXPR || rhs_code == TRUNC_MOD_EXPR)
|
if ((rhs_code == TRUNC_DIV_EXPR || rhs_code == TRUNC_MOD_EXPR)
|
&& INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (rhs, 0)))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (rhs, 0)))
|
&& integer_pow2p (TREE_OPERAND (rhs, 1)))
|
&& integer_pow2p (TREE_OPERAND (rhs, 1)))
|
simplify_div_or_mod_using_ranges (stmt, rhs, rhs_code);
|
simplify_div_or_mod_using_ranges (stmt, rhs, rhs_code);
|
|
|
/* Transform ABS (X) into X or -X as appropriate. */
|
/* Transform ABS (X) into X or -X as appropriate. */
|
if (rhs_code == ABS_EXPR
|
if (rhs_code == ABS_EXPR
|
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
|
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
|
&& INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (rhs, 0))))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (rhs, 0))))
|
simplify_abs_using_ranges (stmt, rhs);
|
simplify_abs_using_ranges (stmt, rhs);
|
}
|
}
|
else if (TREE_CODE (stmt) == COND_EXPR
|
else if (TREE_CODE (stmt) == COND_EXPR
|
&& COMPARISON_CLASS_P (COND_EXPR_COND (stmt)))
|
&& COMPARISON_CLASS_P (COND_EXPR_COND (stmt)))
|
{
|
{
|
simplify_cond_using_ranges (stmt);
|
simplify_cond_using_ranges (stmt);
|
}
|
}
|
}
|
}
|
|
|
/* Stack of dest,src equivalency pairs that need to be restored after
|
/* 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.
|
each attempt to thread a block's incoming edge to an outgoing edge.
|
|
|
A NULL entry is used to mark the end of pairs which need to be
|
A NULL entry is used to mark the end of pairs which need to be
|
restored. */
|
restored. */
|
static VEC(tree,heap) *stack;
|
static VEC(tree,heap) *stack;
|
|
|
/* A trivial wrapper so that we can present the generic jump threading
|
/* A trivial wrapper so that we can present the generic jump threading
|
code with a simple API for simplifying statements. STMT is the
|
code with a simple API for simplifying statements. STMT is the
|
statement we want to simplify, WITHIN_STMT provides the location
|
statement we want to simplify, WITHIN_STMT provides the location
|
for any overflow warnings. */
|
for any overflow warnings. */
|
|
|
static tree
|
static tree
|
simplify_stmt_for_jump_threading (tree stmt, tree within_stmt)
|
simplify_stmt_for_jump_threading (tree stmt, tree within_stmt)
|
{
|
{
|
/* We only use VRP information to simplify conditionals. This is
|
/* We only use VRP information to simplify conditionals. This is
|
overly conservative, but it's unclear if doing more would be
|
overly conservative, but it's unclear if doing more would be
|
worth the compile time cost. */
|
worth the compile time cost. */
|
if (TREE_CODE (stmt) != COND_EXPR)
|
if (TREE_CODE (stmt) != COND_EXPR)
|
return NULL;
|
return NULL;
|
|
|
return vrp_evaluate_conditional (COND_EXPR_COND (stmt), within_stmt);
|
return vrp_evaluate_conditional (COND_EXPR_COND (stmt), within_stmt);
|
}
|
}
|
|
|
/* Blocks which have more than one predecessor and more than
|
/* Blocks which have more than one predecessor and more than
|
one successor present jump threading opportunities. ie,
|
one successor present jump threading opportunities. ie,
|
when the block is reached from a specific predecessor, we
|
when the block is reached from a specific predecessor, we
|
may be able to determine which of the outgoing edges will
|
may be able to determine which of the outgoing edges will
|
be traversed. When this optimization applies, we are able
|
be traversed. When this optimization applies, we are able
|
to avoid conditionals at runtime and we may expose secondary
|
to avoid conditionals at runtime and we may expose secondary
|
optimization opportunities.
|
optimization opportunities.
|
|
|
This routine is effectively a driver for the generic jump
|
This routine is effectively a driver for the generic jump
|
threading code. It basically just presents the generic code
|
threading code. It basically just presents the generic code
|
with edges that may be suitable for jump threading.
|
with edges that may be suitable for jump threading.
|
|
|
Unlike DOM, we do not iterate VRP if jump threading was successful.
|
Unlike DOM, we do not iterate VRP if jump threading was successful.
|
While iterating may expose new opportunities for VRP, it is expected
|
While iterating may expose new opportunities for VRP, it is expected
|
those opportunities would be very limited and the compile time cost
|
those opportunities would be very limited and the compile time cost
|
to expose those opportunities would be significant.
|
to expose those opportunities would be significant.
|
|
|
As jump threading opportunities are discovered, they are registered
|
As jump threading opportunities are discovered, they are registered
|
for later realization. */
|
for later realization. */
|
|
|
static void
|
static void
|
identify_jump_threads (void)
|
identify_jump_threads (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
tree dummy;
|
tree dummy;
|
|
|
/* Ugh. When substituting values earlier in this pass we can
|
/* Ugh. When substituting values earlier in this pass we can
|
wipe the dominance information. So rebuild the dominator
|
wipe the dominance information. So rebuild the dominator
|
information as we need it within the jump threading code. */
|
information as we need it within the jump threading code. */
|
calculate_dominance_info (CDI_DOMINATORS);
|
calculate_dominance_info (CDI_DOMINATORS);
|
|
|
/* We do not allow VRP information to be used for jump threading
|
/* We do not allow VRP information to be used for jump threading
|
across a back edge in the CFG. Otherwise it becomes too
|
across a back edge in the CFG. Otherwise it becomes too
|
difficult to avoid eliminating loop exit tests. Of course
|
difficult to avoid eliminating loop exit tests. Of course
|
EDGE_DFS_BACK is not accurate at this time so we have to
|
EDGE_DFS_BACK is not accurate at this time so we have to
|
recompute it. */
|
recompute it. */
|
mark_dfs_back_edges ();
|
mark_dfs_back_edges ();
|
|
|
/* Allocate our unwinder stack to unwind any temporary equivalences
|
/* Allocate our unwinder stack to unwind any temporary equivalences
|
that might be recorded. */
|
that might be recorded. */
|
stack = VEC_alloc (tree, heap, 20);
|
stack = VEC_alloc (tree, heap, 20);
|
|
|
/* To avoid lots of silly node creation, we create a single
|
/* To avoid lots of silly node creation, we create a single
|
conditional and just modify it in-place when attempting to
|
conditional and just modify it in-place when attempting to
|
thread jumps. */
|
thread jumps. */
|
dummy = build2 (EQ_EXPR, boolean_type_node, NULL, NULL);
|
dummy = build2 (EQ_EXPR, boolean_type_node, NULL, NULL);
|
dummy = build3 (COND_EXPR, void_type_node, dummy, NULL, NULL);
|
dummy = build3 (COND_EXPR, void_type_node, dummy, NULL, NULL);
|
|
|
/* Walk through all the blocks finding those which present a
|
/* Walk through all the blocks finding those which present a
|
potential jump threading opportunity. We could set this up
|
potential jump threading opportunity. We could set this up
|
as a dominator walker and record data during the walk, but
|
as a dominator walker and record data during the walk, but
|
I doubt it's worth the effort for the classes of jump
|
I doubt it's worth the effort for the classes of jump
|
threading opportunities we are trying to identify at this
|
threading opportunities we are trying to identify at this
|
point in compilation. */
|
point in compilation. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
tree last, cond;
|
tree last, cond;
|
|
|
/* If the generic jump threading code does not find this block
|
/* If the generic jump threading code does not find this block
|
interesting, then there is nothing to do. */
|
interesting, then there is nothing to do. */
|
if (! potentially_threadable_block (bb))
|
if (! potentially_threadable_block (bb))
|
continue;
|
continue;
|
|
|
/* We only care about blocks ending in a COND_EXPR. While there
|
/* We only care about blocks ending in a COND_EXPR. While there
|
may be some value in handling SWITCH_EXPR here, I doubt it's
|
may be some value in handling SWITCH_EXPR here, I doubt it's
|
terribly important. */
|
terribly important. */
|
last = bsi_stmt (bsi_last (bb));
|
last = bsi_stmt (bsi_last (bb));
|
if (TREE_CODE (last) != COND_EXPR)
|
if (TREE_CODE (last) != COND_EXPR)
|
continue;
|
continue;
|
|
|
/* We're basically looking for any kind of conditional with
|
/* We're basically looking for any kind of conditional with
|
integral type arguments. */
|
integral type arguments. */
|
cond = COND_EXPR_COND (last);
|
cond = COND_EXPR_COND (last);
|
if ((TREE_CODE (cond) == SSA_NAME
|
if ((TREE_CODE (cond) == SSA_NAME
|
&& INTEGRAL_TYPE_P (TREE_TYPE (cond)))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (cond)))
|
|| (COMPARISON_CLASS_P (cond)
|
|| (COMPARISON_CLASS_P (cond)
|
&& TREE_CODE (TREE_OPERAND (cond, 0)) == SSA_NAME
|
&& TREE_CODE (TREE_OPERAND (cond, 0)) == SSA_NAME
|
&& INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (cond, 0)))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (cond, 0)))
|
&& (TREE_CODE (TREE_OPERAND (cond, 1)) == SSA_NAME
|
&& (TREE_CODE (TREE_OPERAND (cond, 1)) == SSA_NAME
|
|| is_gimple_min_invariant (TREE_OPERAND (cond, 1)))
|
|| is_gimple_min_invariant (TREE_OPERAND (cond, 1)))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (cond, 1)))))
|
&& INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (cond, 1)))))
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
|
|
/* We've got a block with multiple predecessors and multiple
|
/* We've got a block with multiple predecessors and multiple
|
successors which also ends in a suitable conditional. For
|
successors which also ends in a suitable conditional. For
|
each predecessor, see if we can thread it to a specific
|
each predecessor, see if we can thread it to a specific
|
successor. */
|
successor. */
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
{
|
{
|
/* Do not thread across back edges or abnormal edges
|
/* Do not thread across back edges or abnormal edges
|
in the CFG. */
|
in the CFG. */
|
if (e->flags & (EDGE_DFS_BACK | EDGE_COMPLEX))
|
if (e->flags & (EDGE_DFS_BACK | EDGE_COMPLEX))
|
continue;
|
continue;
|
|
|
thread_across_edge (dummy, e, true,
|
thread_across_edge (dummy, e, true,
|
&stack,
|
&stack,
|
simplify_stmt_for_jump_threading);
|
simplify_stmt_for_jump_threading);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* We do not actually update the CFG or SSA graphs at this point as
|
/* We do not actually update the CFG or SSA graphs at this point as
|
ASSERT_EXPRs are still in the IL and cfg cleanup code does not yet
|
ASSERT_EXPRs are still in the IL and cfg cleanup code does not yet
|
handle ASSERT_EXPRs gracefully. */
|
handle ASSERT_EXPRs gracefully. */
|
}
|
}
|
|
|
/* We identified all the jump threading opportunities earlier, but could
|
/* We identified all the jump threading opportunities earlier, but could
|
not transform the CFG at that time. This routine transforms the
|
not transform the CFG at that time. This routine transforms the
|
CFG and arranges for the dominator tree to be rebuilt if necessary.
|
CFG and arranges for the dominator tree to be rebuilt if necessary.
|
|
|
Note the SSA graph update will occur during the normal TODO
|
Note the SSA graph update will occur during the normal TODO
|
processing by the pass manager. */
|
processing by the pass manager. */
|
static void
|
static void
|
finalize_jump_threads (void)
|
finalize_jump_threads (void)
|
{
|
{
|
bool cfg_altered = false;
|
bool cfg_altered = false;
|
cfg_altered = thread_through_all_blocks ();
|
cfg_altered = thread_through_all_blocks ();
|
|
|
/* If we threaded jumps, then we need to recompute the dominance
|
/* If we threaded jumps, then we need to recompute the dominance
|
information, to safely do that we must clean up the CFG first. */
|
information, to safely do that we must clean up the CFG first. */
|
if (cfg_altered)
|
if (cfg_altered)
|
{
|
{
|
free_dominance_info (CDI_DOMINATORS);
|
free_dominance_info (CDI_DOMINATORS);
|
cleanup_tree_cfg ();
|
cleanup_tree_cfg ();
|
calculate_dominance_info (CDI_DOMINATORS);
|
calculate_dominance_info (CDI_DOMINATORS);
|
}
|
}
|
VEC_free (tree, heap, stack);
|
VEC_free (tree, heap, stack);
|
}
|
}
|
|
|
|
|
/* Traverse all the blocks folding conditionals with known ranges. */
|
/* Traverse all the blocks folding conditionals with known ranges. */
|
|
|
static void
|
static void
|
vrp_finalize (void)
|
vrp_finalize (void)
|
{
|
{
|
size_t i;
|
size_t i;
|
prop_value_t *single_val_range;
|
prop_value_t *single_val_range;
|
bool do_value_subst_p;
|
bool do_value_subst_p;
|
|
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "\nValue ranges after VRP:\n\n");
|
fprintf (dump_file, "\nValue ranges after VRP:\n\n");
|
dump_all_value_ranges (dump_file);
|
dump_all_value_ranges (dump_file);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
|
|
/* We may have ended with ranges that have exactly one value. Those
|
/* 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 copy/const propagated
|
value using substitute_and_fold. */
|
value using substitute_and_fold. */
|
single_val_range = XNEWVEC (prop_value_t, num_ssa_names);
|
single_val_range = XNEWVEC (prop_value_t, num_ssa_names);
|
memset (single_val_range, 0, num_ssa_names * sizeof (*single_val_range));
|
memset (single_val_range, 0, num_ssa_names * sizeof (*single_val_range));
|
|
|
do_value_subst_p = false;
|
do_value_subst_p = false;
|
for (i = 0; i < num_ssa_names; i++)
|
for (i = 0; i < num_ssa_names; i++)
|
if (vr_value[i]
|
if (vr_value[i]
|
&& vr_value[i]->type == VR_RANGE
|
&& vr_value[i]->type == VR_RANGE
|
&& vr_value[i]->min == vr_value[i]->max)
|
&& vr_value[i]->min == vr_value[i]->max)
|
{
|
{
|
single_val_range[i].value = vr_value[i]->min;
|
single_val_range[i].value = vr_value[i]->min;
|
do_value_subst_p = true;
|
do_value_subst_p = true;
|
}
|
}
|
|
|
if (!do_value_subst_p)
|
if (!do_value_subst_p)
|
{
|
{
|
/* We found no single-valued ranges, don't waste time trying to
|
/* We found no single-valued ranges, don't waste time trying to
|
do single value substitution in substitute_and_fold. */
|
do single value substitution in substitute_and_fold. */
|
free (single_val_range);
|
free (single_val_range);
|
single_val_range = NULL;
|
single_val_range = NULL;
|
}
|
}
|
|
|
substitute_and_fold (single_val_range, true);
|
substitute_and_fold (single_val_range, true);
|
|
|
/* We must identify jump threading opportunities before we release
|
/* We must identify jump threading opportunities before we release
|
the datastructures built by VRP. */
|
the datastructures built by VRP. */
|
identify_jump_threads ();
|
identify_jump_threads ();
|
|
|
/* Free allocated memory. */
|
/* Free allocated memory. */
|
for (i = 0; i < num_ssa_names; i++)
|
for (i = 0; i < num_ssa_names; i++)
|
if (vr_value[i])
|
if (vr_value[i])
|
{
|
{
|
BITMAP_FREE (vr_value[i]->equiv);
|
BITMAP_FREE (vr_value[i]->equiv);
|
free (vr_value[i]);
|
free (vr_value[i]);
|
}
|
}
|
|
|
free (single_val_range);
|
free (single_val_range);
|
free (vr_value);
|
free (vr_value);
|
|
|
/* So that we can distinguish between VRP data being available
|
/* So that we can distinguish between VRP data being available
|
and not available. */
|
and not available. */
|
vr_value = NULL;
|
vr_value = NULL;
|
}
|
}
|
|
|
|
|
/* Main entry point to VRP (Value Range Propagation). This pass is
|
/* Main entry point to VRP (Value Range Propagation). This pass is
|
loosely based on J. R. C. Patterson, ``Accurate Static Branch
|
loosely based on J. R. C. Patterson, ``Accurate Static Branch
|
Prediction by Value Range Propagation,'' in SIGPLAN Conference on
|
Prediction by Value Range Propagation,'' in SIGPLAN Conference on
|
Programming Language Design and Implementation, pp. 67-78, 1995.
|
Programming Language Design and Implementation, pp. 67-78, 1995.
|
Also available at http://citeseer.ist.psu.edu/patterson95accurate.html
|
Also available at http://citeseer.ist.psu.edu/patterson95accurate.html
|
|
|
This is essentially an SSA-CCP pass modified to deal with ranges
|
This is essentially an SSA-CCP pass modified to deal with ranges
|
instead of constants.
|
instead of constants.
|
|
|
While propagating ranges, we may find that two or more SSA name
|
While propagating ranges, we may find that two or more SSA name
|
have equivalent, though distinct ranges. For instance,
|
have equivalent, though distinct ranges. For instance,
|
|
|
1 x_9 = p_3->a;
|
1 x_9 = p_3->a;
|
2 p_4 = ASSERT_EXPR <p_3, p_3 != 0>
|
2 p_4 = ASSERT_EXPR <p_3, p_3 != 0>
|
3 if (p_4 == q_2)
|
3 if (p_4 == q_2)
|
4 p_5 = ASSERT_EXPR <p_4, p_4 == q_2>;
|
4 p_5 = ASSERT_EXPR <p_4, p_4 == q_2>;
|
5 endif
|
5 endif
|
6 if (q_2)
|
6 if (q_2)
|
|
|
In the code above, pointer p_5 has range [q_2, q_2], but from the
|
In the code above, pointer p_5 has range [q_2, q_2], but from the
|
code we can also determine that p_5 cannot be NULL and, if q_2 had
|
code we can also determine that p_5 cannot be NULL and, if q_2 had
|
a non-varying range, p_5's range should also be compatible with it.
|
a non-varying range, p_5's range should also be compatible with it.
|
|
|
These equivalences are created by two expressions: ASSERT_EXPR and
|
These equivalences are created by two expressions: ASSERT_EXPR and
|
copy operations. Since p_5 is an assertion on p_4, and p_4 was the
|
copy operations. Since p_5 is an assertion on p_4, and p_4 was the
|
result of another assertion, then we can use the fact that p_5 and
|
result of another assertion, then we can use the fact that p_5 and
|
p_4 are equivalent when evaluating p_5's range.
|
p_4 are equivalent when evaluating p_5's range.
|
|
|
Together with value ranges, we also propagate these equivalences
|
Together with value ranges, we also propagate these equivalences
|
between names so that we can take advantage of information from
|
between names so that we can take advantage of information from
|
multiple ranges when doing final replacement. Note that this
|
multiple ranges when doing final replacement. Note that this
|
equivalency relation is transitive but not symmetric.
|
equivalency relation is transitive but not symmetric.
|
|
|
In the example above, p_5 is equivalent to p_4, q_2 and p_3, but we
|
In the example above, p_5 is equivalent to p_4, q_2 and p_3, but we
|
cannot assert that q_2 is equivalent to p_5 because q_2 may be used
|
cannot assert that q_2 is equivalent to p_5 because q_2 may be used
|
in contexts where that assertion does not hold (e.g., in line 6).
|
in contexts where that assertion does not hold (e.g., in line 6).
|
|
|
TODO, the main difference between this pass and Patterson's is that
|
TODO, the main difference between this pass and Patterson's is that
|
we do not propagate edge probabilities. We only compute whether
|
we do not propagate edge probabilities. We only compute whether
|
edges can be taken or not. That is, instead of having a spectrum
|
edges can be taken or not. That is, instead of having a spectrum
|
of jump probabilities between 0 and 1, we only deal with 0, 1 and
|
of jump probabilities between 0 and 1, we only deal with 0, 1 and
|
DON'T KNOW. In the future, it may be worthwhile to propagate
|
DON'T KNOW. In the future, it may be worthwhile to propagate
|
probabilities to aid branch prediction. */
|
probabilities to aid branch prediction. */
|
|
|
static unsigned int
|
static unsigned int
|
execute_vrp (void)
|
execute_vrp (void)
|
{
|
{
|
insert_range_assertions ();
|
insert_range_assertions ();
|
|
|
current_loops = loop_optimizer_init (LOOPS_NORMAL);
|
current_loops = loop_optimizer_init (LOOPS_NORMAL);
|
if (current_loops)
|
if (current_loops)
|
scev_initialize (current_loops);
|
scev_initialize (current_loops);
|
|
|
vrp_initialize ();
|
vrp_initialize ();
|
ssa_propagate (vrp_visit_stmt, vrp_visit_phi_node);
|
ssa_propagate (vrp_visit_stmt, vrp_visit_phi_node);
|
vrp_finalize ();
|
vrp_finalize ();
|
|
|
if (current_loops)
|
if (current_loops)
|
{
|
{
|
scev_finalize ();
|
scev_finalize ();
|
loop_optimizer_finalize (current_loops);
|
loop_optimizer_finalize (current_loops);
|
current_loops = NULL;
|
current_loops = NULL;
|
}
|
}
|
|
|
/* ASSERT_EXPRs must be removed before finalizing jump threads
|
/* ASSERT_EXPRs must be removed before finalizing jump threads
|
as finalizing jump threads calls the CFG cleanup code which
|
as finalizing jump threads calls the CFG cleanup code which
|
does not properly handle ASSERT_EXPRs. */
|
does not properly handle ASSERT_EXPRs. */
|
remove_range_assertions ();
|
remove_range_assertions ();
|
|
|
/* If we exposed any new variables, go ahead and put them into
|
/* If we exposed any new variables, go ahead and put them into
|
SSA form now, before we handle jump threading. This simplifies
|
SSA form now, before we handle jump threading. This simplifies
|
interactions between rewriting of _DECL nodes into SSA form
|
interactions between rewriting of _DECL nodes into SSA form
|
and rewriting SSA_NAME nodes into SSA form after block
|
and rewriting SSA_NAME nodes into SSA form after block
|
duplication and CFG manipulation. */
|
duplication and CFG manipulation. */
|
update_ssa (TODO_update_ssa);
|
update_ssa (TODO_update_ssa);
|
|
|
finalize_jump_threads ();
|
finalize_jump_threads ();
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static bool
|
static bool
|
gate_vrp (void)
|
gate_vrp (void)
|
{
|
{
|
return flag_tree_vrp != 0;
|
return flag_tree_vrp != 0;
|
}
|
}
|
|
|
struct tree_opt_pass pass_vrp =
|
struct tree_opt_pass pass_vrp =
|
{
|
{
|
"vrp", /* name */
|
"vrp", /* name */
|
gate_vrp, /* gate */
|
gate_vrp, /* gate */
|
execute_vrp, /* execute */
|
execute_vrp, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_TREE_VRP, /* tv_id */
|
TV_TREE_VRP, /* tv_id */
|
PROP_ssa | PROP_alias, /* properties_required */
|
PROP_ssa | PROP_alias, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
PROP_smt_usage, /* properties_destroyed */
|
PROP_smt_usage, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_cleanup_cfg
|
TODO_cleanup_cfg
|
| TODO_ggc_collect
|
| TODO_ggc_collect
|
| TODO_verify_ssa
|
| TODO_verify_ssa
|
| TODO_dump_func
|
| TODO_dump_func
|
| TODO_update_ssa
|
| TODO_update_ssa
|
| TODO_update_smt_usage, /* todo_flags_finish */
|
| TODO_update_smt_usage, /* todo_flags_finish */
|
0 /* letter */
|
0 /* letter */
|
};
|
};
|
|
|
