From c2ad9885c01b3c5dd951dd707773de66cd7bb27c Mon Sep 17 00:00:00 2001 From: Jeff Law Date: Tue, 14 Nov 2017 17:18:45 -0700 Subject: [PATCH] vr-values.c: New file with contents extracted from tree-vrp.c. * vr-values.c: New file with contents extracted from tree-vrp.c. * Makefile.in (OBJS): Add vr-values.o * tree-vrp.h (set_value_range_to_nonnull): Prototype. (set_value_range, set_and_canonicalize_value_range): Likewise. (vrp_bitmap_equal_p, range_is_nonnull): Likewise. (value_range_constant_singleton, symbolic_range_p): Likewise. (compare_values, compare_values_warnv, vrp_val_is_min): Likewise. (vrp_val_is_max, copy_value_range, set_value_range_to_value): Likewise. (extract_range_from_binary_expr_1, vrp_val_min, vrp_val_max): Likewise. (set_value_range_to_null, range_int_cst_p, opreand_less_p): Likewise. (find_case_label_range, find_case_label_index): Likewise. (zero_nonzero_bits_from_vr, overflow_comparison_p): Likewise. (range_int_cst_singleton_p, value_inside_range): Likewise. (get_single_symbol): Likewise. (switch_update): Move structure definition here. (to_remove_edges, to_update_switch_stmts): Provide externs. * tree-vrp.c: Move all methods for vr-values class to vr-values.c (vrp_val_max, vrp_val_min, vrp_val_is_max): Make externally visible. (vrp_val_is_min, set_value_range): Likewise. (set_and_canonicalize_value_range, copy_value_range): Likewise. (set_value_range_to_value, set_value_range_to_nonnull): Likewise. (set_value_range_to_null, vrp_bitmap_equal_p): Likewise. (range_is_nonnull, range_int_cst_p): Likewwise. (range_int_cst_singleton_p, symbolic_range_p): Likewise. (get_single_symbol, operand_less_p): Likewise (compare_values_warnv, compare_values): Likewise. (value_inside_range, value_range_constant_singleton): Likewise. (zero_nonzero_bitgs_from_vr): Likewise. (extract_range_from_binary_expr_1): Likewise. (overflow_comparison_p): Likewise. (to_remove_edges, to_update_switch_stmts): Likewise. (find_case_label-index, find_case_label_range): Likewise. (switch_update, set_value_range_to_nonnegative): Remove. (set_value_range_to_truthvalue): Likewise. (symbolic_range_based_on_p, gimple_assign_nonzero_p): Likewise. (gimple_stmt_nonzero_p, compare_ranges): Likewise. (compare_range_with_value, vrp_valueize, vrp_valueize_1): Likewise. (find_case_label_ranges, test_for_singularity): Likewise. (range_fits_type_p, simplify_conversion_using_ranges): LIkewise. (x_vr_values): Move to its remaining use site. From-SVN: r254747 --- gcc/ChangeLog | 73 +- gcc/Makefile.in | 1 + gcc/tree-vrp.c | 10602 ++++++++++++++-------------------------------- gcc/tree-vrp.h | 42 + gcc/vr-values.c | 4183 ++++++++++++++++++ 5 files changed, 7510 insertions(+), 7391 deletions(-) create mode 100644 gcc/vr-values.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 15f391fb726..288e16347d5 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,61 @@ +2017-11-14 Jeff Law + + * vr-values.c: New file with contents extracted from tree-vrp.c. + * Makefile.in (OBJS): Add vr-values.o + * tree-vrp.h (set_value_range_to_nonnull): Prototype. + (set_value_range, set_and_canonicalize_value_range): Likewise. + (vrp_bitmap_equal_p, range_is_nonnull): Likewise. + (value_range_constant_singleton, symbolic_range_p): Likewise. + (compare_values, compare_values_warnv, vrp_val_is_min): Likewise. + (vrp_val_is_max, copy_value_range, set_value_range_to_value): Likewise. + (extract_range_from_binary_expr_1, vrp_val_min, vrp_val_max): Likewise. + (set_value_range_to_null, range_int_cst_p, opreand_less_p): Likewise. + (find_case_label_range, find_case_label_index): Likewise. + (zero_nonzero_bits_from_vr, overflow_comparison_p): Likewise. + (range_int_cst_singleton_p, value_inside_range): Likewise. + (get_single_symbol): Likewise. + (switch_update): Move structure definition here. + (to_remove_edges, to_update_switch_stmts): Provide externs. + * tree-vrp.c: Move all methods for vr-values class to vr-values.c + (vrp_val_max, vrp_val_min, vrp_val_is_max): Make externally visible. + (vrp_val_is_min, set_value_range): Likewise. + (set_and_canonicalize_value_range, copy_value_range): Likewise. + (set_value_range_to_value, set_value_range_to_nonnull): Likewise. + (set_value_range_to_null, vrp_bitmap_equal_p): Likewise. + (range_is_nonnull, range_int_cst_p): Likewwise. + (range_int_cst_singleton_p, symbolic_range_p): Likewise. + (get_single_symbol, operand_less_p): Likewise + (compare_values_warnv, compare_values): Likewise. + (value_inside_range, value_range_constant_singleton): Likewise. + (zero_nonzero_bitgs_from_vr): Likewise. + (extract_range_from_binary_expr_1): Likewise. + (overflow_comparison_p): Likewise. + (to_remove_edges, to_update_switch_stmts): Likewise. + (find_case_label-index, find_case_label_range): Likewise. + (switch_update, set_value_range_to_nonnegative): Remove. + (set_value_range_to_truthvalue): Likewise. + (symbolic_range_based_on_p, gimple_assign_nonzero_p): Likewise. + (gimple_stmt_nonzero_p, compare_ranges): Likewise. + (compare_range_with_value, vrp_valueize, vrp_valueize_1): Likewise. + (find_case_label_ranges, test_for_singularity): Likewise. + (range_fits_type_p, simplify_conversion_using_ranges): LIkewise. + (x_vr_values): Move to its remaining use site. + +2017-11-10 Jeff Law + + * vr-values.h (VR_INITIALIZER): Move #define here. + * gimple-ssa-evrp.c: New file with contents extracted from tree-vrp.c + * Makefile.in (OBJS): Add tree-evrp.o + * tree-vrp.h (assert_info): Move structure definition here. + (set_value_range_to_varying): Prototype. + (vrp_operand_equal_p, range_includes_zero_p): Likewise. + (infer_value_range, register_edge_assert_for): Likewise. + (stmt_interesting_for_vrp): Likewise. + * tree-vrp.c: Move all methods for evrp class into gimple-ssa-evrp.c. + (set_value_range_to_varying): No longer static. + (vrp_operand_equal_p, range_includes_zero_p): Likewise. + (infer_value_range, register_edge_assert_for): Likewise. + 2017-11-14 Michael Meissner * config/rs6000/rs6000.md (bswapdi2): On 32-bit ISA 3.0, don't @@ -430,21 +488,6 @@ with memcpy. (find_subframework_file): Same. -2017-11-10 Jeff Law - - * vr-values.h (VR_INITIALIZER): Move #define here. - * gimple-ssa-evrp.c: New file with contents extracted from tree-vrp.c - * Makefile.in (OBJS): Add tree-evrp.o - * tree-vrp.h (assert_info): Move structure definition here. - (set_value_range_to_varying): Prototype. - (vrp_operand_equal_p, range_includes_zero_p): Likewise. - (infer_value_range, register_edge_assert_for): Likewise. - (stmt_interesting_for_vrp): Likewise. - * tree-vrp.c: Move all methods for evrp class into gimple-ssa-evrp.c. - (set_value_range_to_varying): No longer static. - (vrp_operand_equal_p, range_includes_zero_p): Likewise. - (infer_value_range, register_edge_assert_for): Likewise. - 2017-11-10 Jan Hubicka * auto-profile.c (afdo_indirect_call): Drop frequency. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 824cf3e3ea0..5db78558c0c 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1577,6 +1577,7 @@ OBJS = \ varasm.o \ varpool.o \ vmsdbgout.o \ + vr-values.o \ vtable-verify.o \ web.o \ wide-int.o \ diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index 6fae6b2efb8..945b3a9935e 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -79,10 +79,6 @@ live_on_edge (edge e, tree name) && bitmap_bit_p (live[e->dest->index], SSA_NAME_VERSION (name))); } -/* Local functions. */ -static int compare_values (tree val1, tree val2); -static int compare_values_warnv (tree val1, tree val2, bool *); - /* Location information for ASSERT_EXPRs. Each instance of this structure describes an ASSERT_EXPR for an SSA name. Since a single SSA name may have more than one assertion associated with it, these @@ -122,18 +118,13 @@ static bitmap need_assert_for; ASSERT_EXPRs for SSA name N_I should be inserted. */ static assert_locus **asserts_for; -struct switch_update { - gswitch *stmt; - tree vec; -}; - -static vec to_remove_edges; -static vec to_update_switch_stmts; +vec to_remove_edges; +vec to_update_switch_stmts; /* Return the maximum value for TYPE. */ -static inline tree +tree vrp_val_max (const_tree type) { if (!INTEGRAL_TYPE_P (type)) @@ -144,7 +135,7 @@ vrp_val_max (const_tree type) /* Return the minimum value for TYPE. */ -static inline tree +tree vrp_val_min (const_tree type) { if (!INTEGRAL_TYPE_P (type)) @@ -158,7 +149,7 @@ vrp_val_min (const_tree type) C typedefs and Ada subtypes can produce types whose TYPE_MAX_VALUE is not == to the integer constant with the same value in the type. */ -static inline bool +bool vrp_val_is_max (const_tree val) { tree type_max = vrp_val_max (TREE_TYPE (val)); @@ -169,7 +160,7 @@ vrp_val_is_max (const_tree val) /* Return whether VAL is equal to the minimum value of its type. */ -static inline bool +bool vrp_val_is_min (const_tree val) { tree type_min = vrp_val_min (TREE_TYPE (val)); @@ -203,7 +194,7 @@ set_value_range_to_varying (value_range *vr) /* Set value range VR to {T, MIN, MAX, EQUIV}. */ -static void +void set_value_range (value_range *vr, enum value_range_type t, tree min, tree max, bitmap equiv) { @@ -263,7 +254,7 @@ set_value_range (value_range *vr, enum value_range_type t, tree min, This routine exists to ease canonicalization in the case where we extract ranges from var + CST op limit. */ -static void +void set_and_canonicalize_value_range (value_range *vr, enum value_range_type t, tree min, tree max, bitmap equiv) { @@ -371,7 +362,7 @@ set_and_canonicalize_value_range (value_range *vr, enum value_range_type t, /* Copy value range FROM into value range TO. */ -static inline void +void copy_value_range (value_range *to, value_range *from) { set_value_range (to, from->type, from->min, from->max, from->equiv); @@ -381,7 +372,7 @@ copy_value_range (value_range *to, value_range *from) with values we get from statements, and exists to clear the TREE_OVERFLOW flag. */ -static inline void +void set_value_range_to_value (value_range *vr, tree val, bitmap equiv) { gcc_assert (is_gimple_min_invariant (val)); @@ -390,18 +381,9 @@ set_value_range_to_value (value_range *vr, tree val, bitmap equiv) set_value_range (vr, VR_RANGE, val, val, equiv); } -/* Set value range VR to a non-negative range of type TYPE. */ - -static inline void -set_value_range_to_nonnegative (value_range *vr, tree type) -{ - tree zero = build_int_cst (type, 0); - set_value_range (vr, VR_RANGE, zero, vrp_val_max (type), vr->equiv); -} - /* Set value range VR to a non-NULL range of type TYPE. */ -static inline void +void set_value_range_to_nonnull (value_range *vr, tree type) { tree zero = build_int_cst (type, 0); @@ -411,27 +393,13 @@ set_value_range_to_nonnull (value_range *vr, tree type) /* Set value range VR to a NULL range of type TYPE. */ -static inline void +void set_value_range_to_null (value_range *vr, tree type) { set_value_range_to_value (vr, build_int_cst (type, 0), vr->equiv); } -/* Set value range VR to a range of a truthvalue of type TYPE. */ - -static inline void -set_value_range_to_truthvalue (value_range *vr, tree type) -{ - if (TYPE_PRECISION (type) == 1) - set_value_range_to_varying (vr); - else - set_value_range (vr, VR_RANGE, - build_int_cst (type, 0), build_int_cst (type, 1), - vr->equiv); -} - - /* If abs (min) < abs (max), set VR to [-max, max], if abs (min) >= abs (max), set VR to [-min, min]. */ @@ -467,100 +435,6 @@ abs_extent_range (value_range *vr, tree min, tree max) set_and_canonicalize_value_range (vr, VR_RANGE, min, max, NULL); } - -/* Return value range information for VAR. - - 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. */ - -value_range * -vr_values::get_value_range (const_tree var) -{ - static const value_range vr_const_varying - = { VR_VARYING, NULL_TREE, NULL_TREE, NULL }; - value_range *vr; - tree sym; - unsigned ver = SSA_NAME_VERSION (var); - - /* If we have no recorded ranges, then return NULL. */ - if (! vr_value) - return NULL; - - /* If we query the range for a new SSA name return an unmodifiable VARYING. - We should get here at most from the substitute-and-fold stage which - will never try to change values. */ - if (ver >= num_vr_values) - return CONST_CAST (value_range *, &vr_const_varying); - - vr = vr_value[ver]; - if (vr) - return vr; - - /* After propagation finished do not allocate new value-ranges. */ - if (values_propagated) - return CONST_CAST (value_range *, &vr_const_varying); - - /* Create a default value range. */ - vr_value[ver] = vr = vrp_value_range_pool.allocate (); - memset (vr, 0, sizeof (*vr)); - - /* Defer allocating the equivalence set. */ - vr->equiv = NULL; - - /* If VAR is a default definition of a parameter, the variable can - take any value in VAR's type. */ - if (SSA_NAME_IS_DEFAULT_DEF (var)) - { - sym = SSA_NAME_VAR (var); - if (TREE_CODE (sym) == PARM_DECL) - { - /* Try to use the "nonnull" attribute to create ~[0, 0] - anti-ranges for pointers. Note that this is only valid with - default definitions of PARM_DECLs. */ - if (POINTER_TYPE_P (TREE_TYPE (sym)) - && (nonnull_arg_p (sym) - || get_ptr_nonnull (var))) - set_value_range_to_nonnull (vr, TREE_TYPE (sym)); - else if (INTEGRAL_TYPE_P (TREE_TYPE (sym))) - { - wide_int min, max; - value_range_type rtype = get_range_info (var, &min, &max); - if (rtype == VR_RANGE || rtype == VR_ANTI_RANGE) - set_value_range (vr, rtype, - wide_int_to_tree (TREE_TYPE (var), min), - wide_int_to_tree (TREE_TYPE (var), max), - NULL); - else - set_value_range_to_varying (vr); - } - else - set_value_range_to_varying (vr); - } - else if (TREE_CODE (sym) == RESULT_DECL - && DECL_BY_REFERENCE (sym)) - set_value_range_to_nonnull (vr, TREE_TYPE (sym)); - } - - return vr; -} - -/* Set value-ranges of all SSA names defined by STMT to varying. */ - -void -vr_values::set_defs_to_varying (gimple *stmt) -{ - ssa_op_iter i; - tree def; - FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF) - { - value_range *vr = get_value_range (def); - /* Avoid writing to vr_const_varying get_value_range may return. */ - if (vr->type != VR_VARYING) - set_value_range_to_varying (vr); - } -} - - /* Return true, if VAL1 and VAL2 are equal values for VRP purposes. */ bool @@ -575,7 +449,7 @@ vrp_operand_equal_p (const_tree val1, const_tree val2) /* Return true, if the bitmaps B1 and B2 are equal. */ -static inline bool +bool vrp_bitmap_equal_p (const_bitmap b1, const_bitmap b2) { return (b1 == b2 @@ -585,92 +459,9 @@ vrp_bitmap_equal_p (const_bitmap b1, const_bitmap b2) && bitmap_equal_p (b1, b2))); } -/* Update the value range and equivalence set for variable VAR to - NEW_VR. Return true if NEW_VR is different from VAR's previous - value. - - NOTE: This function assumes that NEW_VR is a temporary value range - 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 - this function. Do not call update_value_range when NEW_VR - is the range object associated with another SSA name. */ - -bool -vr_values::update_value_range (const_tree var, value_range *new_vr) -{ - value_range *old_vr; - bool is_new; - - /* If there is a value-range on the SSA name from earlier analysis - factor that in. */ - if (INTEGRAL_TYPE_P (TREE_TYPE (var))) - { - wide_int min, max; - value_range_type rtype = get_range_info (var, &min, &max); - if (rtype == VR_RANGE || rtype == VR_ANTI_RANGE) - { - tree nr_min, nr_max; - nr_min = wide_int_to_tree (TREE_TYPE (var), min); - nr_max = wide_int_to_tree (TREE_TYPE (var), max); - value_range nr = VR_INITIALIZER; - set_and_canonicalize_value_range (&nr, rtype, nr_min, nr_max, NULL); - vrp_intersect_ranges (new_vr, &nr); - } - } - - /* Update the value range, if necessary. */ - old_vr = get_value_range (var); - is_new = old_vr->type != new_vr->type - || !vrp_operand_equal_p (old_vr->min, new_vr->min) - || !vrp_operand_equal_p (old_vr->max, new_vr->max) - || !vrp_bitmap_equal_p (old_vr->equiv, new_vr->equiv); - - if (is_new) - { - /* Do not allow transitions up the lattice. The following - is slightly more awkward than just new_vr->type < old_vr->type - because VR_RANGE and VR_ANTI_RANGE need to be considered - the same. We may not have is_new when transitioning to - UNDEFINED. If old_vr->type is VARYING, we shouldn't be - called. */ - if (new_vr->type == VR_UNDEFINED) - { - BITMAP_FREE (new_vr->equiv); - set_value_range_to_varying (old_vr); - set_value_range_to_varying (new_vr); - return true; - } - else - set_value_range (old_vr, new_vr->type, new_vr->min, new_vr->max, - new_vr->equiv); - } - - BITMAP_FREE (new_vr->equiv); - - return is_new; -} - - -/* Add VAR and VAR's equivalence set to EQUIV. This is the central - point where equivalence processing can be turned on/off. */ - -void -vr_values::add_equivalence (bitmap *equiv, const_tree var) -{ - unsigned ver = SSA_NAME_VERSION (var); - value_range *vr = get_value_range (var); - - if (*equiv == NULL) - *equiv = BITMAP_ALLOC (&vrp_equiv_obstack); - bitmap_set_bit (*equiv, ver); - if (vr && vr->equiv) - bitmap_ior_into (*equiv, vr->equiv); -} - - /* Return true if VR is ~[0, 0]. */ -static inline bool +bool range_is_nonnull (value_range *vr) { return vr->type == VR_ANTI_RANGE @@ -692,7 +483,7 @@ range_is_null (value_range *vr) /* Return true if max and min of VR are INTEGER_CST. It's not necessary a singleton. */ -static inline bool +bool range_int_cst_p (value_range *vr) { return (vr->type == VR_RANGE @@ -702,7 +493,7 @@ range_int_cst_p (value_range *vr) /* Return true if VR is a INTEGER_CST singleton. */ -static inline bool +bool range_int_cst_singleton_p (value_range *vr) { return (range_int_cst_p (vr) @@ -711,7 +502,7 @@ range_int_cst_singleton_p (value_range *vr) /* Return true if value range VR involves at least one symbol. */ -static inline bool +bool symbolic_range_p (value_range *vr) { return (!is_gimple_min_invariant (vr->min) @@ -722,7 +513,7 @@ symbolic_range_p (value_range *vr) otherwise. We only handle additive operations and set NEG to true if the symbol is negated and INV to the invariant part, if any. */ -static tree +tree get_single_symbol (tree t, bool *neg, tree *inv) { bool neg_; @@ -791,161 +582,11 @@ build_symbolic_expr (tree type, tree sym, bool neg, tree inv) return build2 (pointer_p ? POINTER_PLUS_EXPR : PLUS_EXPR, type, t, inv); } -/* Return true if value range VR involves exactly one symbol SYM. */ - -static bool -symbolic_range_based_on_p (value_range *vr, const_tree sym) -{ - bool neg, min_has_symbol, max_has_symbol; - tree inv; - - if (is_gimple_min_invariant (vr->min)) - min_has_symbol = false; - else if (get_single_symbol (vr->min, &neg, &inv) == sym) - min_has_symbol = true; - else - return false; - - if (is_gimple_min_invariant (vr->max)) - max_has_symbol = false; - else if (get_single_symbol (vr->max, &neg, &inv) == sym) - max_has_symbol = true; - else - return false; - - return (min_has_symbol || max_has_symbol); -} - -/* Return true if the result of assignment STMT is know to be non-zero. */ - -static bool -gimple_assign_nonzero_p (gimple *stmt) -{ - enum tree_code code = gimple_assign_rhs_code (stmt); - bool strict_overflow_p; - switch (get_gimple_rhs_class (code)) - { - case GIMPLE_UNARY_RHS: - return tree_unary_nonzero_warnv_p (gimple_assign_rhs_code (stmt), - gimple_expr_type (stmt), - gimple_assign_rhs1 (stmt), - &strict_overflow_p); - case GIMPLE_BINARY_RHS: - return tree_binary_nonzero_warnv_p (gimple_assign_rhs_code (stmt), - gimple_expr_type (stmt), - gimple_assign_rhs1 (stmt), - gimple_assign_rhs2 (stmt), - &strict_overflow_p); - case GIMPLE_TERNARY_RHS: - return false; - case GIMPLE_SINGLE_RHS: - return tree_single_nonzero_warnv_p (gimple_assign_rhs1 (stmt), - &strict_overflow_p); - case GIMPLE_INVALID_RHS: - gcc_unreachable (); - default: - gcc_unreachable (); - } -} - -/* Return true if STMT is known to compute a non-zero value. */ - -static bool -gimple_stmt_nonzero_p (gimple *stmt) -{ - switch (gimple_code (stmt)) - { - case GIMPLE_ASSIGN: - return gimple_assign_nonzero_p (stmt); - case GIMPLE_CALL: - { - tree fndecl = gimple_call_fndecl (stmt); - if (!fndecl) return false; - if (flag_delete_null_pointer_checks && !flag_check_new - && DECL_IS_OPERATOR_NEW (fndecl) - && !TREE_NOTHROW (fndecl)) - return true; - /* References are always non-NULL. */ - if (flag_delete_null_pointer_checks - && TREE_CODE (TREE_TYPE (fndecl)) == REFERENCE_TYPE) - return true; - if (flag_delete_null_pointer_checks && - lookup_attribute ("returns_nonnull", - TYPE_ATTRIBUTES (gimple_call_fntype (stmt)))) - return true; - - gcall *call_stmt = as_a (stmt); - unsigned rf = gimple_call_return_flags (call_stmt); - if (rf & ERF_RETURNS_ARG) - { - unsigned argnum = rf & ERF_RETURN_ARG_MASK; - if (argnum < gimple_call_num_args (call_stmt)) - { - tree arg = gimple_call_arg (call_stmt, argnum); - if (SSA_VAR_P (arg) - && infer_nonnull_range_by_attribute (stmt, arg)) - return true; - } - } - return gimple_alloca_call_p (stmt); - } - default: - gcc_unreachable (); - } -} - -/* Like tree_expr_nonzero_p, but this function uses value ranges - obtained so far. */ - -bool -vr_values::vrp_stmt_computes_nonzero (gimple *stmt) -{ - if (gimple_stmt_nonzero_p (stmt)) - return true; - - /* If we have an expression of the form &X->a, then the expression - is nonnull if X is nonnull. */ - if (is_gimple_assign (stmt) - && gimple_assign_rhs_code (stmt) == ADDR_EXPR) - { - tree expr = gimple_assign_rhs1 (stmt); - tree base = get_base_address (TREE_OPERAND (expr, 0)); - - if (base != NULL_TREE - && TREE_CODE (base) == MEM_REF - && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME) - { - value_range *vr = get_value_range (TREE_OPERAND (base, 0)); - if (range_is_nonnull (vr)) - return true; - } - } - - return false; -} - -/* Returns true if EXPR is a valid value (as expected by compare_values) -- - a gimple invariant, or SSA_NAME +- CST. */ - -static bool -valid_value_p (tree expr) -{ - if (TREE_CODE (expr) == SSA_NAME) - return true; - - if (TREE_CODE (expr) == PLUS_EXPR - || TREE_CODE (expr) == MINUS_EXPR) - return (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME - && TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST); - - return is_gimple_min_invariant (expr); -} - /* Return 1 if VAL < VAL2 0 if !(VAL < VAL2) -2 if those are incomparable. */ -static inline int +int operand_less_p (tree val, tree val2) { /* LT is folded faster than GE and others. Inline the common case. */ @@ -987,7 +628,7 @@ operand_less_p (tree val, tree val2) true if the return value is only valid if we assume that signed overflow is undefined. */ -static int +int compare_values_warnv (tree val1, tree val2, bool *strict_overflow_p) { if (val1 == val2) @@ -1124,7 +765,7 @@ compare_values_warnv (tree val1, tree val2, bool *strict_overflow_p) /* Compare values like compare_values_warnv. */ -static int +int compare_values (tree val1, tree val2) { bool sop; @@ -1139,7 +780,7 @@ compare_values (tree val1, tree val2) Benchmark compile/20001226-1.c compilation time after changing this function. */ -static inline int +int value_inside_range (tree val, tree min, tree max) { int cmp1, cmp2; @@ -1209,7 +850,7 @@ value_range_nonnegative_p (value_range *vr) /* If *VR has a value rante that is a single constant value return that, otherwise return NULL_TREE. */ -static tree +tree value_range_constant_singleton (value_range *vr) { if (vr->type == VR_RANGE @@ -1220,430 +861,80 @@ value_range_constant_singleton (value_range *vr) return NULL_TREE; } -/* If OP has a value range with a single constant value return that, - otherwise return NULL_TREE. This returns OP itself if OP is a - constant. */ - -tree -vr_values::op_with_constant_singleton_value_range (tree op) -{ - if (is_gimple_min_invariant (op)) - return op; - - if (TREE_CODE (op) != SSA_NAME) - return NULL_TREE; - - return value_range_constant_singleton (get_value_range (op)); -} +/* Wrapper around int_const_binop. Return true if we can compute the + result; i.e. if the operation doesn't overflow or if the overflow is + undefined. In the latter case (if the operation overflows and + overflow is undefined), then adjust the result to be -INF or +INF + depending on CODE, VAL1 and VAL2. Return the value in *RES. -/* Return true if op is in a boolean [0, 1] value-range. */ + Return false for division by zero, for which the result is + indeterminate. */ -bool -vr_values::op_with_boolean_value_range_p (tree op) +static bool +vrp_int_const_binop (enum tree_code code, tree val1, tree val2, wide_int *res) { - value_range *vr; + bool overflow = false; + signop sign = TYPE_SIGN (TREE_TYPE (val1)); - if (TYPE_PRECISION (TREE_TYPE (op)) == 1) - return true; + switch (code) + { + case RSHIFT_EXPR: + case LSHIFT_EXPR: + { + wide_int wval2 = wi::to_wide (val2, TYPE_PRECISION (TREE_TYPE (val1))); + if (wi::neg_p (wval2)) + { + wval2 = -wval2; + if (code == RSHIFT_EXPR) + code = LSHIFT_EXPR; + else + code = RSHIFT_EXPR; + } - if (integer_zerop (op) - || integer_onep (op)) - return true; + if (code == RSHIFT_EXPR) + /* It's unclear from the C standard whether shifts can overflow. + The following code ignores overflow; perhaps a C standard + interpretation ruling is needed. */ + *res = wi::rshift (wi::to_wide (val1), wval2, sign); + else + *res = wi::lshift (wi::to_wide (val1), wval2); + break; + } - if (TREE_CODE (op) != SSA_NAME) - return false; + case MULT_EXPR: + *res = wi::mul (wi::to_wide (val1), + wi::to_wide (val2), sign, &overflow); + break; - vr = get_value_range (op); - return (vr->type == VR_RANGE - && integer_zerop (vr->min) - && integer_onep (vr->max)); -} + case TRUNC_DIV_EXPR: + case EXACT_DIV_EXPR: + if (val2 == 0) + return false; + else + *res = wi::div_trunc (wi::to_wide (val1), + wi::to_wide (val2), sign, &overflow); + break; -/* Extract value range information for VAR when (OP COND_CODE LIMIT) is - true and store it in *VR_P. */ + case FLOOR_DIV_EXPR: + if (val2 == 0) + return false; + *res = wi::div_floor (wi::to_wide (val1), + wi::to_wide (val2), sign, &overflow); + break; -void -vr_values::extract_range_for_var_from_comparison_expr (tree var, - enum tree_code cond_code, - tree op, tree limit, - value_range *vr_p) -{ - tree min, max, type; - value_range *limit_vr; - type = TREE_TYPE (var); - gcc_assert (limit != var); + case CEIL_DIV_EXPR: + if (val2 == 0) + return false; + *res = wi::div_ceil (wi::to_wide (val1), + wi::to_wide (val2), sign, &overflow); + break; - /* For pointer arithmetic, we only keep track of pointer equality - and inequality. */ - if (POINTER_TYPE_P (type) && cond_code != NE_EXPR && cond_code != EQ_EXPR) - { - set_value_range_to_varying (vr_p); - return; - } - - /* 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 - unnecessarily. */ - limit_vr = (TREE_CODE (limit) == SSA_NAME) ? get_value_range (limit) : NULL; - - /* LIMIT's range is only interesting if it has any useful information. */ - if (! limit_vr - || limit_vr->type == VR_UNDEFINED - || limit_vr->type == VR_VARYING - || (symbolic_range_p (limit_vr) - && ! (limit_vr->type == VR_RANGE - && (limit_vr->min == limit_vr->max - || operand_equal_p (limit_vr->min, limit_vr->max, 0))))) - limit_vr = NULL; - - /* Initially, the new range has the same set of equivalences of - VAR's range. This will be revised before returning the final - value. Since assertions may be chained via mutually exclusive - predicates, we will need to trim the set of equivalences before - we are done. */ - gcc_assert (vr_p->equiv == NULL); - add_equivalence (&vr_p->equiv, var); - - /* 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 - will only use it for equality comparisons (EQ_EXPR). For any - other kind of assertion, we cannot derive a range from LIMIT's - anti-range that can be used to describe the new range. For - instance, ASSERT_EXPR . If b_4 is ~[2, 10], - 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 - as well build the range [b_4, +INF] for it. - One special case we handle is extracting a range from a - range test encoded as (unsigned)var + CST <= limit. */ - if (TREE_CODE (op) == NOP_EXPR - || TREE_CODE (op) == PLUS_EXPR) - { - if (TREE_CODE (op) == PLUS_EXPR) - { - min = fold_build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (op, 1)), - TREE_OPERAND (op, 1)); - max = int_const_binop (PLUS_EXPR, limit, min); - op = TREE_OPERAND (op, 0); - } - else - { - min = build_int_cst (TREE_TYPE (var), 0); - max = limit; - } - - /* Make sure to not set TREE_OVERFLOW on the final type - conversion. We are willingly interpreting large positive - unsigned values as negative signed values here. */ - min = force_fit_type (TREE_TYPE (var), wi::to_widest (min), 0, false); - max = force_fit_type (TREE_TYPE (var), wi::to_widest (max), 0, false); - - /* We can transform a max, min range to an anti-range or - vice-versa. Use set_and_canonicalize_value_range which does - this for us. */ - if (cond_code == LE_EXPR) - set_and_canonicalize_value_range (vr_p, VR_RANGE, - min, max, vr_p->equiv); - else if (cond_code == GT_EXPR) - set_and_canonicalize_value_range (vr_p, VR_ANTI_RANGE, - min, max, vr_p->equiv); - else - gcc_unreachable (); - } - else if (cond_code == EQ_EXPR) - { - enum value_range_type range_type; - - if (limit_vr) - { - range_type = limit_vr->type; - min = limit_vr->min; - max = limit_vr->max; - } - else - { - range_type = VR_RANGE; - min = limit; - max = limit; - } - - set_value_range (vr_p, range_type, min, max, vr_p->equiv); - - /* When asserting the equality VAR == LIMIT and LIMIT is another - SSA name, the new range will also inherit the equivalence set - from LIMIT. */ - if (TREE_CODE (limit) == SSA_NAME) - add_equivalence (&vr_p->equiv, limit); - } - else if (cond_code == NE_EXPR) - { - /* As described above, when LIMIT's range is an anti-range and - this assertion is an inequality (NE_EXPR), then we cannot - derive anything from the anti-range. For instance, if - 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 - anti-ranges, we just assert the inequality using LIMIT and - not its anti-range. - - 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 - instance, if LIMIT_VR is [0, 1], the predicate - 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] - and for value 1, VAR should be ~[1, 1]. We cannot - represent these ranges. - - The only situation in which we can build a valid - anti-range is when LIMIT_VR is a single-valued range - (i.e., LIMIT_VR->MIN == LIMIT_VR->MAX). In that case, - build the anti-range ~[LIMIT_VR->MIN, LIMIT_VR->MAX]. */ - if (limit_vr - && limit_vr->type == VR_RANGE - && compare_values (limit_vr->min, limit_vr->max) == 0) - { - min = limit_vr->min; - max = limit_vr->max; - } - else - { - /* In any other case, we cannot use LIMIT's range to build a - valid anti-range. */ - min = max = limit; - } - - /* If MIN and MAX cover the whole range for their type, then - just use the original LIMIT. */ - if (INTEGRAL_TYPE_P (type) - && vrp_val_is_min (min) - && vrp_val_is_max (max)) - min = max = limit; - - set_and_canonicalize_value_range (vr_p, VR_ANTI_RANGE, - min, max, vr_p->equiv); - } - else if (cond_code == LE_EXPR || cond_code == LT_EXPR) - { - min = TYPE_MIN_VALUE (type); - - if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE) - max = limit; - else - { - /* 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 - LT_EXPR. */ - max = limit_vr->max; - } - - /* 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 - all should be optimized away above us. */ - if (cond_code == LT_EXPR - && compare_values (max, min) == 0) - set_value_range_to_varying (vr_p); - else - { - /* For LT_EXPR, we create the range [MIN, MAX - 1]. */ - if (cond_code == LT_EXPR) - { - if (TYPE_PRECISION (TREE_TYPE (max)) == 1 - && !TYPE_UNSIGNED (TREE_TYPE (max))) - max = fold_build2 (PLUS_EXPR, TREE_TYPE (max), max, - build_int_cst (TREE_TYPE (max), -1)); - else - max = fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, - build_int_cst (TREE_TYPE (max), 1)); - /* Signal to compare_values_warnv this expr doesn't overflow. */ - if (EXPR_P (max)) - TREE_NO_WARNING (max) = 1; - } - - set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv); - } - } - else if (cond_code == GE_EXPR || cond_code == GT_EXPR) - { - max = TYPE_MAX_VALUE (type); - - if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE) - min = limit; - else - { - /* 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 - GT_EXPR. */ - min = limit_vr->min; - } - - /* 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 - all should be optimized away above us. */ - if (cond_code == GT_EXPR - && compare_values (min, max) == 0) - set_value_range_to_varying (vr_p); - else - { - /* For GT_EXPR, we create the range [MIN + 1, MAX]. */ - if (cond_code == GT_EXPR) - { - if (TYPE_PRECISION (TREE_TYPE (min)) == 1 - && !TYPE_UNSIGNED (TREE_TYPE (min))) - min = fold_build2 (MINUS_EXPR, TREE_TYPE (min), min, - build_int_cst (TREE_TYPE (min), -1)); - else - min = fold_build2 (PLUS_EXPR, TREE_TYPE (min), min, - build_int_cst (TREE_TYPE (min), 1)); - /* Signal to compare_values_warnv this expr doesn't overflow. */ - if (EXPR_P (min)) - TREE_NO_WARNING (min) = 1; - } - - set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv); - } - } - else - gcc_unreachable (); - - /* Finally intersect the new range with what we already know about var. */ - vrp_intersect_ranges (vr_p, get_value_range (var)); -} - -/* Extract value range information from an ASSERT_EXPR EXPR and store - it in *VR_P. */ - -void -vr_values::extract_range_from_assert (value_range *vr_p, tree expr) -{ - tree var = ASSERT_EXPR_VAR (expr); - tree cond = ASSERT_EXPR_COND (expr); - tree limit, op; - enum tree_code cond_code; - gcc_assert (COMPARISON_CLASS_P (cond)); - - /* Find VAR in the ASSERT_EXPR conditional. */ - if (var == TREE_OPERAND (cond, 0) - || TREE_CODE (TREE_OPERAND (cond, 0)) == PLUS_EXPR - || TREE_CODE (TREE_OPERAND (cond, 0)) == NOP_EXPR) - { - /* If the predicate is of the form VAR COMP LIMIT, then we just - take LIMIT from the RHS and use the same comparison code. */ - cond_code = TREE_CODE (cond); - limit = TREE_OPERAND (cond, 1); - op = TREE_OPERAND (cond, 0); - } - else - { - /* If the predicate is of the form LIMIT COMP VAR, then we need - to flip around the comparison code to create the proper range - for VAR. */ - cond_code = swap_tree_comparison (TREE_CODE (cond)); - limit = TREE_OPERAND (cond, 0); - op = TREE_OPERAND (cond, 1); - } - extract_range_for_var_from_comparison_expr (var, cond_code, op, - limit, vr_p); -} - -/* Extract range information from SSA name VAR and store it in VR. If - VAR has an interesting range, use it. Otherwise, create the - range [VAR, VAR] and return it. This is useful in situations where - we may have conditionals testing values of VARYING names. For - instance, - - 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 - always false. */ - -void -vr_values::extract_range_from_ssa_name (value_range *vr, tree var) -{ - value_range *var_vr = get_value_range (var); - - if (var_vr->type != VR_VARYING) - copy_value_range (vr, var_vr); - else - set_value_range (vr, VR_RANGE, var, var, NULL); - - add_equivalence (&vr->equiv, var); -} - - -/* Wrapper around int_const_binop. Return true if we can compute the - result; i.e. if the operation doesn't overflow or if the overflow is - undefined. In the latter case (if the operation overflows and - overflow is undefined), then adjust the result to be -INF or +INF - depending on CODE, VAL1 and VAL2. Return the value in *RES. - - Return false for division by zero, for which the result is - indeterminate. */ - -static bool -vrp_int_const_binop (enum tree_code code, tree val1, tree val2, wide_int *res) -{ - bool overflow = false; - signop sign = TYPE_SIGN (TREE_TYPE (val1)); - - switch (code) - { - case RSHIFT_EXPR: - case LSHIFT_EXPR: - { - wide_int wval2 = wi::to_wide (val2, TYPE_PRECISION (TREE_TYPE (val1))); - if (wi::neg_p (wval2)) - { - wval2 = -wval2; - if (code == RSHIFT_EXPR) - code = LSHIFT_EXPR; - else - code = RSHIFT_EXPR; - } - - if (code == RSHIFT_EXPR) - /* It's unclear from the C standard whether shifts can overflow. - The following code ignores overflow; perhaps a C standard - interpretation ruling is needed. */ - *res = wi::rshift (wi::to_wide (val1), wval2, sign); - else - *res = wi::lshift (wi::to_wide (val1), wval2); - break; - } - - case MULT_EXPR: - *res = wi::mul (wi::to_wide (val1), - wi::to_wide (val2), sign, &overflow); - break; - - case TRUNC_DIV_EXPR: - case EXACT_DIV_EXPR: - if (val2 == 0) - return false; - else - *res = wi::div_trunc (wi::to_wide (val1), - wi::to_wide (val2), sign, &overflow); - break; - - case FLOOR_DIV_EXPR: - if (val2 == 0) - return false; - *res = wi::div_floor (wi::to_wide (val1), - wi::to_wide (val2), sign, &overflow); - break; - - case CEIL_DIV_EXPR: - if (val2 == 0) - return false; - *res = wi::div_ceil (wi::to_wide (val1), - wi::to_wide (val2), sign, &overflow); - break; - - case ROUND_DIV_EXPR: - if (val2 == 0) - return false; - *res = wi::div_round (wi::to_wide (val1), - wi::to_wide (val2), sign, &overflow); - break; + case ROUND_DIV_EXPR: + if (val2 == 0) + return false; + *res = wi::div_round (wi::to_wide (val1), + wi::to_wide (val2), sign, &overflow); + break; default: gcc_unreachable (); @@ -1703,7 +994,7 @@ vrp_int_const_binop (enum tree_code code, tree val1, tree val2, wide_int *res) bitmask if some bit is set, it means for all numbers in the range the bit is 1, otherwise it might be 0 or 1. */ -static bool +bool zero_nonzero_bits_from_vr (const tree expr_type, value_range *vr, wide_int *may_be_nonzero, @@ -1893,7 +1184,7 @@ extract_range_from_multiplicative_op_1 (value_range *vr, the ranges of each of its operands *VR0 and *VR1 with resulting type EXPR_TYPE. The resulting range is stored in *VR. */ -static void +void extract_range_from_binary_expr_1 (value_range *vr, enum tree_code code, tree expr_type, value_range *vr0_, value_range *vr1_) @@ -2988,105 +2279,6 @@ extract_range_from_binary_expr_1 (value_range *vr, set_value_range (vr, type, min, max, NULL); } -/* Extract range information from a binary expression OP0 CODE OP1 based on - the ranges of each of its operands with resulting type EXPR_TYPE. - The resulting range is stored in *VR. */ - -void -vr_values::extract_range_from_binary_expr (value_range *vr, - enum tree_code code, - tree expr_type, tree op0, tree op1) -{ - value_range vr0 = VR_INITIALIZER; - value_range vr1 = VR_INITIALIZER; - - /* Get value ranges for each operand. For constant operands, create - a new value range with the operand to simplify processing. */ - if (TREE_CODE (op0) == SSA_NAME) - vr0 = *(get_value_range (op0)); - else if (is_gimple_min_invariant (op0)) - set_value_range_to_value (&vr0, op0, NULL); - else - set_value_range_to_varying (&vr0); - - if (TREE_CODE (op1) == SSA_NAME) - vr1 = *(get_value_range (op1)); - else if (is_gimple_min_invariant (op1)) - set_value_range_to_value (&vr1, op1, NULL); - else - set_value_range_to_varying (&vr1); - - extract_range_from_binary_expr_1 (vr, code, expr_type, &vr0, &vr1); - - /* Try harder for PLUS and MINUS if the range of one operand is symbolic - and based on the other operand, for example if it was deduced from a - symbolic comparison. When a bound of the range of the first operand - is invariant, we set the corresponding bound of the new range to INF - in order to avoid recursing on the range of the second operand. */ - if (vr->type == VR_VARYING - && (code == PLUS_EXPR || code == MINUS_EXPR) - && TREE_CODE (op1) == SSA_NAME - && vr0.type == VR_RANGE - && symbolic_range_based_on_p (&vr0, op1)) - { - const bool minus_p = (code == MINUS_EXPR); - value_range n_vr1 = VR_INITIALIZER; - - /* Try with VR0 and [-INF, OP1]. */ - if (is_gimple_min_invariant (minus_p ? vr0.max : vr0.min)) - set_value_range (&n_vr1, VR_RANGE, vrp_val_min (expr_type), op1, NULL); - - /* Try with VR0 and [OP1, +INF]. */ - else if (is_gimple_min_invariant (minus_p ? vr0.min : vr0.max)) - set_value_range (&n_vr1, VR_RANGE, op1, vrp_val_max (expr_type), NULL); - - /* Try with VR0 and [OP1, OP1]. */ - else - set_value_range (&n_vr1, VR_RANGE, op1, op1, NULL); - - extract_range_from_binary_expr_1 (vr, code, expr_type, &vr0, &n_vr1); - } - - if (vr->type == VR_VARYING - && (code == PLUS_EXPR || code == MINUS_EXPR) - && TREE_CODE (op0) == SSA_NAME - && vr1.type == VR_RANGE - && symbolic_range_based_on_p (&vr1, op0)) - { - const bool minus_p = (code == MINUS_EXPR); - value_range n_vr0 = VR_INITIALIZER; - - /* Try with [-INF, OP0] and VR1. */ - if (is_gimple_min_invariant (minus_p ? vr1.max : vr1.min)) - set_value_range (&n_vr0, VR_RANGE, vrp_val_min (expr_type), op0, NULL); - - /* Try with [OP0, +INF] and VR1. */ - else if (is_gimple_min_invariant (minus_p ? vr1.min : vr1.max)) - set_value_range (&n_vr0, VR_RANGE, op0, vrp_val_max (expr_type), NULL); - - /* Try with [OP0, OP0] and VR1. */ - else - set_value_range (&n_vr0, VR_RANGE, op0, op0, NULL); - - extract_range_from_binary_expr_1 (vr, code, expr_type, &n_vr0, &vr1); - } - - /* If we didn't derive a range for MINUS_EXPR, and - op1's range is ~[op0,op0] or vice-versa, then we - can derive a non-null range. This happens often for - pointer subtraction. */ - if (vr->type == VR_VARYING - && code == MINUS_EXPR - && TREE_CODE (op0) == SSA_NAME - && ((vr0.type == VR_ANTI_RANGE - && vr0.min == op1 - && vr0.min == vr0.max) - || (vr1.type == VR_ANTI_RANGE - && vr1.min == op0 - && vr1.min == vr1.max))) - set_value_range_to_nonnull (vr, TREE_TYPE (op0)); -} - /* Extract range information from a unary operation CODE based on the range of its operand *VR0 with type OP0_TYPE with resulting type TYPE. The resulting range is stored in *VR. */ @@ -3334,7112 +2526,3791 @@ extract_range_from_unary_expr (value_range *vr, return; } +/* Debugging dumps. */ -/* Extract range information from a unary expression CODE OP0 based on - the range of its operand with resulting type TYPE. - The resulting range is stored in *VR. */ - -void -vr_values::extract_range_from_unary_expr (value_range *vr, enum tree_code code, - tree type, tree op0) -{ - value_range vr0 = VR_INITIALIZER; - - /* Get value ranges for the operand. For constant operands, create - a new value range with the operand to simplify processing. */ - if (TREE_CODE (op0) == SSA_NAME) - vr0 = *(get_value_range (op0)); - else if (is_gimple_min_invariant (op0)) - set_value_range_to_value (&vr0, op0, NULL); - else - set_value_range_to_varying (&vr0); - - ::extract_range_from_unary_expr (vr, code, type, &vr0, TREE_TYPE (op0)); -} +void dump_value_range (FILE *, const value_range *); +void debug_value_range (value_range *); +void dump_all_value_ranges (FILE *); +void dump_vr_equiv (FILE *, bitmap); +void debug_vr_equiv (bitmap); -/* Extract range information from a conditional expression STMT based on - the ranges of each of its operands and the expression code. */ +/* Dump value range VR to FILE. */ void -vr_values::extract_range_from_cond_expr (value_range *vr, gassign *stmt) +dump_value_range (FILE *file, const value_range *vr) { - tree op0, op1; - value_range vr0 = VR_INITIALIZER; - value_range vr1 = VR_INITIALIZER; - - /* Get value ranges for each operand. For constant operands, create - a new value range with the operand to simplify processing. */ - op0 = gimple_assign_rhs2 (stmt); - if (TREE_CODE (op0) == SSA_NAME) - vr0 = *(get_value_range (op0)); - else if (is_gimple_min_invariant (op0)) - set_value_range_to_value (&vr0, op0, NULL); - else - set_value_range_to_varying (&vr0); - - op1 = gimple_assign_rhs3 (stmt); - if (TREE_CODE (op1) == SSA_NAME) - vr1 = *(get_value_range (op1)); - else if (is_gimple_min_invariant (op1)) - set_value_range_to_value (&vr1, op1, NULL); - else - set_value_range_to_varying (&vr1); - - /* The resulting value range is the union of the operand ranges */ - copy_value_range (vr, &vr0); - vrp_meet (vr, &vr1); -} + if (vr == NULL) + fprintf (file, "[]"); + else if (vr->type == VR_UNDEFINED) + fprintf (file, "UNDEFINED"); + else if (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE) + { + tree type = TREE_TYPE (vr->min); + fprintf (file, "%s[", (vr->type == VR_ANTI_RANGE) ? "~" : ""); -/* Extract range information from a comparison expression EXPR based - on the range of its operand and the expression code. */ + if (INTEGRAL_TYPE_P (type) + && !TYPE_UNSIGNED (type) + && vrp_val_is_min (vr->min)) + fprintf (file, "-INF"); + else + print_generic_expr (file, vr->min); -void -vr_values::extract_range_from_comparison (value_range *vr, enum tree_code code, - tree type, tree op0, tree op1) -{ - bool sop; - tree val; + fprintf (file, ", "); - val = vrp_evaluate_conditional_warnv_with_ops (code, op0, op1, false, &sop, - NULL); - if (val) - { - /* Since this expression was found on the RHS of an assignment, - its type may be different from _Bool. Convert VAL to EXPR's - type. */ - val = fold_convert (type, val); - if (is_gimple_min_invariant (val)) - set_value_range_to_value (vr, val, vr->equiv); + if (INTEGRAL_TYPE_P (type) + && vrp_val_is_max (vr->max)) + fprintf (file, "+INF"); else - set_value_range (vr, VR_RANGE, val, val, vr->equiv); - } - else - /* The result of a comparison is always true or false. */ - set_value_range_to_truthvalue (vr, type); -} + print_generic_expr (file, vr->max); -/* Helper function for simplify_internal_call_using_ranges and - extract_range_basic. Return true if OP0 SUBCODE OP1 for - SUBCODE {PLUS,MINUS,MULT}_EXPR is known to never overflow or - always overflow. Set *OVF to true if it is known to always - overflow. */ + fprintf (file, "]"); -bool -vr_values::check_for_binary_op_overflow (enum tree_code subcode, tree type, - tree op0, tree op1, bool *ovf) -{ - value_range vr0 = VR_INITIALIZER; - value_range vr1 = VR_INITIALIZER; - if (TREE_CODE (op0) == SSA_NAME) - vr0 = *get_value_range (op0); - else if (TREE_CODE (op0) == INTEGER_CST) - set_value_range_to_value (&vr0, op0, NULL); - else - set_value_range_to_varying (&vr0); + if (vr->equiv) + { + bitmap_iterator bi; + unsigned i, c = 0; - if (TREE_CODE (op1) == SSA_NAME) - vr1 = *get_value_range (op1); - else if (TREE_CODE (op1) == INTEGER_CST) - set_value_range_to_value (&vr1, op1, NULL); - else - set_value_range_to_varying (&vr1); + fprintf (file, " EQUIVALENCES: { "); - if (!range_int_cst_p (&vr0) - || TREE_OVERFLOW (vr0.min) - || TREE_OVERFLOW (vr0.max)) - { - vr0.min = vrp_val_min (TREE_TYPE (op0)); - vr0.max = vrp_val_max (TREE_TYPE (op0)); - } - if (!range_int_cst_p (&vr1) - || TREE_OVERFLOW (vr1.min) - || TREE_OVERFLOW (vr1.max)) - { - vr1.min = vrp_val_min (TREE_TYPE (op1)); - vr1.max = vrp_val_max (TREE_TYPE (op1)); - } - *ovf = arith_overflowed_p (subcode, type, vr0.min, - subcode == MINUS_EXPR ? vr1.max : vr1.min); - if (arith_overflowed_p (subcode, type, vr0.max, - subcode == MINUS_EXPR ? vr1.min : vr1.max) != *ovf) - return false; - if (subcode == MULT_EXPR) - { - if (arith_overflowed_p (subcode, type, vr0.min, vr1.max) != *ovf - || arith_overflowed_p (subcode, type, vr0.max, vr1.min) != *ovf) - return false; - } - if (*ovf) - { - /* So far we found that there is an overflow on the boundaries. - That doesn't prove that there is an overflow even for all values - in between the boundaries. For that compute widest_int range - of the result and see if it doesn't overlap the range of - type. */ - widest_int wmin, wmax; - widest_int w[4]; - int i; - w[0] = wi::to_widest (vr0.min); - w[1] = wi::to_widest (vr0.max); - w[2] = wi::to_widest (vr1.min); - w[3] = wi::to_widest (vr1.max); - for (i = 0; i < 4; i++) - { - widest_int wt; - switch (subcode) - { - case PLUS_EXPR: - wt = wi::add (w[i & 1], w[2 + (i & 2) / 2]); - break; - case MINUS_EXPR: - wt = wi::sub (w[i & 1], w[2 + (i & 2) / 2]); - break; - case MULT_EXPR: - wt = wi::mul (w[i & 1], w[2 + (i & 2) / 2]); - break; - default: - gcc_unreachable (); - } - if (i == 0) - { - wmin = wt; - wmax = wt; - } - else + EXECUTE_IF_SET_IN_BITMAP (vr->equiv, 0, i, bi) { - wmin = wi::smin (wmin, wt); - wmax = wi::smax (wmax, wt); + print_generic_expr (file, ssa_name (i)); + fprintf (file, " "); + c++; } + + fprintf (file, "} (%u elements)", c); } - /* The result of op0 CODE op1 is known to be in range - [wmin, wmax]. */ - widest_int wtmin = wi::to_widest (vrp_val_min (type)); - widest_int wtmax = wi::to_widest (vrp_val_max (type)); - /* If all values in [wmin, wmax] are smaller than - [wtmin, wtmax] or all are larger than [wtmin, wtmax], - the arithmetic operation will always overflow. */ - if (wmax < wtmin || wmin > wtmax) - return true; - return false; } - return true; + else if (vr->type == VR_VARYING) + fprintf (file, "VARYING"); + else + fprintf (file, "INVALID RANGE"); } -/* Try to derive a nonnegative or nonzero range out of STMT relying - primarily on generic routines in fold in conjunction with range data. - Store the result in *VR */ - -void -vr_values::extract_range_basic (value_range *vr, gimple *stmt) -{ - bool sop; - tree type = gimple_expr_type (stmt); - if (is_gimple_call (stmt)) - { - tree arg; - int mini, maxi, zerov = 0, prec; - enum tree_code subcode = ERROR_MARK; - combined_fn cfn = gimple_call_combined_fn (stmt); - scalar_int_mode mode; +/* Dump value range VR to stderr. */ - switch (cfn) - { - case CFN_BUILT_IN_CONSTANT_P: - /* If the call is __builtin_constant_p and the argument is a - function parameter resolve it to false. This avoids bogus - array bound warnings. - ??? We could do this as early as inlining is finished. */ - arg = gimple_call_arg (stmt, 0); - if (TREE_CODE (arg) == SSA_NAME - && SSA_NAME_IS_DEFAULT_DEF (arg) - && TREE_CODE (SSA_NAME_VAR (arg)) == PARM_DECL - && cfun->after_inlining) - { - set_value_range_to_null (vr, type); - return; - } - break; - /* Both __builtin_ffs* and __builtin_popcount return - [0, prec]. */ - CASE_CFN_FFS: - CASE_CFN_POPCOUNT: - arg = gimple_call_arg (stmt, 0); - prec = TYPE_PRECISION (TREE_TYPE (arg)); - mini = 0; - maxi = prec; - if (TREE_CODE (arg) == SSA_NAME) - { - value_range *vr0 = get_value_range (arg); - /* If arg is non-zero, then ffs or popcount - are non-zero. */ - if ((vr0->type == VR_RANGE - && range_includes_zero_p (vr0->min, vr0->max) == 0) - || (vr0->type == VR_ANTI_RANGE - && range_includes_zero_p (vr0->min, vr0->max) == 1)) - mini = 1; - /* If some high bits are known to be zero, - we can decrease the maximum. */ - if (vr0->type == VR_RANGE - && TREE_CODE (vr0->max) == INTEGER_CST - && !operand_less_p (vr0->min, - build_zero_cst (TREE_TYPE (vr0->min)))) - maxi = tree_floor_log2 (vr0->max) + 1; - } - goto bitop_builtin; - /* __builtin_parity* returns [0, 1]. */ - CASE_CFN_PARITY: - mini = 0; - maxi = 1; - goto bitop_builtin; - /* __builtin_c[lt]z* return [0, prec-1], except for - when the argument is 0, but that is undefined behavior. - On many targets where the CLZ RTL or optab value is defined - for 0 the value is prec, so include that in the range - by default. */ - CASE_CFN_CLZ: - arg = gimple_call_arg (stmt, 0); - prec = TYPE_PRECISION (TREE_TYPE (arg)); - mini = 0; - maxi = prec; - mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg)); - if (optab_handler (clz_optab, mode) != CODE_FOR_nothing - && CLZ_DEFINED_VALUE_AT_ZERO (mode, zerov) - /* Handle only the single common value. */ - && zerov != prec) - /* Magic value to give up, unless vr0 proves - arg is non-zero. */ - mini = -2; - if (TREE_CODE (arg) == SSA_NAME) - { - value_range *vr0 = get_value_range (arg); - /* From clz of VR_RANGE minimum we can compute - result maximum. */ - if (vr0->type == VR_RANGE - && TREE_CODE (vr0->min) == INTEGER_CST) - { - maxi = prec - 1 - tree_floor_log2 (vr0->min); - if (maxi != prec) - mini = 0; - } - else if (vr0->type == VR_ANTI_RANGE - && integer_zerop (vr0->min)) - { - maxi = prec - 1; - mini = 0; - } - if (mini == -2) - break; - /* From clz of VR_RANGE maximum we can compute - result minimum. */ - if (vr0->type == VR_RANGE - && TREE_CODE (vr0->max) == INTEGER_CST) - { - mini = prec - 1 - tree_floor_log2 (vr0->max); - if (mini == prec) - break; - } - } - if (mini == -2) - break; - goto bitop_builtin; - /* __builtin_ctz* return [0, prec-1], except for - when the argument is 0, but that is undefined behavior. - If there is a ctz optab for this mode and - CTZ_DEFINED_VALUE_AT_ZERO, include that in the range, - otherwise just assume 0 won't be seen. */ - CASE_CFN_CTZ: - arg = gimple_call_arg (stmt, 0); - prec = TYPE_PRECISION (TREE_TYPE (arg)); - mini = 0; - maxi = prec - 1; - mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg)); - if (optab_handler (ctz_optab, mode) != CODE_FOR_nothing - && CTZ_DEFINED_VALUE_AT_ZERO (mode, zerov)) - { - /* Handle only the two common values. */ - if (zerov == -1) - mini = -1; - else if (zerov == prec) - maxi = prec; - else - /* Magic value to give up, unless vr0 proves - arg is non-zero. */ - mini = -2; - } - if (TREE_CODE (arg) == SSA_NAME) - { - value_range *vr0 = get_value_range (arg); - /* If arg is non-zero, then use [0, prec - 1]. */ - if ((vr0->type == VR_RANGE - && integer_nonzerop (vr0->min)) - || (vr0->type == VR_ANTI_RANGE - && integer_zerop (vr0->min))) - { - mini = 0; - maxi = prec - 1; - } - /* If some high bits are known to be zero, - we can decrease the result maximum. */ - if (vr0->type == VR_RANGE - && TREE_CODE (vr0->max) == INTEGER_CST) - { - maxi = tree_floor_log2 (vr0->max); - /* For vr0 [0, 0] give up. */ - if (maxi == -1) - break; - } - } - if (mini == -2) - break; - goto bitop_builtin; - /* __builtin_clrsb* returns [0, prec-1]. */ - CASE_CFN_CLRSB: - arg = gimple_call_arg (stmt, 0); - prec = TYPE_PRECISION (TREE_TYPE (arg)); - mini = 0; - maxi = prec - 1; - goto bitop_builtin; - bitop_builtin: - set_value_range (vr, VR_RANGE, build_int_cst (type, mini), - build_int_cst (type, maxi), NULL); - return; - case CFN_UBSAN_CHECK_ADD: - subcode = PLUS_EXPR; - break; - case CFN_UBSAN_CHECK_SUB: - subcode = MINUS_EXPR; - break; - case CFN_UBSAN_CHECK_MUL: - subcode = MULT_EXPR; - break; - case CFN_GOACC_DIM_SIZE: - case CFN_GOACC_DIM_POS: - /* Optimizing these two internal functions helps the loop - optimizer eliminate outer comparisons. Size is [1,N] - and pos is [0,N-1]. */ - { - bool is_pos = cfn == CFN_GOACC_DIM_POS; - int axis = oacc_get_ifn_dim_arg (stmt); - int size = oacc_get_fn_dim_size (current_function_decl, axis); - - if (!size) - /* If it's dynamic, the backend might know a hardware - limitation. */ - size = targetm.goacc.dim_limit (axis); - - tree type = TREE_TYPE (gimple_call_lhs (stmt)); - set_value_range (vr, VR_RANGE, - build_int_cst (type, is_pos ? 0 : 1), - size ? build_int_cst (type, size - is_pos) - : vrp_val_max (type), NULL); - } - return; - case CFN_BUILT_IN_STRLEN: - if (tree lhs = gimple_call_lhs (stmt)) - if (ptrdiff_type_node - && (TYPE_PRECISION (ptrdiff_type_node) - == TYPE_PRECISION (TREE_TYPE (lhs)))) - { - tree type = TREE_TYPE (lhs); - tree max = vrp_val_max (ptrdiff_type_node); - wide_int wmax = wi::to_wide (max, TYPE_PRECISION (TREE_TYPE (max))); - tree range_min = build_zero_cst (type); - tree range_max = wide_int_to_tree (type, wmax - 1); - set_value_range (vr, VR_RANGE, range_min, range_max, NULL); - return; - } - break; - default: - break; - } - if (subcode != ERROR_MARK) - { - bool saved_flag_wrapv = flag_wrapv; - /* Pretend the arithmetics is wrapping. If there is - any overflow, we'll complain, but will actually do - wrapping operation. */ - flag_wrapv = 1; - extract_range_from_binary_expr (vr, subcode, type, - gimple_call_arg (stmt, 0), - gimple_call_arg (stmt, 1)); - flag_wrapv = saved_flag_wrapv; - - /* If for both arguments vrp_valueize returned non-NULL, - this should have been already folded and if not, it - wasn't folded because of overflow. Avoid removing the - UBSAN_CHECK_* calls in that case. */ - if (vr->type == VR_RANGE - && (vr->min == vr->max - || operand_equal_p (vr->min, vr->max, 0))) - set_value_range_to_varying (vr); - return; - } - } - /* Handle extraction of the two results (result of arithmetics and - a flag whether arithmetics overflowed) from {ADD,SUB,MUL}_OVERFLOW - internal function. Similarly from ATOMIC_COMPARE_EXCHANGE. */ - else if (is_gimple_assign (stmt) - && (gimple_assign_rhs_code (stmt) == REALPART_EXPR - || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR) - && INTEGRAL_TYPE_P (type)) - { - enum tree_code code = gimple_assign_rhs_code (stmt); - tree op = gimple_assign_rhs1 (stmt); - if (TREE_CODE (op) == code && TREE_CODE (TREE_OPERAND (op, 0)) == SSA_NAME) - { - gimple *g = SSA_NAME_DEF_STMT (TREE_OPERAND (op, 0)); - if (is_gimple_call (g) && gimple_call_internal_p (g)) - { - enum tree_code subcode = ERROR_MARK; - switch (gimple_call_internal_fn (g)) - { - case IFN_ADD_OVERFLOW: - subcode = PLUS_EXPR; - break; - case IFN_SUB_OVERFLOW: - subcode = MINUS_EXPR; - break; - case IFN_MUL_OVERFLOW: - subcode = MULT_EXPR; - break; - case IFN_ATOMIC_COMPARE_EXCHANGE: - if (code == IMAGPART_EXPR) - { - /* This is the boolean return value whether compare and - exchange changed anything or not. */ - set_value_range (vr, VR_RANGE, build_int_cst (type, 0), - build_int_cst (type, 1), NULL); - return; - } - break; - default: - break; - } - if (subcode != ERROR_MARK) - { - tree op0 = gimple_call_arg (g, 0); - tree op1 = gimple_call_arg (g, 1); - if (code == IMAGPART_EXPR) - { - bool ovf = false; - if (check_for_binary_op_overflow (subcode, type, - op0, op1, &ovf)) - set_value_range_to_value (vr, - build_int_cst (type, ovf), - NULL); - else if (TYPE_PRECISION (type) == 1 - && !TYPE_UNSIGNED (type)) - set_value_range_to_varying (vr); - else - set_value_range (vr, VR_RANGE, build_int_cst (type, 0), - build_int_cst (type, 1), NULL); - } - else if (types_compatible_p (type, TREE_TYPE (op0)) - && types_compatible_p (type, TREE_TYPE (op1))) - { - bool saved_flag_wrapv = flag_wrapv; - /* Pretend the arithmetics is wrapping. If there is - any overflow, IMAGPART_EXPR will be set. */ - flag_wrapv = 1; - extract_range_from_binary_expr (vr, subcode, type, - op0, op1); - flag_wrapv = saved_flag_wrapv; - } - else - { - value_range vr0 = VR_INITIALIZER; - value_range vr1 = VR_INITIALIZER; - bool saved_flag_wrapv = flag_wrapv; - /* Pretend the arithmetics is wrapping. If there is - any overflow, IMAGPART_EXPR will be set. */ - flag_wrapv = 1; - extract_range_from_unary_expr (&vr0, NOP_EXPR, - type, op0); - extract_range_from_unary_expr (&vr1, NOP_EXPR, - type, op1); - extract_range_from_binary_expr_1 (vr, subcode, type, - &vr0, &vr1); - flag_wrapv = saved_flag_wrapv; - } - return; - } - } - } - } - if (INTEGRAL_TYPE_P (type) - && gimple_stmt_nonnegative_warnv_p (stmt, &sop)) - set_value_range_to_nonnegative (vr, type); - else if (vrp_stmt_computes_nonzero (stmt)) - set_value_range_to_nonnull (vr, type); - else - set_value_range_to_varying (vr); +DEBUG_FUNCTION void +debug_value_range (value_range *vr) +{ + dump_value_range (stderr, vr); + fprintf (stderr, "\n"); } -/* Try to compute a useful range out of assignment STMT and store it - in *VR. */ +/* 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 + 'N = ASSERT_EXPR '. */ -void -vr_values::extract_range_from_assignment (value_range *vr, gassign *stmt) +static gimple * +build_assert_expr_for (tree cond, tree v) { - enum tree_code code = gimple_assign_rhs_code (stmt); - - if (code == ASSERT_EXPR) - extract_range_from_assert (vr, gimple_assign_rhs1 (stmt)); - else if (code == SSA_NAME) - extract_range_from_ssa_name (vr, gimple_assign_rhs1 (stmt)); - else if (TREE_CODE_CLASS (code) == tcc_binary) - extract_range_from_binary_expr (vr, gimple_assign_rhs_code (stmt), - gimple_expr_type (stmt), - gimple_assign_rhs1 (stmt), - gimple_assign_rhs2 (stmt)); - else if (TREE_CODE_CLASS (code) == tcc_unary) - extract_range_from_unary_expr (vr, gimple_assign_rhs_code (stmt), - gimple_expr_type (stmt), - gimple_assign_rhs1 (stmt)); - else if (code == COND_EXPR) - extract_range_from_cond_expr (vr, stmt); - else if (TREE_CODE_CLASS (code) == tcc_comparison) - extract_range_from_comparison (vr, gimple_assign_rhs_code (stmt), - gimple_expr_type (stmt), - gimple_assign_rhs1 (stmt), - gimple_assign_rhs2 (stmt)); - else if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS - && is_gimple_min_invariant (gimple_assign_rhs1 (stmt))) - set_value_range_to_value (vr, gimple_assign_rhs1 (stmt), NULL); - else - set_value_range_to_varying (vr); + tree a; + gassign *assertion; - if (vr->type == VR_VARYING) - extract_range_basic (vr, stmt); -} + gcc_assert (TREE_CODE (v) == SSA_NAME + && COMPARISON_CLASS_P (cond)); -/* Given a range VR, a LOOP and a variable VAR, determine whether it - would be profitable to adjust VR using scalar evolution information - for VAR. If so, update VR with the new limits. */ + a = build2 (ASSERT_EXPR, TREE_TYPE (v), v, cond); + assertion = gimple_build_assign (NULL_TREE, a); -void -vr_values::adjust_range_with_scev (value_range *vr, struct loop *loop, - gimple *stmt, tree var) -{ - tree init, step, chrec, tmin, tmax, min, max, type, tem; - enum ev_direction dir; + /* The new ASSERT_EXPR, creates a new SSA name that replaces the + operand of the ASSERT_EXPR. Create it so the new name and the old one + are registered in the replacement table so that we can fix the SSA web + after adding all the ASSERT_EXPRs. */ + tree new_def = create_new_def_for (v, assertion, NULL); + /* Make sure we preserve abnormalness throughout an ASSERT_EXPR chain + given we have to be able to fully propagate those out to re-create + valid SSA when removing the asserts. */ + if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (v)) + SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_def) = 1; - /* TODO. Don't adjust anti-ranges. An anti-range may provide - better opportunities than a regular range, but I'm not sure. */ - if (vr->type == VR_ANTI_RANGE) - return; + return assertion; +} - chrec = instantiate_parameters (loop, analyze_scalar_evolution (loop, var)); - /* Like in PR19590, scev can return a constant function. */ - if (is_gimple_min_invariant (chrec)) - { - set_value_range_to_value (vr, chrec, vr->equiv); - return; - } +/* Return false if EXPR is a predicate expression involving floating + point values. */ - if (TREE_CODE (chrec) != POLYNOMIAL_CHREC) - return; +static inline bool +fp_predicate (gimple *stmt) +{ + GIMPLE_CHECK (stmt, GIMPLE_COND); - init = initial_condition_in_loop_num (chrec, loop->num); - tem = op_with_constant_singleton_value_range (init); - if (tem) - init = tem; - step = evolution_part_in_loop_num (chrec, loop->num); - tem = op_with_constant_singleton_value_range (step); - if (tem) - step = tem; - - /* If STEP is symbolic, we can't know whether INIT will be the - minimum or maximum value in the range. Also, unless INIT is - a simple expression, compare_values and possibly other functions - in tree-vrp won't be able to handle it. */ - if (step == NULL_TREE - || !is_gimple_min_invariant (step) - || !valid_value_p (init)) - return; + return FLOAT_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt))); +} - dir = scev_direction (chrec); - if (/* Do not adjust ranges if we do not know whether the iv increases - or decreases, ... */ - dir == EV_DIR_UNKNOWN - /* ... or if it may wrap. */ - || scev_probably_wraps_p (NULL_TREE, init, step, stmt, - get_chrec_loop (chrec), true)) - return; +/* 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 + describes the inferred range. Return true if a range could be + inferred. */ - type = TREE_TYPE (var); - if (POINTER_TYPE_P (type) || !TYPE_MIN_VALUE (type)) - tmin = lower_bound_in_type (type, type); - else - tmin = TYPE_MIN_VALUE (type); - if (POINTER_TYPE_P (type) || !TYPE_MAX_VALUE (type)) - tmax = upper_bound_in_type (type, type); - else - tmax = TYPE_MAX_VALUE (type); +bool +infer_value_range (gimple *stmt, tree op, tree_code *comp_code_p, tree *val_p) +{ + *val_p = NULL_TREE; + *comp_code_p = ERROR_MARK; - /* Try to use estimated number of iterations for the loop to constrain the - final value in the evolution. */ - if (TREE_CODE (step) == INTEGER_CST - && is_gimple_val (init) - && (TREE_CODE (init) != SSA_NAME - || get_value_range (init)->type == VR_RANGE)) - { - widest_int nit; + /* Do not attempt to infer anything in names that flow through + abnormal edges. */ + if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op)) + return false; - /* We are only entering here for loop header PHI nodes, so using - the number of latch executions is the correct thing to use. */ - if (max_loop_iterations (loop, &nit)) - { - value_range maxvr = VR_INITIALIZER; - signop sgn = TYPE_SIGN (TREE_TYPE (step)); - bool overflow; - - widest_int wtmp = wi::mul (wi::to_widest (step), nit, sgn, - &overflow); - /* If the multiplication overflowed we can't do a meaningful - adjustment. Likewise if the result doesn't fit in the type - of the induction variable. For a signed type we have to - check whether the result has the expected signedness which - is that of the step as number of iterations is unsigned. */ - if (!overflow - && wi::fits_to_tree_p (wtmp, TREE_TYPE (init)) - && (sgn == UNSIGNED - || wi::gts_p (wtmp, 0) == wi::gts_p (wi::to_wide (step), 0))) - { - tem = wide_int_to_tree (TREE_TYPE (init), wtmp); - extract_range_from_binary_expr (&maxvr, PLUS_EXPR, - TREE_TYPE (init), init, tem); - /* Likewise if the addition did. */ - if (maxvr.type == VR_RANGE) - { - value_range initvr = VR_INITIALIZER; + /* If STMT is the last statement of a basic block with no normal + successors, there is no point inferring anything about any of its + operands. We would not be able to find a proper insertion point + for the assertion, anyway. */ + if (stmt_ends_bb_p (stmt)) + { + edge_iterator ei; + edge e; - if (TREE_CODE (init) == SSA_NAME) - initvr = *(get_value_range (init)); - else if (is_gimple_min_invariant (init)) - set_value_range_to_value (&initvr, init, NULL); - else - return; - - /* Check if init + nit * step overflows. Though we checked - scev {init, step}_loop doesn't wrap, it is not enough - because the loop may exit immediately. Overflow could - happen in the plus expression in this case. */ - if ((dir == EV_DIR_DECREASES - && compare_values (maxvr.min, initvr.min) != -1) - || (dir == EV_DIR_GROWS - && compare_values (maxvr.max, initvr.max) != 1)) - return; - - tmin = maxvr.min; - tmax = maxvr.max; - } - } - } + FOR_EACH_EDGE (e, ei, gimple_bb (stmt)->succs) + if (!(e->flags & (EDGE_ABNORMAL|EDGE_EH))) + break; + if (e == NULL) + return false; } - if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED) + if (infer_nonnull_range (stmt, op)) { - min = tmin; - max = tmax; + *val_p = build_int_cst (TREE_TYPE (op), 0); + *comp_code_p = NE_EXPR; + return true; + } - /* For VARYING or UNDEFINED ranges, just about anything we get - from scalar evolutions should be better. */ + return false; +} - if (dir == EV_DIR_DECREASES) - max = init; - else - min = init; - } - else if (vr->type == VR_RANGE) - { - min = vr->min; - max = vr->max; - if (dir == EV_DIR_DECREASES) - { - /* INIT is the maximum value. If INIT is lower than VR->MAX - but no smaller than VR->MIN, set VR->MAX to INIT. */ - if (compare_values (init, max) == -1) - max = init; +void dump_asserts_for (FILE *, tree); +void debug_asserts_for (tree); +void dump_all_asserts (FILE *); +void debug_all_asserts (void); - /* According to the loop information, the variable does not - overflow. */ - if (compare_values (min, tmin) == -1) - min = tmin; +/* Dump all the registered assertions for NAME to FILE. */ - } - else - { - /* If INIT is bigger than VR->MIN, set VR->MIN to INIT. */ - if (compare_values (init, min) == 1) - min = init; +void +dump_asserts_for (FILE *file, tree name) +{ + assert_locus *loc; + + fprintf (file, "Assertions to be inserted for "); + print_generic_expr (file, name); + fprintf (file, "\n"); - if (compare_values (tmax, max) == -1) - max = tmax; + loc = asserts_for[SSA_NAME_VERSION (name)]; + while (loc) + { + fprintf (file, "\t"); + print_gimple_stmt (file, gsi_stmt (loc->si), 0); + fprintf (file, "\n\tBB #%d", loc->bb->index); + if (loc->e) + { + fprintf (file, "\n\tEDGE %d->%d", loc->e->src->index, + loc->e->dest->index); + dump_edge_info (file, loc->e, dump_flags, 0); } + fprintf (file, "\n\tPREDICATE: "); + print_generic_expr (file, loc->expr); + fprintf (file, " %s ", get_tree_code_name (loc->comp_code)); + print_generic_expr (file, loc->val); + fprintf (file, "\n\n"); + loc = loc->next; } - else - return; - /* If we just created an invalid range with the minimum - greater than the maximum, we fail conservatively. - This should happen only in unreachable - parts of code, or for invalid programs. */ - if (compare_values (min, max) == 1) - return; - - /* Even for valid range info, sometimes overflow flag will leak in. - As GIMPLE IL should have no constants with TREE_OVERFLOW set, we - drop them. */ - if (TREE_OVERFLOW_P (min)) - min = drop_tree_overflow (min); - if (TREE_OVERFLOW_P (max)) - max = drop_tree_overflow (max); - - set_value_range (vr, VR_RANGE, min, max, vr->equiv); + fprintf (file, "\n"); } -/* Given two numeric value ranges VR0, VR1 and a comparison code COMP: - - - Return BOOLEAN_TRUE_NODE if VR0 COMP VR1 always returns true for - all the values in the ranges. - - - Return BOOLEAN_FALSE_NODE if the comparison always returns false. +/* Dump all the registered assertions for NAME to stderr. */ - - Return NULL_TREE if it is not always possible to determine the - value of the comparison. +DEBUG_FUNCTION void +debug_asserts_for (tree name) +{ + dump_asserts_for (stderr, name); +} - Also set *STRICT_OVERFLOW_P to indicate whether comparision evaluation - assumed signed overflow is undefined. */ +/* Dump all the registered assertions for all the names to FILE. */ -static tree -compare_ranges (enum tree_code comp, value_range *vr0, value_range *vr1, - bool *strict_overflow_p) +void +dump_all_asserts (FILE *file) { - /* VARYING or UNDEFINED ranges cannot be compared. */ - if (vr0->type == VR_VARYING - || vr0->type == VR_UNDEFINED - || vr1->type == VR_VARYING - || vr1->type == VR_UNDEFINED) - return NULL_TREE; + unsigned i; + bitmap_iterator bi; - /* Anti-ranges need to be handled separately. */ - if (vr0->type == VR_ANTI_RANGE || vr1->type == VR_ANTI_RANGE) - { - /* If both are anti-ranges, then we cannot compute any - comparison. */ - if (vr0->type == VR_ANTI_RANGE && vr1->type == VR_ANTI_RANGE) - return NULL_TREE; + fprintf (file, "\nASSERT_EXPRs to be inserted\n\n"); + EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi) + dump_asserts_for (file, ssa_name (i)); + fprintf (file, "\n"); +} - /* These comparisons are never statically computable. */ - if (comp == GT_EXPR - || comp == GE_EXPR - || comp == LT_EXPR - || comp == LE_EXPR) - return NULL_TREE; - /* Equality can be computed only between a range and an - anti-range. ~[VAL1, VAL2] == [VAL1, VAL2] is always false. */ - if (vr0->type == VR_RANGE) - { - /* To simplify processing, make VR0 the anti-range. */ - value_range *tmp = vr0; - vr0 = vr1; - vr1 = tmp; - } +/* Dump all the registered assertions for all the names to stderr. */ - gcc_assert (comp == NE_EXPR || comp == EQ_EXPR); +DEBUG_FUNCTION void +debug_all_asserts (void) +{ + dump_all_asserts (stderr); +} - if (compare_values_warnv (vr0->min, vr1->min, 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; +/* Push the assert info for NAME, EXPR, COMP_CODE and VAL to ASSERTS. */ - return NULL_TREE; - } +static void +add_assert_info (vec &asserts, + tree name, tree expr, enum tree_code comp_code, tree val) +{ + assert_info info; + info.comp_code = comp_code; + info.name = name; + info.val = val; + info.expr = expr; + asserts.safe_push (info); +} - /* Simplify processing. If COMP is GT_EXPR or GE_EXPR, switch the - operands around and change the comparison code. */ - if (comp == GT_EXPR || comp == GE_EXPR) - { - comp = (comp == GT_EXPR) ? LT_EXPR : LE_EXPR; - std::swap (vr0, vr1); - } +/* If NAME doesn't have an ASSERT_EXPR registered for asserting + 'EXPR COMP_CODE VAL' at a location that dominates block BB or + E->DEST, then register this location as a possible insertion point + for ASSERT_EXPR . + + 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 + 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 + must not be NULL. */ + +static void +register_new_assert_for (tree name, tree expr, + enum tree_code comp_code, + tree val, + basic_block bb, + edge e, + gimple_stmt_iterator si) +{ + assert_locus *n, *loc, *last_loc; + basic_block dest_bb; + + gcc_checking_assert (bb == NULL || e == NULL); + + if (e == NULL) + gcc_checking_assert (gimple_code (gsi_stmt (si)) != GIMPLE_COND + && gimple_code (gsi_stmt (si)) != GIMPLE_SWITCH); + + /* Never build an assert comparing against an integer constant with + TREE_OVERFLOW set. This confuses our undefined overflow warning + machinery. */ + if (TREE_OVERFLOW_P (val)) + val = drop_tree_overflow (val); - if (comp == EQ_EXPR) + /* The new assertion A will be inserted at BB or E. We need to + determine if the new location is dominated by a previously + 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 + necessarily true. + + 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 + E->DEST dominates. + + The reverse, however, is not true, blocks dominated by E->DEST + 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 + the new location to move another assertion previously registered + at a block dominated by E->DEST. */ + dest_bb = (bb) ? bb : e->dest; + + /* 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 + one. Similarly, if the same assertion already exists at a block + dominated by DEST_BB and the new location is not on a critical + edge, then update the existing location for the assertion (i.e., + move the assertion up in the dominance tree). + + Note, this is implemented as a simple linked list because there + should not be more than a handful of assertions registered per + name. If this becomes a performance problem, a table hashed by + COMP_CODE and VAL could be implemented. */ + loc = asserts_for[SSA_NAME_VERSION (name)]; + last_loc = loc; + while (loc) { - /* Equality may only be computed if both ranges represent - exactly one value. */ - if (compare_values_warnv (vr0->min, vr0->max, strict_overflow_p) == 0 - && compare_values_warnv (vr1->min, vr1->max, strict_overflow_p) == 0) + if (loc->comp_code == comp_code + && (loc->val == val + || operand_equal_p (loc->val, val, 0)) + && (loc->expr == expr + || operand_equal_p (loc->expr, expr, 0))) { - int cmp_min = compare_values_warnv (vr0->min, vr1->min, - strict_overflow_p); - int cmp_max = compare_values_warnv (vr0->max, vr1->max, - strict_overflow_p); - if (cmp_min == 0 && cmp_max == 0) - return boolean_true_node; - else if (cmp_min != -2 && cmp_max != -2) - return boolean_false_node; + /* If E is not a critical edge and DEST_BB + dominates the existing location for the assertion, move + the assertion up in the dominance tree by updating its + location information. */ + if ((e == NULL || !EDGE_CRITICAL_P (e)) + && dominated_by_p (CDI_DOMINATORS, loc->bb, dest_bb)) + { + loc->bb = dest_bb; + loc->e = e; + loc->si = si; + return; + } } - /* If [V0_MIN, V1_MAX] < [V1_MIN, V1_MAX] then V0 != V1. */ - else if (compare_values_warnv (vr0->min, vr1->max, - strict_overflow_p) == 1 - || compare_values_warnv (vr1->min, vr0->max, - strict_overflow_p) == 1) - return boolean_false_node; - return NULL_TREE; - } - else if (comp == NE_EXPR) - { - int cmp1, cmp2; - - /* If VR0 is completely to the left or completely to the right - of VR1, they are always different. Notice that we need to - make sure that both comparisons yield similar results to - avoid comparing values that cannot be compared at - compile-time. */ - cmp1 = compare_values_warnv (vr0->max, vr1->min, strict_overflow_p); - cmp2 = compare_values_warnv (vr0->min, vr1->max, strict_overflow_p); - if ((cmp1 == -1 && cmp2 == -1) || (cmp1 == 1 && cmp2 == 1)) - return boolean_true_node; - - /* If VR0 and VR1 represent a single value and are identical, - return false. */ - else 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 (vr0->min, vr1->min, - strict_overflow_p) == 0 - && compare_values_warnv (vr0->max, vr1->max, - strict_overflow_p) == 0) - return boolean_false_node; - - /* Otherwise, they may or may not be different. */ - else - return NULL_TREE; + /* Update the last node of the list and move to the next one. */ + last_loc = loc; + loc = loc->next; } - else if (comp == LT_EXPR || comp == LE_EXPR) - { - int tst; - /* If VR0 is to the left of VR1, return true. */ - tst = compare_values_warnv (vr0->max, vr1->min, strict_overflow_p); - if ((comp == LT_EXPR && tst == -1) - || (comp == LE_EXPR && (tst == -1 || tst == 0))) - return boolean_true_node; - - /* If VR0 is to the right of VR1, return false. */ - tst = compare_values_warnv (vr0->min, vr1->max, strict_overflow_p); - if ((comp == LT_EXPR && (tst == 0 || tst == 1)) - || (comp == LE_EXPR && tst == 1)) - return boolean_false_node; + /* 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 + assertions associated with NAME. */ + n = XNEW (struct assert_locus); + n->bb = dest_bb; + n->e = e; + n->si = si; + n->comp_code = comp_code; + n->val = val; + n->expr = expr; + n->next = NULL; - /* Otherwise, we don't know. */ - return NULL_TREE; - } + if (last_loc) + last_loc->next = n; + else + asserts_for[SSA_NAME_VERSION (name)] = n; - gcc_unreachable (); + bitmap_set_bit (need_assert_for, SSA_NAME_VERSION (name)); } +/* (COND_OP0 COND_CODE COND_OP1) is a predicate which uses NAME. + Extract a suitable test code and value and store them into *CODE_P and + *VAL_P so the predicate is normalized to NAME *CODE_P *VAL_P. + + If no extraction was possible, return FALSE, otherwise return TRUE. -/* 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 - values in VR. Return BOOLEAN_FALSE_NODE if the comparison - always returns false. Return NULL_TREE if it is not always - possible to determine the value of the comparison. Also set - *STRICT_OVERFLOW_P to indicate whether comparision evaluation - assumed signed overflow is undefined. */ + If INVERT is true, then we invert the result stored into *CODE_P. */ -static tree -compare_range_with_value (enum tree_code comp, value_range *vr, tree val, - bool *strict_overflow_p) +static bool +extract_code_and_val_from_cond_with_ops (tree name, enum tree_code cond_code, + tree cond_op0, tree cond_op1, + bool invert, enum tree_code *code_p, + tree *val_p) { - if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED) - return NULL_TREE; + enum tree_code comp_code; + tree val; - /* Anti-ranges need to be handled separately. */ - if (vr->type == VR_ANTI_RANGE) + /* Otherwise, we have a comparison of the form NAME COMP VAL + or VAL COMP NAME. */ + if (name == cond_op1) { - /* For anti-ranges, the only predicates that we can compute at - compile time are equality and inequality. */ - if (comp == GT_EXPR - || comp == GE_EXPR - || comp == LT_EXPR - || comp == LE_EXPR) - return NULL_TREE; - - /* ~[VAL_1, VAL_2] OP VAL is known if VAL_1 <= VAL <= VAL_2. */ - if (value_inside_range (val, vr->min, vr->max) == 1) - return (comp == NE_EXPR) ? boolean_true_node : boolean_false_node; - - return NULL_TREE; + /* If the predicate is of the form VAL COMP NAME, flip + COMP around because we need to register NAME as the + first operand in the predicate. */ + comp_code = swap_tree_comparison (cond_code); + val = cond_op0; } - - if (comp == EQ_EXPR) + else if (name == cond_op0) { - /* EQ_EXPR may only be computed if VR represents exactly - one value. */ - if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0) - { - int cmp = compare_values_warnv (vr->min, val, strict_overflow_p); - if (cmp == 0) - return boolean_true_node; - else if (cmp == -1 || cmp == 1 || cmp == 2) - return boolean_false_node; - } - else if (compare_values_warnv (val, vr->min, strict_overflow_p) == -1 - || compare_values_warnv (vr->max, val, strict_overflow_p) == -1) - return boolean_false_node; - - return NULL_TREE; + /* The comparison is of the form NAME COMP VAL, so the + comparison code remains unchanged. */ + comp_code = cond_code; + val = cond_op1; } - else if (comp == NE_EXPR) - { - /* If VAL is not inside VR, then they are always different. */ - if (compare_values_warnv (vr->max, val, strict_overflow_p) == -1 - || compare_values_warnv (vr->min, val, strict_overflow_p) == 1) - return boolean_true_node; + else + gcc_unreachable (); - /* If VR represents exactly one value equal to VAL, then return - false. */ - if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0 - && compare_values_warnv (vr->min, val, strict_overflow_p) == 0) - return boolean_false_node; + /* Invert the comparison code as necessary. */ + if (invert) + comp_code = invert_tree_comparison (comp_code, 0); - /* Otherwise, they may or may not be different. */ - return NULL_TREE; - } - else if (comp == LT_EXPR || comp == LE_EXPR) - { - int tst; + /* VRP only handles integral and pointer types. */ + if (! INTEGRAL_TYPE_P (TREE_TYPE (val)) + && ! POINTER_TYPE_P (TREE_TYPE (val))) + return false; - /* If VR is to the left of VAL, return true. */ - tst = compare_values_warnv (vr->max, val, strict_overflow_p); - if ((comp == LT_EXPR && tst == -1) - || (comp == LE_EXPR && (tst == -1 || tst == 0))) - return boolean_true_node; + /* Do not register always-false predicates. + FIXME: this works around a limitation in fold() when dealing with + enumerations. Given 'enum { N1, N2 } x;', fold will not + fold 'if (x > N2)' to 'if (0)'. */ + if ((comp_code == GT_EXPR || comp_code == LT_EXPR) + && INTEGRAL_TYPE_P (TREE_TYPE (val))) + { + tree min = TYPE_MIN_VALUE (TREE_TYPE (val)); + tree max = TYPE_MAX_VALUE (TREE_TYPE (val)); - /* If VR is to the right of VAL, return false. */ - tst = compare_values_warnv (vr->min, val, strict_overflow_p); - if ((comp == LT_EXPR && (tst == 0 || tst == 1)) - || (comp == LE_EXPR && tst == 1)) - return boolean_false_node; + if (comp_code == GT_EXPR + && (!max + || compare_values (val, max) == 0)) + return false; - /* Otherwise, we don't know. */ - return NULL_TREE; + if (comp_code == LT_EXPR + && (!min + || compare_values (val, min) == 0)) + return false; } - else if (comp == GT_EXPR || comp == GE_EXPR) - { - int tst; + *code_p = comp_code; + *val_p = val; + return true; +} - /* If VR is to the right of VAL, return true. */ - tst = compare_values_warnv (vr->min, val, strict_overflow_p); - if ((comp == GT_EXPR && tst == 1) - || (comp == GE_EXPR && (tst == 0 || tst == 1))) - return boolean_true_node; +/* Find out smallest RES where RES > VAL && (RES & MASK) == RES, if any + (otherwise return VAL). VAL and MASK must be zero-extended for + precision PREC. If SGNBIT is non-zero, first xor VAL with SGNBIT + (to transform signed values into unsigned) and at the end xor + SGNBIT back. */ - /* If VR is to the left of VAL, return false. */ - tst = compare_values_warnv (vr->max, val, strict_overflow_p); - if ((comp == GT_EXPR && (tst == -1 || tst == 0)) - || (comp == GE_EXPR && tst == -1)) - return boolean_false_node; +static wide_int +masked_increment (const wide_int &val_in, const wide_int &mask, + const wide_int &sgnbit, unsigned int prec) +{ + wide_int bit = wi::one (prec), res; + unsigned int i; - /* Otherwise, we don't know. */ - return NULL_TREE; + wide_int val = val_in ^ sgnbit; + for (i = 0; i < prec; i++, bit += bit) + { + res = mask; + if ((res & bit) == 0) + continue; + res = bit - 1; + res = wi::bit_and_not (val + bit, res); + res &= mask; + if (wi::gtu_p (res, val)) + return res ^ sgnbit; } - - gcc_unreachable (); + return val ^ sgnbit; } +/* Helper for overflow_comparison_p -/* Debugging dumps. */ + OP0 CODE OP1 is a comparison. Examine the comparison and potentially + OP1's defining statement to see if it ultimately has the form + OP0 CODE (OP0 PLUS INTEGER_CST) -void dump_value_range (FILE *, const value_range *); -void debug_value_range (value_range *); -void dump_all_value_ranges (FILE *); -void dump_vr_equiv (FILE *, bitmap); -void debug_vr_equiv (bitmap); + If so, return TRUE indicating this is an overflow test and store into + *NEW_CST an updated constant that can be used in a narrowed range test. + REVERSED indicates if the comparison was originally: -/* Dump value range VR to FILE. */ + OP1 CODE' OP0. -void -dump_value_range (FILE *file, const value_range *vr) + This affects how we build the updated constant. */ + +static bool +overflow_comparison_p_1 (enum tree_code code, tree op0, tree op1, + bool follow_assert_exprs, bool reversed, tree *new_cst) { - if (vr == NULL) - fprintf (file, "[]"); - else if (vr->type == VR_UNDEFINED) - fprintf (file, "UNDEFINED"); - else if (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE) + /* See if this is a relational operation between two SSA_NAMES with + unsigned, overflow wrapping values. If so, check it more deeply. */ + if ((code == LT_EXPR || code == LE_EXPR + || code == GE_EXPR || code == GT_EXPR) + && TREE_CODE (op0) == SSA_NAME + && TREE_CODE (op1) == SSA_NAME + && INTEGRAL_TYPE_P (TREE_TYPE (op0)) + && TYPE_UNSIGNED (TREE_TYPE (op0)) + && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0))) { - tree type = TREE_TYPE (vr->min); - - fprintf (file, "%s[", (vr->type == VR_ANTI_RANGE) ? "~" : ""); - - if (INTEGRAL_TYPE_P (type) - && !TYPE_UNSIGNED (type) - && vrp_val_is_min (vr->min)) - fprintf (file, "-INF"); - else - print_generic_expr (file, vr->min); - - fprintf (file, ", "); - - if (INTEGRAL_TYPE_P (type) - && vrp_val_is_max (vr->max)) - fprintf (file, "+INF"); - else - print_generic_expr (file, vr->max); - - fprintf (file, "]"); + gimple *op1_def = SSA_NAME_DEF_STMT (op1); - if (vr->equiv) + /* If requested, follow any ASSERT_EXPRs backwards for OP1. */ + if (follow_assert_exprs) { - bitmap_iterator bi; - unsigned i, c = 0; + while (gimple_assign_single_p (op1_def) + && TREE_CODE (gimple_assign_rhs1 (op1_def)) == ASSERT_EXPR) + { + op1 = TREE_OPERAND (gimple_assign_rhs1 (op1_def), 0); + if (TREE_CODE (op1) != SSA_NAME) + break; + op1_def = SSA_NAME_DEF_STMT (op1); + } + } - fprintf (file, " EQUIVALENCES: { "); + /* Now look at the defining statement of OP1 to see if it adds + or subtracts a nonzero constant from another operand. */ + if (op1_def + && is_gimple_assign (op1_def) + && gimple_assign_rhs_code (op1_def) == PLUS_EXPR + && TREE_CODE (gimple_assign_rhs2 (op1_def)) == INTEGER_CST + && !integer_zerop (gimple_assign_rhs2 (op1_def))) + { + tree target = gimple_assign_rhs1 (op1_def); - EXECUTE_IF_SET_IN_BITMAP (vr->equiv, 0, i, bi) + /* If requested, follow ASSERT_EXPRs backwards for op0 looking + for one where TARGET appears on the RHS. */ + if (follow_assert_exprs) { - print_generic_expr (file, ssa_name (i)); - fprintf (file, " "); - c++; + /* Now see if that "other operand" is op0, following the chain + of ASSERT_EXPRs if necessary. */ + gimple *op0_def = SSA_NAME_DEF_STMT (op0); + while (op0 != target + && gimple_assign_single_p (op0_def) + && TREE_CODE (gimple_assign_rhs1 (op0_def)) == ASSERT_EXPR) + { + op0 = TREE_OPERAND (gimple_assign_rhs1 (op0_def), 0); + if (TREE_CODE (op0) != SSA_NAME) + break; + op0_def = SSA_NAME_DEF_STMT (op0); + } } - fprintf (file, "} (%u elements)", c); + /* If we did not find our target SSA_NAME, then this is not + an overflow test. */ + if (op0 != target) + return false; + + tree type = TREE_TYPE (op0); + wide_int max = wi::max_value (TYPE_PRECISION (type), UNSIGNED); + tree inc = gimple_assign_rhs2 (op1_def); + if (reversed) + *new_cst = wide_int_to_tree (type, max + wi::to_wide (inc)); + else + *new_cst = wide_int_to_tree (type, max - wi::to_wide (inc)); + return true; } } - else if (vr->type == VR_VARYING) - fprintf (file, "VARYING"); - else - fprintf (file, "INVALID RANGE"); + return false; } +/* OP0 CODE OP1 is a comparison. Examine the comparison and potentially + OP1's defining statement to see if it ultimately has the form + OP0 CODE (OP0 PLUS INTEGER_CST) -/* Dump value range VR to stderr. */ + If so, return TRUE indicating this is an overflow test and store into + *NEW_CST an updated constant that can be used in a narrowed range test. -DEBUG_FUNCTION void -debug_value_range (value_range *vr) + These statements are left as-is in the IL to facilitate discovery of + {ADD,SUB}_OVERFLOW sequences later in the optimizer pipeline. But + the alternate range representation is often useful within VRP. */ + +bool +overflow_comparison_p (tree_code code, tree name, tree val, + bool use_equiv_p, tree *new_cst) { - dump_value_range (stderr, vr); - fprintf (stderr, "\n"); + if (overflow_comparison_p_1 (code, name, val, use_equiv_p, false, new_cst)) + return true; + return overflow_comparison_p_1 (swap_tree_comparison (code), val, name, + use_equiv_p, true, new_cst); } -/* Dump value ranges of all SSA_NAMEs to FILE. */ +/* Try to register an edge assertion for SSA name NAME on edge E for + the condition COND contributing to the conditional jump pointed to by BSI. + Invert the condition COND if INVERT is true. */ -void -vr_values::dump_all_value_ranges (FILE *file) +static void +register_edge_assert_for_2 (tree name, edge e, + enum tree_code cond_code, + tree cond_op0, tree cond_op1, bool invert, + vec &asserts) { - size_t i; + tree val; + enum tree_code comp_code; + + if (!extract_code_and_val_from_cond_with_ops (name, cond_code, + cond_op0, + cond_op1, + invert, &comp_code, &val)) + return; - for (i = 0; i < num_vr_values; i++) + /* Queue the assert. */ + tree x; + if (overflow_comparison_p (comp_code, name, val, false, &x)) { - if (vr_value[i]) - { - print_generic_expr (file, ssa_name (i)); - fprintf (file, ": "); - dump_value_range (file, vr_value[i]); - fprintf (file, "\n"); - } + enum tree_code new_code = ((comp_code == GT_EXPR || comp_code == GE_EXPR) + ? GT_EXPR : LE_EXPR); + add_assert_info (asserts, name, name, new_code, x); } + add_assert_info (asserts, name, name, comp_code, val); - fprintf (file, "\n"); -} + /* In the case of NAME <= CST and NAME being defined as + NAME = (unsigned) NAME2 + CST2 we can assert NAME2 >= -CST2 + and NAME2 <= CST - CST2. We can do the same for NAME > CST. + This catches range and anti-range tests. */ + if ((comp_code == LE_EXPR + || comp_code == GT_EXPR) + && TREE_CODE (val) == INTEGER_CST + && TYPE_UNSIGNED (TREE_TYPE (val))) + { + gimple *def_stmt = SSA_NAME_DEF_STMT (name); + tree cst2 = NULL_TREE, name2 = NULL_TREE, name3 = NULL_TREE; -/* 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 - 'N = ASSERT_EXPR '. */ + /* Extract CST2 from the (optional) addition. */ + if (is_gimple_assign (def_stmt) + && gimple_assign_rhs_code (def_stmt) == PLUS_EXPR) + { + name2 = gimple_assign_rhs1 (def_stmt); + cst2 = gimple_assign_rhs2 (def_stmt); + if (TREE_CODE (name2) == SSA_NAME + && TREE_CODE (cst2) == INTEGER_CST) + def_stmt = SSA_NAME_DEF_STMT (name2); + } -static gimple * -build_assert_expr_for (tree cond, tree v) -{ - tree a; - gassign *assertion; + /* Extract NAME2 from the (optional) sign-changing cast. */ + if (gimple_assign_cast_p (def_stmt)) + { + if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)) + && ! TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (def_stmt))) + && (TYPE_PRECISION (gimple_expr_type (def_stmt)) + == TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt))))) + name3 = gimple_assign_rhs1 (def_stmt); + } - gcc_assert (TREE_CODE (v) == SSA_NAME - && COMPARISON_CLASS_P (cond)); + /* If name3 is used later, create an ASSERT_EXPR for it. */ + if (name3 != NULL_TREE + && TREE_CODE (name3) == SSA_NAME + && (cst2 == NULL_TREE + || TREE_CODE (cst2) == INTEGER_CST) + && INTEGRAL_TYPE_P (TREE_TYPE (name3))) + { + tree tmp; - a = build2 (ASSERT_EXPR, TREE_TYPE (v), v, cond); - assertion = gimple_build_assign (NULL_TREE, a); + /* Build an expression for the range test. */ + tmp = build1 (NOP_EXPR, TREE_TYPE (name), name3); + if (cst2 != NULL_TREE) + tmp = build2 (PLUS_EXPR, TREE_TYPE (name), tmp, cst2); - /* The new ASSERT_EXPR, creates a new SSA name that replaces the - operand of the ASSERT_EXPR. Create it so the new name and the old one - are registered in the replacement table so that we can fix the SSA web - after adding all the ASSERT_EXPRs. */ - tree new_def = create_new_def_for (v, assertion, NULL); - /* Make sure we preserve abnormalness throughout an ASSERT_EXPR chain - given we have to be able to fully propagate those out to re-create - valid SSA when removing the asserts. */ - if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (v)) - SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_def) = 1; + if (dump_file) + { + fprintf (dump_file, "Adding assert for "); + print_generic_expr (dump_file, name3); + fprintf (dump_file, " from "); + print_generic_expr (dump_file, tmp); + fprintf (dump_file, "\n"); + } - return assertion; -} + add_assert_info (asserts, name3, tmp, comp_code, val); + } + /* If name2 is used later, create an ASSERT_EXPR for it. */ + if (name2 != NULL_TREE + && TREE_CODE (name2) == SSA_NAME + && TREE_CODE (cst2) == INTEGER_CST + && INTEGRAL_TYPE_P (TREE_TYPE (name2))) + { + tree tmp; -/* Return false if EXPR is a predicate expression involving floating - point values. */ + /* Build an expression for the range test. */ + tmp = name2; + if (TREE_TYPE (name) != TREE_TYPE (name2)) + tmp = build1 (NOP_EXPR, TREE_TYPE (name), tmp); + if (cst2 != NULL_TREE) + tmp = build2 (PLUS_EXPR, TREE_TYPE (name), tmp, cst2); -static inline bool -fp_predicate (gimple *stmt) -{ - GIMPLE_CHECK (stmt, GIMPLE_COND); + if (dump_file) + { + fprintf (dump_file, "Adding assert for "); + print_generic_expr (dump_file, name2); + fprintf (dump_file, " from "); + print_generic_expr (dump_file, tmp); + fprintf (dump_file, "\n"); + } - return FLOAT_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt))); -} + add_assert_info (asserts, name2, tmp, comp_code, val); + } + } -/* 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 - describes the inferred range. Return true if a range could be - inferred. */ + /* In the case of post-in/decrement tests like if (i++) ... and uses + of the in/decremented value on the edge the extra name we want to + assert for is not on the def chain of the name compared. Instead + it is in the set of use stmts. + Similar cases happen for conversions that were simplified through + fold_{sign_changed,widened}_comparison. */ + if ((comp_code == NE_EXPR + || comp_code == EQ_EXPR) + && TREE_CODE (val) == INTEGER_CST) + { + imm_use_iterator ui; + gimple *use_stmt; + FOR_EACH_IMM_USE_STMT (use_stmt, ui, name) + { + if (!is_gimple_assign (use_stmt)) + continue; -bool -infer_value_range (gimple *stmt, tree op, tree_code *comp_code_p, tree *val_p) -{ - *val_p = NULL_TREE; - *comp_code_p = ERROR_MARK; + /* Cut off to use-stmts that are dominating the predecessor. */ + if (!dominated_by_p (CDI_DOMINATORS, e->src, gimple_bb (use_stmt))) + continue; - /* Do not attempt to infer anything in names that flow through - abnormal edges. */ - if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op)) - return false; + tree name2 = gimple_assign_lhs (use_stmt); + if (TREE_CODE (name2) != SSA_NAME) + continue; - /* If STMT is the last statement of a basic block with no normal - successors, there is no point inferring anything about any of its - operands. We would not be able to find a proper insertion point - for the assertion, anyway. */ - if (stmt_ends_bb_p (stmt)) - { - edge_iterator ei; - edge e; + enum tree_code code = gimple_assign_rhs_code (use_stmt); + tree cst; + if (code == PLUS_EXPR + || code == MINUS_EXPR) + { + cst = gimple_assign_rhs2 (use_stmt); + if (TREE_CODE (cst) != INTEGER_CST) + continue; + cst = int_const_binop (code, val, cst); + } + else if (CONVERT_EXPR_CODE_P (code)) + { + /* For truncating conversions we cannot record + an inequality. */ + if (comp_code == NE_EXPR + && (TYPE_PRECISION (TREE_TYPE (name2)) + < TYPE_PRECISION (TREE_TYPE (name)))) + continue; + cst = fold_convert (TREE_TYPE (name2), val); + } + else + continue; - FOR_EACH_EDGE (e, ei, gimple_bb (stmt)->succs) - if (!(e->flags & (EDGE_ABNORMAL|EDGE_EH))) - break; - if (e == NULL) - return false; + if (TREE_OVERFLOW_P (cst)) + cst = drop_tree_overflow (cst); + add_assert_info (asserts, name2, name2, comp_code, cst); + } } - - if (infer_nonnull_range (stmt, op)) + + if (TREE_CODE_CLASS (comp_code) == tcc_comparison + && TREE_CODE (val) == INTEGER_CST) { - *val_p = build_int_cst (TREE_TYPE (op), 0); - *comp_code_p = NE_EXPR; - return true; - } + gimple *def_stmt = SSA_NAME_DEF_STMT (name); + tree name2 = NULL_TREE, names[2], cst2 = NULL_TREE; + tree val2 = NULL_TREE; + unsigned int prec = TYPE_PRECISION (TREE_TYPE (val)); + wide_int mask = wi::zero (prec); + unsigned int nprec = prec; + enum tree_code rhs_code = ERROR_MARK; - return false; -} + if (is_gimple_assign (def_stmt)) + rhs_code = gimple_assign_rhs_code (def_stmt); + /* In the case of NAME != CST1 where NAME = A +- CST2 we can + assert that A != CST1 -+ CST2. */ + if ((comp_code == EQ_EXPR || comp_code == NE_EXPR) + && (rhs_code == PLUS_EXPR || rhs_code == MINUS_EXPR)) + { + tree op0 = gimple_assign_rhs1 (def_stmt); + tree op1 = gimple_assign_rhs2 (def_stmt); + if (TREE_CODE (op0) == SSA_NAME + && TREE_CODE (op1) == INTEGER_CST) + { + enum tree_code reverse_op = (rhs_code == PLUS_EXPR + ? MINUS_EXPR : PLUS_EXPR); + op1 = int_const_binop (reverse_op, val, op1); + if (TREE_OVERFLOW (op1)) + op1 = drop_tree_overflow (op1); + add_assert_info (asserts, op0, op0, comp_code, op1); + } + } -void dump_asserts_for (FILE *, tree); -void debug_asserts_for (tree); -void dump_all_asserts (FILE *); -void debug_all_asserts (void); + /* Add asserts for NAME cmp CST and NAME being defined + as NAME = (int) NAME2. */ + if (!TYPE_UNSIGNED (TREE_TYPE (val)) + && (comp_code == LE_EXPR || comp_code == LT_EXPR + || comp_code == GT_EXPR || comp_code == GE_EXPR) + && gimple_assign_cast_p (def_stmt)) + { + name2 = gimple_assign_rhs1 (def_stmt); + if (CONVERT_EXPR_CODE_P (rhs_code) + && INTEGRAL_TYPE_P (TREE_TYPE (name2)) + && TYPE_UNSIGNED (TREE_TYPE (name2)) + && prec == TYPE_PRECISION (TREE_TYPE (name2)) + && (comp_code == LE_EXPR || comp_code == GT_EXPR + || !tree_int_cst_equal (val, + TYPE_MIN_VALUE (TREE_TYPE (val))))) + { + tree tmp, cst; + enum tree_code new_comp_code = comp_code; -/* Dump all the registered assertions for NAME to FILE. */ + cst = fold_convert (TREE_TYPE (name2), + TYPE_MIN_VALUE (TREE_TYPE (val))); + /* Build an expression for the range test. */ + tmp = build2 (PLUS_EXPR, TREE_TYPE (name2), name2, cst); + cst = fold_build2 (PLUS_EXPR, TREE_TYPE (name2), cst, + fold_convert (TREE_TYPE (name2), val)); + if (comp_code == LT_EXPR || comp_code == GE_EXPR) + { + new_comp_code = comp_code == LT_EXPR ? LE_EXPR : GT_EXPR; + cst = fold_build2 (MINUS_EXPR, TREE_TYPE (name2), cst, + build_int_cst (TREE_TYPE (name2), 1)); + } -void -dump_asserts_for (FILE *file, tree name) -{ - assert_locus *loc; + if (dump_file) + { + fprintf (dump_file, "Adding assert for "); + print_generic_expr (dump_file, name2); + fprintf (dump_file, " from "); + print_generic_expr (dump_file, tmp); + fprintf (dump_file, "\n"); + } - fprintf (file, "Assertions to be inserted for "); - print_generic_expr (file, name); - fprintf (file, "\n"); + add_assert_info (asserts, name2, tmp, new_comp_code, cst); + } + } - loc = asserts_for[SSA_NAME_VERSION (name)]; - while (loc) - { - fprintf (file, "\t"); - print_gimple_stmt (file, gsi_stmt (loc->si), 0); - fprintf (file, "\n\tBB #%d", loc->bb->index); - if (loc->e) + /* Add asserts for NAME cmp CST and NAME being defined as + NAME = NAME2 >> CST2. + + Extract CST2 from the right shift. */ + if (rhs_code == RSHIFT_EXPR) { - fprintf (file, "\n\tEDGE %d->%d", loc->e->src->index, - loc->e->dest->index); - dump_edge_info (file, loc->e, dump_flags, 0); + name2 = gimple_assign_rhs1 (def_stmt); + cst2 = gimple_assign_rhs2 (def_stmt); + if (TREE_CODE (name2) == SSA_NAME + && tree_fits_uhwi_p (cst2) + && INTEGRAL_TYPE_P (TREE_TYPE (name2)) + && IN_RANGE (tree_to_uhwi (cst2), 1, prec - 1) + && type_has_mode_precision_p (TREE_TYPE (val))) + { + mask = wi::mask (tree_to_uhwi (cst2), false, prec); + val2 = fold_binary (LSHIFT_EXPR, TREE_TYPE (val), val, cst2); + } } - fprintf (file, "\n\tPREDICATE: "); - print_generic_expr (file, loc->expr); - fprintf (file, " %s ", get_tree_code_name (loc->comp_code)); - print_generic_expr (file, loc->val); - fprintf (file, "\n\n"); - loc = loc->next; - } - - fprintf (file, "\n"); -} + if (val2 != NULL_TREE + && TREE_CODE (val2) == INTEGER_CST + && simple_cst_equal (fold_build2 (RSHIFT_EXPR, + TREE_TYPE (val), + val2, cst2), val)) + { + enum tree_code new_comp_code = comp_code; + tree tmp, new_val; + tmp = name2; + if (comp_code == EQ_EXPR || comp_code == NE_EXPR) + { + if (!TYPE_UNSIGNED (TREE_TYPE (val))) + { + tree type = build_nonstandard_integer_type (prec, 1); + tmp = build1 (NOP_EXPR, type, name2); + val2 = fold_convert (type, val2); + } + tmp = fold_build2 (MINUS_EXPR, TREE_TYPE (tmp), tmp, val2); + new_val = wide_int_to_tree (TREE_TYPE (tmp), mask); + new_comp_code = comp_code == EQ_EXPR ? LE_EXPR : GT_EXPR; + } + else if (comp_code == LT_EXPR || comp_code == GE_EXPR) + { + wide_int minval + = wi::min_value (prec, TYPE_SIGN (TREE_TYPE (val))); + new_val = val2; + if (minval == wi::to_wide (new_val)) + new_val = NULL_TREE; + } + else + { + wide_int maxval + = wi::max_value (prec, TYPE_SIGN (TREE_TYPE (val))); + mask |= wi::to_wide (val2); + if (wi::eq_p (mask, maxval)) + new_val = NULL_TREE; + else + new_val = wide_int_to_tree (TREE_TYPE (val2), mask); + } -/* Dump all the registered assertions for NAME to stderr. */ + if (new_val) + { + if (dump_file) + { + fprintf (dump_file, "Adding assert for "); + print_generic_expr (dump_file, name2); + fprintf (dump_file, " from "); + print_generic_expr (dump_file, tmp); + fprintf (dump_file, "\n"); + } -DEBUG_FUNCTION void -debug_asserts_for (tree name) -{ - dump_asserts_for (stderr, name); -} - - -/* Dump all the registered assertions for all the names to FILE. */ - -void -dump_all_asserts (FILE *file) -{ - unsigned i; - bitmap_iterator bi; + add_assert_info (asserts, name2, tmp, new_comp_code, new_val); + } + } - fprintf (file, "\nASSERT_EXPRs to be inserted\n\n"); - EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi) - dump_asserts_for (file, ssa_name (i)); - fprintf (file, "\n"); -} + /* Add asserts for NAME cmp CST and NAME being defined as + NAME = NAME2 & CST2. + Extract CST2 from the and. -/* Dump all the registered assertions for all the names to stderr. */ + Also handle + NAME = (unsigned) NAME2; + casts where NAME's type is unsigned and has smaller precision + than NAME2's type as if it was NAME = NAME2 & MASK. */ + names[0] = NULL_TREE; + names[1] = NULL_TREE; + cst2 = NULL_TREE; + if (rhs_code == BIT_AND_EXPR + || (CONVERT_EXPR_CODE_P (rhs_code) + && INTEGRAL_TYPE_P (TREE_TYPE (val)) + && TYPE_UNSIGNED (TREE_TYPE (val)) + && TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt))) + > prec)) + { + name2 = gimple_assign_rhs1 (def_stmt); + if (rhs_code == BIT_AND_EXPR) + cst2 = gimple_assign_rhs2 (def_stmt); + else + { + cst2 = TYPE_MAX_VALUE (TREE_TYPE (val)); + nprec = TYPE_PRECISION (TREE_TYPE (name2)); + } + if (TREE_CODE (name2) == SSA_NAME + && INTEGRAL_TYPE_P (TREE_TYPE (name2)) + && TREE_CODE (cst2) == INTEGER_CST + && !integer_zerop (cst2) + && (nprec > 1 + || TYPE_UNSIGNED (TREE_TYPE (val)))) + { + gimple *def_stmt2 = SSA_NAME_DEF_STMT (name2); + if (gimple_assign_cast_p (def_stmt2)) + { + names[1] = gimple_assign_rhs1 (def_stmt2); + if (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt2)) + || !INTEGRAL_TYPE_P (TREE_TYPE (names[1])) + || (TYPE_PRECISION (TREE_TYPE (name2)) + != TYPE_PRECISION (TREE_TYPE (names[1])))) + names[1] = NULL_TREE; + } + names[0] = name2; + } + } + if (names[0] || names[1]) + { + wide_int minv, maxv, valv, cst2v; + wide_int tem, sgnbit; + bool valid_p = false, valn, cst2n; + enum tree_code ccode = comp_code; -DEBUG_FUNCTION void -debug_all_asserts (void) -{ - dump_all_asserts (stderr); -} + valv = wide_int::from (wi::to_wide (val), nprec, UNSIGNED); + cst2v = wide_int::from (wi::to_wide (cst2), nprec, UNSIGNED); + valn = wi::neg_p (valv, TYPE_SIGN (TREE_TYPE (val))); + cst2n = wi::neg_p (cst2v, TYPE_SIGN (TREE_TYPE (val))); + /* If CST2 doesn't have most significant bit set, + but VAL is negative, we have comparison like + if ((x & 0x123) > -4) (always true). Just give up. */ + if (!cst2n && valn) + ccode = ERROR_MARK; + if (cst2n) + sgnbit = wi::set_bit_in_zero (nprec - 1, nprec); + else + sgnbit = wi::zero (nprec); + minv = valv & cst2v; + switch (ccode) + { + case EQ_EXPR: + /* Minimum unsigned value for equality is VAL & CST2 + (should be equal to VAL, otherwise we probably should + have folded the comparison into false) and + maximum unsigned value is VAL | ~CST2. */ + maxv = valv | ~cst2v; + valid_p = true; + break; -/* Push the assert info for NAME, EXPR, COMP_CODE and VAL to ASSERTS. */ + case NE_EXPR: + tem = valv | ~cst2v; + /* If VAL is 0, handle (X & CST2) != 0 as (X & CST2) > 0U. */ + if (valv == 0) + { + cst2n = false; + sgnbit = wi::zero (nprec); + goto gt_expr; + } + /* If (VAL | ~CST2) is all ones, handle it as + (X & CST2) < VAL. */ + if (tem == -1) + { + cst2n = false; + valn = false; + sgnbit = wi::zero (nprec); + goto lt_expr; + } + if (!cst2n && wi::neg_p (cst2v)) + sgnbit = wi::set_bit_in_zero (nprec - 1, nprec); + if (sgnbit != 0) + { + if (valv == sgnbit) + { + cst2n = true; + valn = true; + goto gt_expr; + } + if (tem == wi::mask (nprec - 1, false, nprec)) + { + cst2n = true; + goto lt_expr; + } + if (!cst2n) + sgnbit = wi::zero (nprec); + } + break; -static void -add_assert_info (vec &asserts, - tree name, tree expr, enum tree_code comp_code, tree val) -{ - assert_info info; - info.comp_code = comp_code; - info.name = name; - info.val = val; - info.expr = expr; - asserts.safe_push (info); -} + case GE_EXPR: + /* Minimum unsigned value for >= if (VAL & CST2) == VAL + is VAL and maximum unsigned value is ~0. For signed + comparison, if CST2 doesn't have most significant bit + set, handle it similarly. If CST2 has MSB set, + the minimum is the same, and maximum is ~0U/2. */ + if (minv != valv) + { + /* If (VAL & CST2) != VAL, X & CST2 can't be equal to + VAL. */ + minv = masked_increment (valv, cst2v, sgnbit, nprec); + if (minv == valv) + break; + } + maxv = wi::mask (nprec - (cst2n ? 1 : 0), false, nprec); + valid_p = true; + break; -/* If NAME doesn't have an ASSERT_EXPR registered for asserting - 'EXPR COMP_CODE VAL' at a location that dominates block BB or - E->DEST, then register this location as a possible insertion point - for ASSERT_EXPR . + case GT_EXPR: + gt_expr: + /* Find out smallest MINV where MINV > VAL + && (MINV & CST2) == MINV, if any. If VAL is signed and + CST2 has MSB set, compute it biased by 1 << (nprec - 1). */ + minv = masked_increment (valv, cst2v, sgnbit, nprec); + if (minv == valv) + break; + maxv = wi::mask (nprec - (cst2n ? 1 : 0), false, nprec); + valid_p = true; + break; - 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 - 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 - must not be NULL. */ + case LE_EXPR: + /* Minimum unsigned value for <= is 0 and maximum + unsigned value is VAL | ~CST2 if (VAL & CST2) == VAL. + Otherwise, find smallest VAL2 where VAL2 > VAL + && (VAL2 & CST2) == VAL2 and use (VAL2 - 1) | ~CST2 + as maximum. + For signed comparison, if CST2 doesn't have most + significant bit set, handle it similarly. If CST2 has + MSB set, the maximum is the same and minimum is INT_MIN. */ + if (minv == valv) + maxv = valv; + else + { + maxv = masked_increment (valv, cst2v, sgnbit, nprec); + if (maxv == valv) + break; + maxv -= 1; + } + maxv |= ~cst2v; + minv = sgnbit; + valid_p = true; + break; -static void -register_new_assert_for (tree name, tree expr, - enum tree_code comp_code, - tree val, - basic_block bb, - edge e, - gimple_stmt_iterator si) -{ - assert_locus *n, *loc, *last_loc; - basic_block dest_bb; + case LT_EXPR: + lt_expr: + /* Minimum unsigned value for < is 0 and maximum + unsigned value is (VAL-1) | ~CST2 if (VAL & CST2) == VAL. + Otherwise, find smallest VAL2 where VAL2 > VAL + && (VAL2 & CST2) == VAL2 and use (VAL2 - 1) | ~CST2 + as maximum. + For signed comparison, if CST2 doesn't have most + significant bit set, handle it similarly. If CST2 has + MSB set, the maximum is the same and minimum is INT_MIN. */ + if (minv == valv) + { + if (valv == sgnbit) + break; + maxv = valv; + } + else + { + maxv = masked_increment (valv, cst2v, sgnbit, nprec); + if (maxv == valv) + break; + } + maxv -= 1; + maxv |= ~cst2v; + minv = sgnbit; + valid_p = true; + break; - gcc_checking_assert (bb == NULL || e == NULL); + default: + break; + } + if (valid_p + && (maxv - minv) != -1) + { + tree tmp, new_val, type; + int i; - if (e == NULL) - gcc_checking_assert (gimple_code (gsi_stmt (si)) != GIMPLE_COND - && gimple_code (gsi_stmt (si)) != GIMPLE_SWITCH); - - /* Never build an assert comparing against an integer constant with - TREE_OVERFLOW set. This confuses our undefined overflow warning - machinery. */ - if (TREE_OVERFLOW_P (val)) - val = drop_tree_overflow (val); - - /* The new assertion A will be inserted at BB or E. We need to - determine if the new location is dominated by a previously - 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 - necessarily true. - - 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 - E->DEST dominates. - - The reverse, however, is not true, blocks dominated by E->DEST - 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 - the new location to move another assertion previously registered - at a block dominated by E->DEST. */ - dest_bb = (bb) ? bb : e->dest; + for (i = 0; i < 2; i++) + if (names[i]) + { + wide_int maxv2 = maxv; + tmp = names[i]; + type = TREE_TYPE (names[i]); + if (!TYPE_UNSIGNED (type)) + { + type = build_nonstandard_integer_type (nprec, 1); + tmp = build1 (NOP_EXPR, type, names[i]); + } + if (minv != 0) + { + tmp = build2 (PLUS_EXPR, type, tmp, + wide_int_to_tree (type, -minv)); + maxv2 = maxv - minv; + } + new_val = wide_int_to_tree (type, maxv2); - /* 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 - one. Similarly, if the same assertion already exists at a block - dominated by DEST_BB and the new location is not on a critical - edge, then update the existing location for the assertion (i.e., - move the assertion up in the dominance tree). + if (dump_file) + { + fprintf (dump_file, "Adding assert for "); + print_generic_expr (dump_file, names[i]); + fprintf (dump_file, " from "); + print_generic_expr (dump_file, tmp); + fprintf (dump_file, "\n"); + } - Note, this is implemented as a simple linked list because there - should not be more than a handful of assertions registered per - name. If this becomes a performance problem, a table hashed by - COMP_CODE and VAL could be implemented. */ - loc = asserts_for[SSA_NAME_VERSION (name)]; - last_loc = loc; - while (loc) - { - if (loc->comp_code == comp_code - && (loc->val == val - || operand_equal_p (loc->val, val, 0)) - && (loc->expr == expr - || operand_equal_p (loc->expr, expr, 0))) - { - /* If E is not a critical edge and DEST_BB - dominates the existing location for the assertion, move - the assertion up in the dominance tree by updating its - location information. */ - if ((e == NULL || !EDGE_CRITICAL_P (e)) - && dominated_by_p (CDI_DOMINATORS, loc->bb, dest_bb)) - { - loc->bb = dest_bb; - loc->e = e; - loc->si = si; - return; + add_assert_info (asserts, names[i], tmp, LE_EXPR, new_val); + } } } - - /* Update the last node of the list and move to the next one. */ - last_loc = loc; - loc = loc->next; } +} - /* 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 - assertions associated with NAME. */ - n = XNEW (struct assert_locus); - n->bb = dest_bb; - n->e = e; - n->si = si; - n->comp_code = comp_code; - n->val = val; - n->expr = expr; - n->next = NULL; +/* OP is an operand of a truth value expression which is known to have + a particular value. Register any asserts for OP and for any + operands in OP's defining statement. - if (last_loc) - last_loc->next = n; - else - asserts_for[SSA_NAME_VERSION (name)] = n; + If CODE is EQ_EXPR, then we want to register OP is zero (false), + if CODE is NE_EXPR, then we want to register OP is nonzero (true). */ - bitmap_set_bit (need_assert_for, SSA_NAME_VERSION (name)); -} +static void +register_edge_assert_for_1 (tree op, enum tree_code code, + edge e, vec &asserts) +{ + gimple *op_def; + tree val; + enum tree_code rhs_code; -/* (COND_OP0 COND_CODE COND_OP1) is a predicate which uses NAME. - Extract a suitable test code and value and store them into *CODE_P and - *VAL_P so the predicate is normalized to NAME *CODE_P *VAL_P. + /* We only care about SSA_NAMEs. */ + if (TREE_CODE (op) != SSA_NAME) + return; - If no extraction was possible, return FALSE, otherwise return TRUE. + /* We know that OP will have a zero or nonzero value. */ + val = build_int_cst (TREE_TYPE (op), 0); + add_assert_info (asserts, op, op, code, val); - If INVERT is true, then we invert the result stored into *CODE_P. */ + /* Now look at how OP is set. If it's set from a comparison, + a truth operation or some bit operations, then we may be able + to register information about the operands of that assignment. */ + op_def = SSA_NAME_DEF_STMT (op); + if (gimple_code (op_def) != GIMPLE_ASSIGN) + return; -static bool -extract_code_and_val_from_cond_with_ops (tree name, enum tree_code cond_code, - tree cond_op0, tree cond_op1, - bool invert, enum tree_code *code_p, - tree *val_p) -{ - enum tree_code comp_code; - tree val; + rhs_code = gimple_assign_rhs_code (op_def); - /* Otherwise, we have a comparison of the form NAME COMP VAL - or VAL COMP NAME. */ - if (name == cond_op1) + if (TREE_CODE_CLASS (rhs_code) == tcc_comparison) { - /* If the predicate is of the form VAL COMP NAME, flip - COMP around because we need to register NAME as the - first operand in the predicate. */ - comp_code = swap_tree_comparison (cond_code); - val = cond_op0; + bool invert = (code == EQ_EXPR ? true : false); + tree op0 = gimple_assign_rhs1 (op_def); + tree op1 = gimple_assign_rhs2 (op_def); + + if (TREE_CODE (op0) == SSA_NAME) + register_edge_assert_for_2 (op0, e, rhs_code, op0, op1, invert, asserts); + if (TREE_CODE (op1) == SSA_NAME) + register_edge_assert_for_2 (op1, e, rhs_code, op0, op1, invert, asserts); } - else if (name == cond_op0) + else if ((code == NE_EXPR + && gimple_assign_rhs_code (op_def) == BIT_AND_EXPR) + || (code == EQ_EXPR + && gimple_assign_rhs_code (op_def) == BIT_IOR_EXPR)) { - /* The comparison is of the form NAME COMP VAL, so the - comparison code remains unchanged. */ - comp_code = cond_code; - val = cond_op1; + /* Recurse on each operand. */ + tree op0 = gimple_assign_rhs1 (op_def); + tree op1 = gimple_assign_rhs2 (op_def); + if (TREE_CODE (op0) == SSA_NAME + && has_single_use (op0)) + register_edge_assert_for_1 (op0, code, e, asserts); + if (TREE_CODE (op1) == SSA_NAME + && has_single_use (op1)) + register_edge_assert_for_1 (op1, code, e, asserts); } - else - gcc_unreachable (); - - /* Invert the comparison code as necessary. */ - if (invert) - comp_code = invert_tree_comparison (comp_code, 0); - - /* VRP only handles integral and pointer types. */ - if (! INTEGRAL_TYPE_P (TREE_TYPE (val)) - && ! POINTER_TYPE_P (TREE_TYPE (val))) - return false; - - /* Do not register always-false predicates. - FIXME: this works around a limitation in fold() when dealing with - enumerations. Given 'enum { N1, N2 } x;', fold will not - fold 'if (x > N2)' to 'if (0)'. */ - if ((comp_code == GT_EXPR || comp_code == LT_EXPR) - && INTEGRAL_TYPE_P (TREE_TYPE (val))) + else if (gimple_assign_rhs_code (op_def) == BIT_NOT_EXPR + && TYPE_PRECISION (TREE_TYPE (gimple_assign_lhs (op_def))) == 1) { - tree min = TYPE_MIN_VALUE (TREE_TYPE (val)); - tree max = TYPE_MAX_VALUE (TREE_TYPE (val)); - - if (comp_code == GT_EXPR - && (!max - || compare_values (val, max) == 0)) - return false; - - if (comp_code == LT_EXPR - && (!min - || compare_values (val, min) == 0)) - return false; + /* Recurse, flipping CODE. */ + code = invert_tree_comparison (code, false); + register_edge_assert_for_1 (gimple_assign_rhs1 (op_def), code, e, asserts); + } + else if (gimple_assign_rhs_code (op_def) == SSA_NAME) + { + /* Recurse through the copy. */ + register_edge_assert_for_1 (gimple_assign_rhs1 (op_def), code, e, asserts); + } + else if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (op_def))) + { + /* Recurse through the type conversion, unless it is a narrowing + conversion or conversion from non-integral type. */ + tree rhs = gimple_assign_rhs1 (op_def); + if (INTEGRAL_TYPE_P (TREE_TYPE (rhs)) + && (TYPE_PRECISION (TREE_TYPE (rhs)) + <= TYPE_PRECISION (TREE_TYPE (op)))) + register_edge_assert_for_1 (rhs, code, e, asserts); } - *code_p = comp_code; - *val_p = val; - return true; } -/* Find out smallest RES where RES > VAL && (RES & MASK) == RES, if any - (otherwise return VAL). VAL and MASK must be zero-extended for - precision PREC. If SGNBIT is non-zero, first xor VAL with SGNBIT - (to transform signed values into unsigned) and at the end xor - SGNBIT back. */ +/* Check if comparison + NAME COND_OP INTEGER_CST + has a form of + (X & 11...100..0) COND_OP XX...X00...0 + Such comparison can yield assertions like + X >= XX...X00...0 + X <= XX...X11...1 + in case of COND_OP being NE_EXPR or + X < XX...X00...0 + X > XX...X11...1 + in case of EQ_EXPR. */ -static wide_int -masked_increment (const wide_int &val_in, const wide_int &mask, - const wide_int &sgnbit, unsigned int prec) +static bool +is_masked_range_test (tree name, tree valt, enum tree_code cond_code, + tree *new_name, tree *low, enum tree_code *low_code, + tree *high, enum tree_code *high_code) { - wide_int bit = wi::one (prec), res; - unsigned int i; - - wide_int val = val_in ^ sgnbit; - for (i = 0; i < prec; i++, bit += bit) - { - res = mask; - if ((res & bit) == 0) - continue; - res = bit - 1; - res = wi::bit_and_not (val + bit, res); - res &= mask; - if (wi::gtu_p (res, val)) - return res ^ sgnbit; - } - return val ^ sgnbit; -} + gimple *def_stmt = SSA_NAME_DEF_STMT (name); -/* Helper for overflow_comparison_p + if (!is_gimple_assign (def_stmt) + || gimple_assign_rhs_code (def_stmt) != BIT_AND_EXPR) + return false; - OP0 CODE OP1 is a comparison. Examine the comparison and potentially - OP1's defining statement to see if it ultimately has the form - OP0 CODE (OP0 PLUS INTEGER_CST) + tree t = gimple_assign_rhs1 (def_stmt); + tree maskt = gimple_assign_rhs2 (def_stmt); + if (TREE_CODE (t) != SSA_NAME || TREE_CODE (maskt) != INTEGER_CST) + return false; - If so, return TRUE indicating this is an overflow test and store into - *NEW_CST an updated constant that can be used in a narrowed range test. + wi::tree_to_wide_ref mask = wi::to_wide (maskt); + wide_int inv_mask = ~mask; + /* Assume VALT is INTEGER_CST. */ + wi::tree_to_wide_ref val = wi::to_wide (valt); - REVERSED indicates if the comparison was originally: + if ((inv_mask & (inv_mask + 1)) != 0 + || (val & mask) != val) + return false; - OP1 CODE' OP0. + bool is_range = cond_code == EQ_EXPR; - This affects how we build the updated constant. */ + tree type = TREE_TYPE (t); + wide_int min = wi::min_value (type), + max = wi::max_value (type); -static bool -overflow_comparison_p_1 (enum tree_code code, tree op0, tree op1, - bool follow_assert_exprs, bool reversed, tree *new_cst) -{ - /* See if this is a relational operation between two SSA_NAMES with - unsigned, overflow wrapping values. If so, check it more deeply. */ - if ((code == LT_EXPR || code == LE_EXPR - || code == GE_EXPR || code == GT_EXPR) - && TREE_CODE (op0) == SSA_NAME - && TREE_CODE (op1) == SSA_NAME - && INTEGRAL_TYPE_P (TREE_TYPE (op0)) - && TYPE_UNSIGNED (TREE_TYPE (op0)) - && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0))) + if (is_range) { - gimple *op1_def = SSA_NAME_DEF_STMT (op1); - - /* If requested, follow any ASSERT_EXPRs backwards for OP1. */ - if (follow_assert_exprs) + *low_code = val == min ? ERROR_MARK : GE_EXPR; + *high_code = val == max ? ERROR_MARK : LE_EXPR; + } + else + { + /* We can still generate assertion if one of alternatives + is known to always be false. */ + if (val == min) { - while (gimple_assign_single_p (op1_def) - && TREE_CODE (gimple_assign_rhs1 (op1_def)) == ASSERT_EXPR) - { - op1 = TREE_OPERAND (gimple_assign_rhs1 (op1_def), 0); - if (TREE_CODE (op1) != SSA_NAME) - break; - op1_def = SSA_NAME_DEF_STMT (op1); - } + *low_code = (enum tree_code) 0; + *high_code = GT_EXPR; } - - /* Now look at the defining statement of OP1 to see if it adds - or subtracts a nonzero constant from another operand. */ - if (op1_def - && is_gimple_assign (op1_def) - && gimple_assign_rhs_code (op1_def) == PLUS_EXPR - && TREE_CODE (gimple_assign_rhs2 (op1_def)) == INTEGER_CST - && !integer_zerop (gimple_assign_rhs2 (op1_def))) + else if ((val | inv_mask) == max) { - tree target = gimple_assign_rhs1 (op1_def); - - /* If requested, follow ASSERT_EXPRs backwards for op0 looking - for one where TARGET appears on the RHS. */ - if (follow_assert_exprs) - { - /* Now see if that "other operand" is op0, following the chain - of ASSERT_EXPRs if necessary. */ - gimple *op0_def = SSA_NAME_DEF_STMT (op0); - while (op0 != target - && gimple_assign_single_p (op0_def) - && TREE_CODE (gimple_assign_rhs1 (op0_def)) == ASSERT_EXPR) - { - op0 = TREE_OPERAND (gimple_assign_rhs1 (op0_def), 0); - if (TREE_CODE (op0) != SSA_NAME) - break; - op0_def = SSA_NAME_DEF_STMT (op0); - } - } - - /* If we did not find our target SSA_NAME, then this is not - an overflow test. */ - if (op0 != target) - return false; - - tree type = TREE_TYPE (op0); - wide_int max = wi::max_value (TYPE_PRECISION (type), UNSIGNED); - tree inc = gimple_assign_rhs2 (op1_def); - if (reversed) - *new_cst = wide_int_to_tree (type, max + wi::to_wide (inc)); - else - *new_cst = wide_int_to_tree (type, max - wi::to_wide (inc)); - return true; + *low_code = LT_EXPR; + *high_code = (enum tree_code) 0; } + else + return false; } - return false; -} - -/* OP0 CODE OP1 is a comparison. Examine the comparison and potentially - OP1's defining statement to see if it ultimately has the form - OP0 CODE (OP0 PLUS INTEGER_CST) - If so, return TRUE indicating this is an overflow test and store into - *NEW_CST an updated constant that can be used in a narrowed range test. + *new_name = t; + *low = wide_int_to_tree (type, val); + *high = wide_int_to_tree (type, val | inv_mask); - These statements are left as-is in the IL to facilitate discovery of - {ADD,SUB}_OVERFLOW sequences later in the optimizer pipeline. But - the alternate range representation is often useful within VRP. */ + if (wi::neg_p (val, TYPE_SIGN (type))) + std::swap (*low, *high); -static bool -overflow_comparison_p (tree_code code, tree name, tree val, - bool use_equiv_p, tree *new_cst) -{ - if (overflow_comparison_p_1 (code, name, val, use_equiv_p, false, new_cst)) - return true; - return overflow_comparison_p_1 (swap_tree_comparison (code), val, name, - use_equiv_p, true, new_cst); + return true; } - /* Try to register an edge assertion for SSA name NAME on edge E for - the condition COND contributing to the conditional jump pointed to by BSI. - Invert the condition COND if INVERT is true. */ + the condition COND contributing to the conditional jump pointed to by + SI. */ -static void -register_edge_assert_for_2 (tree name, edge e, - enum tree_code cond_code, - tree cond_op0, tree cond_op1, bool invert, - vec &asserts) +void +register_edge_assert_for (tree name, edge e, + enum tree_code cond_code, tree cond_op0, + tree cond_op1, vec &asserts) { tree val; enum tree_code comp_code; + bool is_else_edge = (e->flags & EDGE_FALSE_VALUE) != 0; + + /* Do not attempt to infer anything in names that flow through + abnormal edges. */ + if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name)) + return; if (!extract_code_and_val_from_cond_with_ops (name, cond_code, - cond_op0, - cond_op1, - invert, &comp_code, &val)) + cond_op0, cond_op1, + is_else_edge, + &comp_code, &val)) return; - /* Queue the assert. */ - tree x; - if (overflow_comparison_p (comp_code, name, val, false, &x)) - { - enum tree_code new_code = ((comp_code == GT_EXPR || comp_code == GE_EXPR) - ? GT_EXPR : LE_EXPR); - add_assert_info (asserts, name, name, new_code, x); - } - add_assert_info (asserts, name, name, comp_code, val); + /* Register ASSERT_EXPRs for name. */ + register_edge_assert_for_2 (name, e, cond_code, cond_op0, + cond_op1, is_else_edge, asserts); - /* In the case of NAME <= CST and NAME being defined as - NAME = (unsigned) NAME2 + CST2 we can assert NAME2 >= -CST2 - and NAME2 <= CST - CST2. We can do the same for NAME > CST. - This catches range and anti-range tests. */ - if ((comp_code == LE_EXPR - || comp_code == GT_EXPR) - && TREE_CODE (val) == INTEGER_CST - && TYPE_UNSIGNED (TREE_TYPE (val))) + + /* If COND is effectively an equality test of an SSA_NAME against + the value zero or one, then we may be able to assert values + for SSA_NAMEs which flow into COND. */ + + /* In the case of NAME == 1 or NAME != 0, for BIT_AND_EXPR defining + statement of NAME we can assert both operands of the BIT_AND_EXPR + have nonzero value. */ + if (((comp_code == EQ_EXPR && integer_onep (val)) + || (comp_code == NE_EXPR && integer_zerop (val)))) { gimple *def_stmt = SSA_NAME_DEF_STMT (name); - tree cst2 = NULL_TREE, name2 = NULL_TREE, name3 = NULL_TREE; - /* Extract CST2 from the (optional) addition. */ if (is_gimple_assign (def_stmt) - && gimple_assign_rhs_code (def_stmt) == PLUS_EXPR) + && gimple_assign_rhs_code (def_stmt) == BIT_AND_EXPR) { - name2 = gimple_assign_rhs1 (def_stmt); - cst2 = gimple_assign_rhs2 (def_stmt); - if (TREE_CODE (name2) == SSA_NAME - && TREE_CODE (cst2) == INTEGER_CST) - def_stmt = SSA_NAME_DEF_STMT (name2); + tree op0 = gimple_assign_rhs1 (def_stmt); + tree op1 = gimple_assign_rhs2 (def_stmt); + register_edge_assert_for_1 (op0, NE_EXPR, e, asserts); + register_edge_assert_for_1 (op1, NE_EXPR, e, asserts); } + } - /* Extract NAME2 from the (optional) sign-changing cast. */ - if (gimple_assign_cast_p (def_stmt)) + /* In the case of NAME == 0 or NAME != 1, for BIT_IOR_EXPR defining + statement of NAME we can assert both operands of the BIT_IOR_EXPR + have zero value. */ + if (((comp_code == EQ_EXPR && integer_zerop (val)) + || (comp_code == NE_EXPR && integer_onep (val)))) + { + gimple *def_stmt = SSA_NAME_DEF_STMT (name); + + /* For BIT_IOR_EXPR only if NAME == 0 both operands have + necessarily zero value, or if type-precision is one. */ + if (is_gimple_assign (def_stmt) + && (gimple_assign_rhs_code (def_stmt) == BIT_IOR_EXPR + && (TYPE_PRECISION (TREE_TYPE (name)) == 1 + || comp_code == EQ_EXPR))) { - if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)) - && ! TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (def_stmt))) - && (TYPE_PRECISION (gimple_expr_type (def_stmt)) - == TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt))))) - name3 = gimple_assign_rhs1 (def_stmt); + tree op0 = gimple_assign_rhs1 (def_stmt); + tree op1 = gimple_assign_rhs2 (def_stmt); + register_edge_assert_for_1 (op0, EQ_EXPR, e, asserts); + register_edge_assert_for_1 (op1, EQ_EXPR, e, asserts); } + } - /* If name3 is used later, create an ASSERT_EXPR for it. */ - if (name3 != NULL_TREE - && TREE_CODE (name3) == SSA_NAME - && (cst2 == NULL_TREE - || TREE_CODE (cst2) == INTEGER_CST) - && INTEGRAL_TYPE_P (TREE_TYPE (name3))) - { - tree tmp; + /* Sometimes we can infer ranges from (NAME & MASK) == VALUE. */ + if ((comp_code == EQ_EXPR || comp_code == NE_EXPR) + && TREE_CODE (val) == INTEGER_CST) + { + enum tree_code low_code, high_code; + tree low, high; + if (is_masked_range_test (name, val, comp_code, &name, &low, + &low_code, &high, &high_code)) + { + if (low_code != ERROR_MARK) + register_edge_assert_for_2 (name, e, low_code, name, + low, /*invert*/false, asserts); + if (high_code != ERROR_MARK) + register_edge_assert_for_2 (name, e, high_code, name, + high, /*invert*/false, asserts); + } + } +} - /* Build an expression for the range test. */ - tmp = build1 (NOP_EXPR, TREE_TYPE (name), name3); - if (cst2 != NULL_TREE) - tmp = build2 (PLUS_EXPR, TREE_TYPE (name), tmp, cst2); +/* Finish found ASSERTS for E and register them at GSI. */ - if (dump_file) - { - fprintf (dump_file, "Adding assert for "); - print_generic_expr (dump_file, name3); - fprintf (dump_file, " from "); - print_generic_expr (dump_file, tmp); - fprintf (dump_file, "\n"); - } +static void +finish_register_edge_assert_for (edge e, gimple_stmt_iterator gsi, + vec &asserts) +{ + for (unsigned i = 0; i < asserts.length (); ++i) + /* Only register an ASSERT_EXPR if NAME was found in the sub-graph + reachable from E. */ + if (live_on_edge (e, asserts[i].name)) + register_new_assert_for (asserts[i].name, asserts[i].expr, + asserts[i].comp_code, asserts[i].val, + NULL, e, gsi); +} - add_assert_info (asserts, name3, tmp, comp_code, val); - } - /* If name2 is used later, create an ASSERT_EXPR for it. */ - if (name2 != NULL_TREE - && TREE_CODE (name2) == SSA_NAME - && TREE_CODE (cst2) == INTEGER_CST - && INTEGRAL_TYPE_P (TREE_TYPE (name2))) - { - tree tmp; - /* Build an expression for the range test. */ - tmp = name2; - if (TREE_TYPE (name) != TREE_TYPE (name2)) - tmp = build1 (NOP_EXPR, TREE_TYPE (name), tmp); - if (cst2 != NULL_TREE) - tmp = build2 (PLUS_EXPR, TREE_TYPE (name), tmp, cst2); +/* Determine whether the outgoing edges of BB should receive an + ASSERT_EXPR for each of the operands of BB's LAST statement. + The last statement of BB must be a COND_EXPR. - if (dump_file) - { - fprintf (dump_file, "Adding assert for "); - print_generic_expr (dump_file, name2); - fprintf (dump_file, " from "); - print_generic_expr (dump_file, tmp); - fprintf (dump_file, "\n"); - } + 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 + list of assertions for the corresponding operands. */ - add_assert_info (asserts, name2, tmp, comp_code, val); - } +static void +find_conditional_asserts (basic_block bb, gcond *last) +{ + gimple_stmt_iterator bsi; + tree op; + edge_iterator ei; + edge e; + ssa_op_iter iter; + + bsi = gsi_for_stmt (last); + + /* Look for uses of the operands in each of the sub-graphs + rooted at BB. We need to check each of the outgoing edges + separately, so that we know what kind of ASSERT_EXPR to + insert. */ + FOR_EACH_EDGE (e, ei, bb->succs) + { + if (e->dest == bb) + continue; + + /* Register the necessary assertions for each operand in the + conditional predicate. */ + auto_vec asserts; + FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE) + register_edge_assert_for (op, e, + gimple_cond_code (last), + gimple_cond_lhs (last), + gimple_cond_rhs (last), asserts); + finish_register_edge_assert_for (e, bsi, asserts); } +} - /* In the case of post-in/decrement tests like if (i++) ... and uses - of the in/decremented value on the edge the extra name we want to - assert for is not on the def chain of the name compared. Instead - it is in the set of use stmts. - Similar cases happen for conversions that were simplified through - fold_{sign_changed,widened}_comparison. */ - if ((comp_code == NE_EXPR - || comp_code == EQ_EXPR) - && TREE_CODE (val) == INTEGER_CST) +struct case_info +{ + tree expr; + basic_block bb; +}; + +/* Compare two case labels sorting first by the destination bb index + and then by the case value. */ + +static int +compare_case_labels (const void *p1, const void *p2) +{ + const struct case_info *ci1 = (const struct case_info *) p1; + const struct case_info *ci2 = (const struct case_info *) p2; + int idx1 = ci1->bb->index; + int idx2 = ci2->bb->index; + + if (idx1 < idx2) + return -1; + else if (idx1 == idx2) { - imm_use_iterator ui; - gimple *use_stmt; - FOR_EACH_IMM_USE_STMT (use_stmt, ui, name) - { - if (!is_gimple_assign (use_stmt)) - continue; + /* Make sure the default label is first in a group. */ + if (!CASE_LOW (ci1->expr)) + return -1; + else if (!CASE_LOW (ci2->expr)) + return 1; + else + return tree_int_cst_compare (CASE_LOW (ci1->expr), + CASE_LOW (ci2->expr)); + } + else + return 1; +} - /* Cut off to use-stmts that are dominating the predecessor. */ - if (!dominated_by_p (CDI_DOMINATORS, e->src, gimple_bb (use_stmt))) - continue; +/* Determine whether the outgoing edges of BB should receive an + ASSERT_EXPR for each of the operands of BB's LAST statement. + The last statement of BB must be a SWITCH_EXPR. - tree name2 = gimple_assign_lhs (use_stmt); - if (TREE_CODE (name2) != SSA_NAME) - continue; + 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 + list of assertions for the corresponding operands. */ - enum tree_code code = gimple_assign_rhs_code (use_stmt); - tree cst; - if (code == PLUS_EXPR - || code == MINUS_EXPR) - { - cst = gimple_assign_rhs2 (use_stmt); - if (TREE_CODE (cst) != INTEGER_CST) - continue; - cst = int_const_binop (code, val, cst); - } - else if (CONVERT_EXPR_CODE_P (code)) - { - /* For truncating conversions we cannot record - an inequality. */ - if (comp_code == NE_EXPR - && (TYPE_PRECISION (TREE_TYPE (name2)) - < TYPE_PRECISION (TREE_TYPE (name)))) - continue; - cst = fold_convert (TREE_TYPE (name2), val); - } - else - continue; +static void +find_switch_asserts (basic_block bb, gswitch *last) +{ + gimple_stmt_iterator bsi; + tree op; + edge e; + struct case_info *ci; + size_t n = gimple_switch_num_labels (last); +#if GCC_VERSION >= 4000 + unsigned int idx; +#else + /* Work around GCC 3.4 bug (PR 37086). */ + volatile unsigned int idx; +#endif - if (TREE_OVERFLOW_P (cst)) - cst = drop_tree_overflow (cst); - add_assert_info (asserts, name2, name2, comp_code, cst); - } + bsi = gsi_for_stmt (last); + op = gimple_switch_index (last); + if (TREE_CODE (op) != SSA_NAME) + return; + + /* Build a vector of case labels sorted by destination label. */ + ci = XNEWVEC (struct case_info, n); + for (idx = 0; idx < n; ++idx) + { + ci[idx].expr = gimple_switch_label (last, idx); + ci[idx].bb = label_to_block (CASE_LABEL (ci[idx].expr)); } - - if (TREE_CODE_CLASS (comp_code) == tcc_comparison - && TREE_CODE (val) == INTEGER_CST) + edge default_edge = find_edge (bb, ci[0].bb); + qsort (ci, n, sizeof (struct case_info), compare_case_labels); + + for (idx = 0; idx < n; ++idx) { - gimple *def_stmt = SSA_NAME_DEF_STMT (name); - tree name2 = NULL_TREE, names[2], cst2 = NULL_TREE; - tree val2 = NULL_TREE; - unsigned int prec = TYPE_PRECISION (TREE_TYPE (val)); - wide_int mask = wi::zero (prec); - unsigned int nprec = prec; - enum tree_code rhs_code = ERROR_MARK; + tree min, max; + tree cl = ci[idx].expr; + basic_block cbb = ci[idx].bb; - if (is_gimple_assign (def_stmt)) - rhs_code = gimple_assign_rhs_code (def_stmt); + min = CASE_LOW (cl); + max = CASE_HIGH (cl); - /* In the case of NAME != CST1 where NAME = A +- CST2 we can - assert that A != CST1 -+ CST2. */ - if ((comp_code == EQ_EXPR || comp_code == NE_EXPR) - && (rhs_code == PLUS_EXPR || rhs_code == MINUS_EXPR)) + /* If there are multiple case labels with the same destination + we need to combine them to a single value range for the edge. */ + if (idx + 1 < n && cbb == ci[idx + 1].bb) { - tree op0 = gimple_assign_rhs1 (def_stmt); - tree op1 = gimple_assign_rhs2 (def_stmt); - if (TREE_CODE (op0) == SSA_NAME - && TREE_CODE (op1) == INTEGER_CST) - { - enum tree_code reverse_op = (rhs_code == PLUS_EXPR - ? MINUS_EXPR : PLUS_EXPR); - op1 = int_const_binop (reverse_op, val, op1); - if (TREE_OVERFLOW (op1)) - op1 = drop_tree_overflow (op1); - add_assert_info (asserts, op0, op0, comp_code, op1); - } - } - - /* Add asserts for NAME cmp CST and NAME being defined - as NAME = (int) NAME2. */ - if (!TYPE_UNSIGNED (TREE_TYPE (val)) - && (comp_code == LE_EXPR || comp_code == LT_EXPR - || comp_code == GT_EXPR || comp_code == GE_EXPR) - && gimple_assign_cast_p (def_stmt)) - { - name2 = gimple_assign_rhs1 (def_stmt); - if (CONVERT_EXPR_CODE_P (rhs_code) - && INTEGRAL_TYPE_P (TREE_TYPE (name2)) - && TYPE_UNSIGNED (TREE_TYPE (name2)) - && prec == TYPE_PRECISION (TREE_TYPE (name2)) - && (comp_code == LE_EXPR || comp_code == GT_EXPR - || !tree_int_cst_equal (val, - TYPE_MIN_VALUE (TREE_TYPE (val))))) - { - tree tmp, cst; - enum tree_code new_comp_code = comp_code; - - cst = fold_convert (TREE_TYPE (name2), - TYPE_MIN_VALUE (TREE_TYPE (val))); - /* Build an expression for the range test. */ - tmp = build2 (PLUS_EXPR, TREE_TYPE (name2), name2, cst); - cst = fold_build2 (PLUS_EXPR, TREE_TYPE (name2), cst, - fold_convert (TREE_TYPE (name2), val)); - if (comp_code == LT_EXPR || comp_code == GE_EXPR) - { - new_comp_code = comp_code == LT_EXPR ? LE_EXPR : GT_EXPR; - cst = fold_build2 (MINUS_EXPR, TREE_TYPE (name2), cst, - build_int_cst (TREE_TYPE (name2), 1)); - } - - if (dump_file) - { - fprintf (dump_file, "Adding assert for "); - print_generic_expr (dump_file, name2); - fprintf (dump_file, " from "); - print_generic_expr (dump_file, tmp); - fprintf (dump_file, "\n"); - } + /* Skip labels until the last of the group. */ + do { + ++idx; + } while (idx < n && cbb == ci[idx].bb); + --idx; - add_assert_info (asserts, name2, tmp, new_comp_code, cst); - } + /* Pick up the maximum of the case label range. */ + if (CASE_HIGH (ci[idx].expr)) + max = CASE_HIGH (ci[idx].expr); + else + max = CASE_LOW (ci[idx].expr); } - /* Add asserts for NAME cmp CST and NAME being defined as - NAME = NAME2 >> CST2. + /* Can't extract a useful assertion out of a range that includes the + default label. */ + if (min == NULL_TREE) + continue; - Extract CST2 from the right shift. */ - if (rhs_code == RSHIFT_EXPR) - { - name2 = gimple_assign_rhs1 (def_stmt); - cst2 = gimple_assign_rhs2 (def_stmt); - if (TREE_CODE (name2) == SSA_NAME - && tree_fits_uhwi_p (cst2) - && INTEGRAL_TYPE_P (TREE_TYPE (name2)) - && IN_RANGE (tree_to_uhwi (cst2), 1, prec - 1) - && type_has_mode_precision_p (TREE_TYPE (val))) - { - mask = wi::mask (tree_to_uhwi (cst2), false, prec); - val2 = fold_binary (LSHIFT_EXPR, TREE_TYPE (val), val, cst2); - } - } - if (val2 != NULL_TREE - && TREE_CODE (val2) == INTEGER_CST - && simple_cst_equal (fold_build2 (RSHIFT_EXPR, - TREE_TYPE (val), - val2, cst2), val)) - { - enum tree_code new_comp_code = comp_code; - tree tmp, new_val; + /* Find the edge to register the assert expr on. */ + e = find_edge (bb, cbb); - tmp = name2; - if (comp_code == EQ_EXPR || comp_code == NE_EXPR) - { - if (!TYPE_UNSIGNED (TREE_TYPE (val))) - { - tree type = build_nonstandard_integer_type (prec, 1); - tmp = build1 (NOP_EXPR, type, name2); - val2 = fold_convert (type, val2); - } - tmp = fold_build2 (MINUS_EXPR, TREE_TYPE (tmp), tmp, val2); - new_val = wide_int_to_tree (TREE_TYPE (tmp), mask); - new_comp_code = comp_code == EQ_EXPR ? LE_EXPR : GT_EXPR; - } - else if (comp_code == LT_EXPR || comp_code == GE_EXPR) - { - wide_int minval - = wi::min_value (prec, TYPE_SIGN (TREE_TYPE (val))); - new_val = val2; - if (minval == wi::to_wide (new_val)) - new_val = NULL_TREE; - } - else - { - wide_int maxval - = wi::max_value (prec, TYPE_SIGN (TREE_TYPE (val))); - mask |= wi::to_wide (val2); - if (wi::eq_p (mask, maxval)) - new_val = NULL_TREE; - else - new_val = wide_int_to_tree (TREE_TYPE (val2), mask); - } + /* Register the necessary assertions for the operand in the + SWITCH_EXPR. */ + auto_vec asserts; + register_edge_assert_for (op, e, + max ? GE_EXPR : EQ_EXPR, + op, fold_convert (TREE_TYPE (op), min), + asserts); + if (max) + register_edge_assert_for (op, e, LE_EXPR, op, + fold_convert (TREE_TYPE (op), max), + asserts); + finish_register_edge_assert_for (e, bsi, asserts); + } - if (new_val) - { - if (dump_file) - { - fprintf (dump_file, "Adding assert for "); - print_generic_expr (dump_file, name2); - fprintf (dump_file, " from "); - print_generic_expr (dump_file, tmp); - fprintf (dump_file, "\n"); - } + XDELETEVEC (ci); - add_assert_info (asserts, name2, tmp, new_comp_code, new_val); - } - } + if (!live_on_edge (default_edge, op)) + return; - /* Add asserts for NAME cmp CST and NAME being defined as - NAME = NAME2 & CST2. + /* Now register along the default label assertions that correspond to the + anti-range of each label. */ + int insertion_limit = PARAM_VALUE (PARAM_MAX_VRP_SWITCH_ASSERTIONS); + if (insertion_limit == 0) + return; - Extract CST2 from the and. + /* We can't do this if the default case shares a label with another case. */ + tree default_cl = gimple_switch_default_label (last); + for (idx = 1; idx < n; idx++) + { + tree min, max; + tree cl = gimple_switch_label (last, idx); + if (CASE_LABEL (cl) == CASE_LABEL (default_cl)) + continue; - Also handle - NAME = (unsigned) NAME2; - casts where NAME's type is unsigned and has smaller precision - than NAME2's type as if it was NAME = NAME2 & MASK. */ - names[0] = NULL_TREE; - names[1] = NULL_TREE; - cst2 = NULL_TREE; - if (rhs_code == BIT_AND_EXPR - || (CONVERT_EXPR_CODE_P (rhs_code) - && INTEGRAL_TYPE_P (TREE_TYPE (val)) - && TYPE_UNSIGNED (TREE_TYPE (val)) - && TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt))) - > prec)) + min = CASE_LOW (cl); + max = CASE_HIGH (cl); + + /* Combine contiguous case ranges to reduce the number of assertions + to insert. */ + for (idx = idx + 1; idx < n; idx++) { - name2 = gimple_assign_rhs1 (def_stmt); - if (rhs_code == BIT_AND_EXPR) - cst2 = gimple_assign_rhs2 (def_stmt); + tree next_min, next_max; + tree next_cl = gimple_switch_label (last, idx); + if (CASE_LABEL (next_cl) == CASE_LABEL (default_cl)) + break; + + next_min = CASE_LOW (next_cl); + next_max = CASE_HIGH (next_cl); + + wide_int difference = (wi::to_wide (next_min) + - wi::to_wide (max ? max : min)); + if (wi::eq_p (difference, 1)) + max = next_max ? next_max : next_min; else - { - cst2 = TYPE_MAX_VALUE (TREE_TYPE (val)); - nprec = TYPE_PRECISION (TREE_TYPE (name2)); - } - if (TREE_CODE (name2) == SSA_NAME - && INTEGRAL_TYPE_P (TREE_TYPE (name2)) - && TREE_CODE (cst2) == INTEGER_CST - && !integer_zerop (cst2) - && (nprec > 1 - || TYPE_UNSIGNED (TREE_TYPE (val)))) - { - gimple *def_stmt2 = SSA_NAME_DEF_STMT (name2); - if (gimple_assign_cast_p (def_stmt2)) - { - names[1] = gimple_assign_rhs1 (def_stmt2); - if (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt2)) - || !INTEGRAL_TYPE_P (TREE_TYPE (names[1])) - || (TYPE_PRECISION (TREE_TYPE (name2)) - != TYPE_PRECISION (TREE_TYPE (names[1])))) - names[1] = NULL_TREE; - } - names[0] = name2; - } + break; } - if (names[0] || names[1]) + idx--; + + if (max == NULL_TREE) { - wide_int minv, maxv, valv, cst2v; - wide_int tem, sgnbit; - bool valid_p = false, valn, cst2n; - enum tree_code ccode = comp_code; + /* Register the assertion OP != MIN. */ + auto_vec asserts; + min = fold_convert (TREE_TYPE (op), min); + register_edge_assert_for (op, default_edge, NE_EXPR, op, min, + asserts); + finish_register_edge_assert_for (default_edge, bsi, asserts); + } + else + { + /* Register the assertion (unsigned)OP - MIN > (MAX - MIN), + which will give OP the anti-range ~[MIN,MAX]. */ + tree uop = fold_convert (unsigned_type_for (TREE_TYPE (op)), op); + min = fold_convert (TREE_TYPE (uop), min); + max = fold_convert (TREE_TYPE (uop), max); - valv = wide_int::from (wi::to_wide (val), nprec, UNSIGNED); - cst2v = wide_int::from (wi::to_wide (cst2), nprec, UNSIGNED); - valn = wi::neg_p (valv, TYPE_SIGN (TREE_TYPE (val))); - cst2n = wi::neg_p (cst2v, TYPE_SIGN (TREE_TYPE (val))); - /* If CST2 doesn't have most significant bit set, - but VAL is negative, we have comparison like - if ((x & 0x123) > -4) (always true). Just give up. */ - if (!cst2n && valn) - ccode = ERROR_MARK; - if (cst2n) - sgnbit = wi::set_bit_in_zero (nprec - 1, nprec); - else - sgnbit = wi::zero (nprec); - minv = valv & cst2v; - switch (ccode) - { - case EQ_EXPR: - /* Minimum unsigned value for equality is VAL & CST2 - (should be equal to VAL, otherwise we probably should - have folded the comparison into false) and - maximum unsigned value is VAL | ~CST2. */ - maxv = valv | ~cst2v; - valid_p = true; - break; + tree lhs = fold_build2 (MINUS_EXPR, TREE_TYPE (uop), uop, min); + tree rhs = int_const_binop (MINUS_EXPR, max, min); + register_new_assert_for (op, lhs, GT_EXPR, rhs, + NULL, default_edge, bsi); + } - case NE_EXPR: - tem = valv | ~cst2v; - /* If VAL is 0, handle (X & CST2) != 0 as (X & CST2) > 0U. */ - if (valv == 0) - { - cst2n = false; - sgnbit = wi::zero (nprec); - goto gt_expr; - } - /* If (VAL | ~CST2) is all ones, handle it as - (X & CST2) < VAL. */ - if (tem == -1) - { - cst2n = false; - valn = false; - sgnbit = wi::zero (nprec); - goto lt_expr; - } - if (!cst2n && wi::neg_p (cst2v)) - sgnbit = wi::set_bit_in_zero (nprec - 1, nprec); - if (sgnbit != 0) - { - if (valv == sgnbit) - { - cst2n = true; - valn = true; - goto gt_expr; - } - if (tem == wi::mask (nprec - 1, false, nprec)) - { - cst2n = true; - goto lt_expr; - } - if (!cst2n) - sgnbit = wi::zero (nprec); - } - break; + if (--insertion_limit == 0) + break; + } +} - case GE_EXPR: - /* Minimum unsigned value for >= if (VAL & CST2) == VAL - is VAL and maximum unsigned value is ~0. For signed - comparison, if CST2 doesn't have most significant bit - set, handle it similarly. If CST2 has MSB set, - the minimum is the same, and maximum is ~0U/2. */ - if (minv != valv) - { - /* If (VAL & CST2) != VAL, X & CST2 can't be equal to - VAL. */ - minv = masked_increment (valv, cst2v, sgnbit, nprec); - if (minv == valv) - break; - } - maxv = wi::mask (nprec - (cst2n ? 1 : 0), false, nprec); - valid_p = true; - break; - case GT_EXPR: - gt_expr: - /* Find out smallest MINV where MINV > VAL - && (MINV & CST2) == MINV, if any. If VAL is signed and - CST2 has MSB set, compute it biased by 1 << (nprec - 1). */ - minv = masked_increment (valv, cst2v, sgnbit, nprec); - if (minv == valv) - break; - maxv = wi::mask (nprec - (cst2n ? 1 : 0), false, nprec); - valid_p = true; - break; +/* Traverse all the statements in block BB looking for statements that + 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 + list of assertions already generated for N_i is scanned to + determine if A is actually needed. - case LE_EXPR: - /* Minimum unsigned value for <= is 0 and maximum - unsigned value is VAL | ~CST2 if (VAL & CST2) == VAL. - Otherwise, find smallest VAL2 where VAL2 > VAL - && (VAL2 & CST2) == VAL2 and use (VAL2 - 1) | ~CST2 - as maximum. - For signed comparison, if CST2 doesn't have most - significant bit set, handle it similarly. If CST2 has - MSB set, the maximum is the same and minimum is INT_MIN. */ - if (minv == valv) - maxv = valv; - else - { - maxv = masked_increment (valv, cst2v, sgnbit, nprec); - if (maxv == valv) - break; - maxv -= 1; - } - maxv |= ~cst2v; - minv = sgnbit; - valid_p = true; - break; + If N_i already had the assertion A at a location dominating the + current location, then nothing needs to be done. Otherwise, the + new location for A is recorded instead. - case LT_EXPR: - lt_expr: - /* Minimum unsigned value for < is 0 and maximum - unsigned value is (VAL-1) | ~CST2 if (VAL & CST2) == VAL. - Otherwise, find smallest VAL2 where VAL2 > VAL - && (VAL2 & CST2) == VAL2 and use (VAL2 - 1) | ~CST2 - as maximum. - For signed comparison, if CST2 doesn't have most - significant bit set, handle it similarly. If CST2 has - MSB set, the maximum is the same and minimum is INT_MIN. */ - if (minv == valv) - { - if (valv == sgnbit) - break; - maxv = valv; - } - else - { - maxv = masked_increment (valv, cst2v, sgnbit, nprec); - if (maxv == valv) - break; - } - maxv -= 1; - maxv |= ~cst2v; - minv = sgnbit; - valid_p = true; - break; + 1- For every statement S in BB, all the variables used by S are + added to bitmap FOUND_IN_SUBGRAPH. - default: - break; - } - if (valid_p - && (maxv - minv) != -1) - { - tree tmp, new_val, type; - int i; + 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 + ASSERT_EXPR, create a new assert location for N. For instance, + if N is a pointer and the statement dereferences it, we can + assume that N is not NULL. - for (i = 0; i < 2; i++) - if (names[i]) - { - wide_int maxv2 = maxv; - tmp = names[i]; - type = TREE_TYPE (names[i]); - if (!TYPE_UNSIGNED (type)) - { - type = build_nonstandard_integer_type (nprec, 1); - tmp = build1 (NOP_EXPR, type, names[i]); - } - if (minv != 0) - { - tmp = build2 (PLUS_EXPR, type, tmp, - wide_int_to_tree (type, -minv)); - maxv2 = maxv - minv; - } - new_val = wide_int_to_tree (type, maxv2); + 3- COND_EXPRs are a special case of #2. We can derive range + information from the predicate but need to insert different + ASSERT_EXPRs for each of the sub-graphs rooted at the + conditional block. If the last statement of BB is a conditional + expression of the form 'X op Y', then - if (dump_file) - { - fprintf (dump_file, "Adding assert for "); - print_generic_expr (dump_file, names[i]); - fprintf (dump_file, " from "); - print_generic_expr (dump_file, tmp); - fprintf (dump_file, "\n"); - } + a) Remove X and Y from the set FOUND_IN_SUBGRAPH. - add_assert_info (asserts, names[i], tmp, LE_EXPR, new_val); - } - } - } - } -} + b) If the conditional is the only entry point to the sub-graph + corresponding to the THEN_CLAUSE, recurse into it. On + return, if X and/or Y are marked in FOUND_IN_SUBGRAPH, then + an ASSERT_EXPR is added for the corresponding variable. -/* OP is an operand of a truth value expression which is known to have - a particular value. Register any asserts for OP and for any - operands in OP's defining statement. + c) Repeat step (b) on the ELSE_CLAUSE. - If CODE is EQ_EXPR, then we want to register OP is zero (false), - if CODE is NE_EXPR, then we want to register OP is nonzero (true). */ + d) Mark X and Y in FOUND_IN_SUBGRAPH. -static void -register_edge_assert_for_1 (tree op, enum tree_code code, - edge e, vec &asserts) -{ - gimple *op_def; - tree val; - enum tree_code rhs_code; + For instance, - /* We only care about SSA_NAMEs. */ - if (TREE_CODE (op) != SSA_NAME) - return; + if (a == 9) + b = a; + else + b = c + 1; - /* We know that OP will have a zero or nonzero value. */ - val = build_int_cst (TREE_TYPE (op), 0); - add_assert_info (asserts, op, op, code, val); + In this case, an assertion on the THEN clause is useful to + determine that 'a' is always 9 on that edge. However, an assertion + on the ELSE clause would be unnecessary. - /* Now look at how OP is set. If it's set from a comparison, - a truth operation or some bit operations, then we may be able - to register information about the operands of that assignment. */ - op_def = SSA_NAME_DEF_STMT (op); - if (gimple_code (op_def) != GIMPLE_ASSIGN) - return; + 4- If BB does not end in a conditional expression, then we recurse + into BB's dominator children. - rhs_code = gimple_assign_rhs_code (op_def); + 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 + location for name N is found, it is registered by calling + register_new_assert_for. That function keeps track of all the + registered assertions to prevent adding unnecessary assertions. + For instance, if a pointer P_4 is dereferenced more than once in a + dominator tree, only the location dominating all the dereference of + P_4 will receive an ASSERT_EXPR. */ - if (TREE_CODE_CLASS (rhs_code) == tcc_comparison) - { - bool invert = (code == EQ_EXPR ? true : false); - tree op0 = gimple_assign_rhs1 (op_def); - tree op1 = gimple_assign_rhs2 (op_def); +static void +find_assert_locations_1 (basic_block bb, sbitmap live) +{ + gimple *last; - if (TREE_CODE (op0) == SSA_NAME) - register_edge_assert_for_2 (op0, e, rhs_code, op0, op1, invert, asserts); - if (TREE_CODE (op1) == SSA_NAME) - register_edge_assert_for_2 (op1, e, rhs_code, op0, op1, invert, asserts); - } - else if ((code == NE_EXPR - && gimple_assign_rhs_code (op_def) == BIT_AND_EXPR) - || (code == EQ_EXPR - && gimple_assign_rhs_code (op_def) == BIT_IOR_EXPR)) - { - /* Recurse on each operand. */ - tree op0 = gimple_assign_rhs1 (op_def); - tree op1 = gimple_assign_rhs2 (op_def); - if (TREE_CODE (op0) == SSA_NAME - && has_single_use (op0)) - register_edge_assert_for_1 (op0, code, e, asserts); - if (TREE_CODE (op1) == SSA_NAME - && has_single_use (op1)) - register_edge_assert_for_1 (op1, code, e, asserts); - } - else if (gimple_assign_rhs_code (op_def) == BIT_NOT_EXPR - && TYPE_PRECISION (TREE_TYPE (gimple_assign_lhs (op_def))) == 1) - { - /* Recurse, flipping CODE. */ - code = invert_tree_comparison (code, false); - register_edge_assert_for_1 (gimple_assign_rhs1 (op_def), code, e, asserts); - } - else if (gimple_assign_rhs_code (op_def) == SSA_NAME) - { - /* Recurse through the copy. */ - register_edge_assert_for_1 (gimple_assign_rhs1 (op_def), code, e, asserts); - } - else if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (op_def))) + last = last_stmt (bb); + + /* If BB's last statement is a conditional statement involving integer + operands, determine if we need to add ASSERT_EXPRs. */ + if (last + && gimple_code (last) == GIMPLE_COND + && !fp_predicate (last) + && !ZERO_SSA_OPERANDS (last, SSA_OP_USE)) + find_conditional_asserts (bb, as_a (last)); + + /* If BB's last statement is a switch statement involving integer + operands, determine if we need to add ASSERT_EXPRs. */ + if (last + && gimple_code (last) == GIMPLE_SWITCH + && !ZERO_SSA_OPERANDS (last, SSA_OP_USE)) + find_switch_asserts (bb, as_a (last)); + + /* Traverse all the statements in BB marking used names and looking + for statements that may infer assertions for their used operands. */ + for (gimple_stmt_iterator si = gsi_last_bb (bb); !gsi_end_p (si); + gsi_prev (&si)) { - /* Recurse through the type conversion, unless it is a narrowing - conversion or conversion from non-integral type. */ - tree rhs = gimple_assign_rhs1 (op_def); - if (INTEGRAL_TYPE_P (TREE_TYPE (rhs)) - && (TYPE_PRECISION (TREE_TYPE (rhs)) - <= TYPE_PRECISION (TREE_TYPE (op)))) - register_edge_assert_for_1 (rhs, code, e, asserts); - } -} + gimple *stmt; + tree op; + ssa_op_iter i; -/* Check if comparison - NAME COND_OP INTEGER_CST - has a form of - (X & 11...100..0) COND_OP XX...X00...0 - Such comparison can yield assertions like - X >= XX...X00...0 - X <= XX...X11...1 - in case of COND_OP being NE_EXPR or - X < XX...X00...0 - X > XX...X11...1 - in case of EQ_EXPR. */ + stmt = gsi_stmt (si); -static bool -is_masked_range_test (tree name, tree valt, enum tree_code cond_code, - tree *new_name, tree *low, enum tree_code *low_code, - tree *high, enum tree_code *high_code) -{ - gimple *def_stmt = SSA_NAME_DEF_STMT (name); + if (is_gimple_debug (stmt)) + continue; - if (!is_gimple_assign (def_stmt) - || gimple_assign_rhs_code (def_stmt) != BIT_AND_EXPR) - return false; + /* See if we can derive an assertion for any of STMT's operands. */ + FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE) + { + tree value; + enum tree_code comp_code; - tree t = gimple_assign_rhs1 (def_stmt); - tree maskt = gimple_assign_rhs2 (def_stmt); - if (TREE_CODE (t) != SSA_NAME || TREE_CODE (maskt) != INTEGER_CST) - return false; + /* If op is not live beyond this stmt, do not bother to insert + asserts for it. */ + if (!bitmap_bit_p (live, SSA_NAME_VERSION (op))) + continue; - wi::tree_to_wide_ref mask = wi::to_wide (maskt); - wide_int inv_mask = ~mask; - /* Assume VALT is INTEGER_CST. */ - wi::tree_to_wide_ref val = wi::to_wide (valt); + /* 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 + it, create a new assertion location node for OP. */ + if (infer_value_range (stmt, op, &comp_code, &value)) + { + /* If we are able to infer a nonzero value range for OP, + then walk backwards through the use-def chain to see if OP + was set via a typecast. - if ((inv_mask & (inv_mask + 1)) != 0 - || (val & mask) != val) - return false; + If so, then we can also infer a nonzero value range + for the operand of the NOP_EXPR. */ + if (comp_code == NE_EXPR && integer_zerop (value)) + { + tree t = op; + gimple *def_stmt = SSA_NAME_DEF_STMT (t); - bool is_range = cond_code == EQ_EXPR; + while (is_gimple_assign (def_stmt) + && CONVERT_EXPR_CODE_P + (gimple_assign_rhs_code (def_stmt)) + && TREE_CODE + (gimple_assign_rhs1 (def_stmt)) == SSA_NAME + && POINTER_TYPE_P + (TREE_TYPE (gimple_assign_rhs1 (def_stmt)))) + { + t = gimple_assign_rhs1 (def_stmt); + def_stmt = SSA_NAME_DEF_STMT (t); - tree type = TREE_TYPE (t); - wide_int min = wi::min_value (type), - max = wi::max_value (type); + /* Note we want to register the assert for the + operand of the NOP_EXPR after SI, not after the + conversion. */ + if (bitmap_bit_p (live, SSA_NAME_VERSION (t))) + register_new_assert_for (t, t, comp_code, value, + bb, NULL, si); + } + } - if (is_range) - { - *low_code = val == min ? ERROR_MARK : GE_EXPR; - *high_code = val == max ? ERROR_MARK : LE_EXPR; - } - else - { - /* We can still generate assertion if one of alternatives - is known to always be false. */ - if (val == min) - { - *low_code = (enum tree_code) 0; - *high_code = GT_EXPR; - } - else if ((val | inv_mask) == max) - { - *low_code = LT_EXPR; - *high_code = (enum tree_code) 0; + register_new_assert_for (op, op, comp_code, value, bb, NULL, si); + } } - else - return false; + + /* Update live. */ + FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE) + bitmap_set_bit (live, SSA_NAME_VERSION (op)); + FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_DEF) + bitmap_clear_bit (live, SSA_NAME_VERSION (op)); } - *new_name = t; - *low = wide_int_to_tree (type, val); - *high = wide_int_to_tree (type, val | inv_mask); + /* Traverse all PHI nodes in BB, updating live. */ + for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si); + gsi_next (&si)) + { + use_operand_p arg_p; + ssa_op_iter i; + gphi *phi = si.phi (); + tree res = gimple_phi_result (phi); - if (wi::neg_p (val, TYPE_SIGN (type))) - std::swap (*low, *high); + if (virtual_operand_p (res)) + continue; - return true; + FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_USE) + { + tree arg = USE_FROM_PTR (arg_p); + if (TREE_CODE (arg) == SSA_NAME) + bitmap_set_bit (live, SSA_NAME_VERSION (arg)); + } + + bitmap_clear_bit (live, SSA_NAME_VERSION (res)); + } } -/* Try to register an edge assertion for SSA name NAME on edge E for - the condition COND contributing to the conditional jump pointed to by - SI. */ +/* Do an RPO walk over the function computing SSA name liveness + on-the-fly and deciding on assert expressions to insert. */ -void -register_edge_assert_for (tree name, edge e, - enum tree_code cond_code, tree cond_op0, - tree cond_op1, vec &asserts) +static void +find_assert_locations (void) { - tree val; - enum tree_code comp_code; - bool is_else_edge = (e->flags & EDGE_FALSE_VALUE) != 0; - - /* Do not attempt to infer anything in names that flow through - abnormal edges. */ - if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name)) - return; - - if (!extract_code_and_val_from_cond_with_ops (name, cond_code, - cond_op0, cond_op1, - is_else_edge, - &comp_code, &val)) - return; - - /* Register ASSERT_EXPRs for name. */ - register_edge_assert_for_2 (name, e, cond_code, cond_op0, - cond_op1, is_else_edge, asserts); - + int *rpo = XNEWVEC (int, last_basic_block_for_fn (cfun)); + int *bb_rpo = XNEWVEC (int, last_basic_block_for_fn (cfun)); + int *last_rpo = XCNEWVEC (int, last_basic_block_for_fn (cfun)); + int rpo_cnt, i; - /* If COND is effectively an equality test of an SSA_NAME against - the value zero or one, then we may be able to assert values - for SSA_NAMEs which flow into COND. */ + live = XCNEWVEC (sbitmap, last_basic_block_for_fn (cfun)); + rpo_cnt = pre_and_rev_post_order_compute (NULL, rpo, false); + for (i = 0; i < rpo_cnt; ++i) + bb_rpo[rpo[i]] = i; - /* In the case of NAME == 1 or NAME != 0, for BIT_AND_EXPR defining - statement of NAME we can assert both operands of the BIT_AND_EXPR - have nonzero value. */ - if (((comp_code == EQ_EXPR && integer_onep (val)) - || (comp_code == NE_EXPR && integer_zerop (val)))) + /* Pre-seed loop latch liveness from loop header PHI nodes. Due to + the order we compute liveness and insert asserts we otherwise + fail to insert asserts into the loop latch. */ + loop_p loop; + FOR_EACH_LOOP (loop, 0) { - gimple *def_stmt = SSA_NAME_DEF_STMT (name); - - if (is_gimple_assign (def_stmt) - && gimple_assign_rhs_code (def_stmt) == BIT_AND_EXPR) + i = loop->latch->index; + unsigned int j = single_succ_edge (loop->latch)->dest_idx; + for (gphi_iterator gsi = gsi_start_phis (loop->header); + !gsi_end_p (gsi); gsi_next (&gsi)) { - tree op0 = gimple_assign_rhs1 (def_stmt); - tree op1 = gimple_assign_rhs2 (def_stmt); - register_edge_assert_for_1 (op0, NE_EXPR, e, asserts); - register_edge_assert_for_1 (op1, NE_EXPR, e, asserts); - } - } + gphi *phi = gsi.phi (); + if (virtual_operand_p (gimple_phi_result (phi))) + continue; + tree arg = gimple_phi_arg_def (phi, j); + if (TREE_CODE (arg) == SSA_NAME) + { + if (live[i] == NULL) + { + live[i] = sbitmap_alloc (num_ssa_names); + bitmap_clear (live[i]); + } + bitmap_set_bit (live[i], SSA_NAME_VERSION (arg)); + } + } + } - /* In the case of NAME == 0 or NAME != 1, for BIT_IOR_EXPR defining - statement of NAME we can assert both operands of the BIT_IOR_EXPR - have zero value. */ - if (((comp_code == EQ_EXPR && integer_zerop (val)) - || (comp_code == NE_EXPR && integer_onep (val)))) + for (i = rpo_cnt - 1; i >= 0; --i) { - gimple *def_stmt = SSA_NAME_DEF_STMT (name); + basic_block bb = BASIC_BLOCK_FOR_FN (cfun, rpo[i]); + edge e; + edge_iterator ei; - /* For BIT_IOR_EXPR only if NAME == 0 both operands have - necessarily zero value, or if type-precision is one. */ - if (is_gimple_assign (def_stmt) - && (gimple_assign_rhs_code (def_stmt) == BIT_IOR_EXPR - && (TYPE_PRECISION (TREE_TYPE (name)) == 1 - || comp_code == EQ_EXPR))) + if (!live[rpo[i]]) { - tree op0 = gimple_assign_rhs1 (def_stmt); - tree op1 = gimple_assign_rhs2 (def_stmt); - register_edge_assert_for_1 (op0, EQ_EXPR, e, asserts); - register_edge_assert_for_1 (op1, EQ_EXPR, e, asserts); + live[rpo[i]] = sbitmap_alloc (num_ssa_names); + bitmap_clear (live[rpo[i]]); } - } - /* Sometimes we can infer ranges from (NAME & MASK) == VALUE. */ - if ((comp_code == EQ_EXPR || comp_code == NE_EXPR) - && TREE_CODE (val) == INTEGER_CST) - { - enum tree_code low_code, high_code; - tree low, high; - if (is_masked_range_test (name, val, comp_code, &name, &low, - &low_code, &high, &high_code)) + /* Process BB and update the live information with uses in + this block. */ + find_assert_locations_1 (bb, live[rpo[i]]); + + /* Merge liveness into the predecessor blocks and free it. */ + if (!bitmap_empty_p (live[rpo[i]])) { - if (low_code != ERROR_MARK) - register_edge_assert_for_2 (name, e, low_code, name, - low, /*invert*/false, asserts); - if (high_code != ERROR_MARK) - register_edge_assert_for_2 (name, e, high_code, name, - high, /*invert*/false, asserts); - } - } -} + int pred_rpo = i; + FOR_EACH_EDGE (e, ei, bb->preds) + { + int pred = e->src->index; + if ((e->flags & EDGE_DFS_BACK) || pred == ENTRY_BLOCK) + continue; -/* Finish found ASSERTS for E and register them at GSI. */ + if (!live[pred]) + { + live[pred] = sbitmap_alloc (num_ssa_names); + bitmap_clear (live[pred]); + } + bitmap_ior (live[pred], live[pred], live[rpo[i]]); -static void -finish_register_edge_assert_for (edge e, gimple_stmt_iterator gsi, - vec &asserts) -{ - for (unsigned i = 0; i < asserts.length (); ++i) - /* Only register an ASSERT_EXPR if NAME was found in the sub-graph - reachable from E. */ - if (live_on_edge (e, asserts[i].name)) - register_new_assert_for (asserts[i].name, asserts[i].expr, - asserts[i].comp_code, asserts[i].val, - NULL, e, gsi); -} + if (bb_rpo[pred] < pred_rpo) + pred_rpo = bb_rpo[pred]; + } + /* Record the RPO number of the last visited block that needs + live information from this block. */ + last_rpo[rpo[i]] = pred_rpo; + } + else + { + sbitmap_free (live[rpo[i]]); + live[rpo[i]] = NULL; + } + /* We can free all successors live bitmaps if all their + predecessors have been visited already. */ + FOR_EACH_EDGE (e, ei, bb->succs) + if (last_rpo[e->dest->index] == i + && live[e->dest->index]) + { + sbitmap_free (live[e->dest->index]); + live[e->dest->index] = NULL; + } + } -/* Determine whether the outgoing edges of BB should receive an - ASSERT_EXPR for each of the operands of BB's LAST statement. - The last statement of BB must be a COND_EXPR. + XDELETEVEC (rpo); + XDELETEVEC (bb_rpo); + XDELETEVEC (last_rpo); + for (i = 0; i < last_basic_block_for_fn (cfun); ++i) + if (live[i]) + sbitmap_free (live[i]); + XDELETEVEC (live); +} - 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 - list of assertions for the corresponding operands. */ +/* Create an ASSERT_EXPR for NAME and insert it in the location + indicated by LOC. Return true if we made any edge insertions. */ -static void -find_conditional_asserts (basic_block bb, gcond *last) +static bool +process_assert_insertions_for (tree name, assert_locus *loc) { - gimple_stmt_iterator bsi; - tree op; + /* Build the comparison expression NAME_i COMP_CODE VAL. */ + gimple *stmt; + tree cond; + gimple *assert_stmt; edge_iterator ei; edge e; - ssa_op_iter iter; - bsi = gsi_for_stmt (last); + /* If we have X <=> X do not insert an assert expr for that. */ + if (loc->expr == loc->val) + return false; - /* Look for uses of the operands in each of the sub-graphs - rooted at BB. We need to check each of the outgoing edges - separately, so that we know what kind of ASSERT_EXPR to - insert. */ - FOR_EACH_EDGE (e, ei, bb->succs) + cond = build2 (loc->comp_code, boolean_type_node, loc->expr, loc->val); + assert_stmt = build_assert_expr_for (cond, name); + if (loc->e) { - if (e->dest == bb) - continue; + /* We have been asked to insert the assertion on an edge. This + is used only by COND_EXPR and SWITCH_EXPR assertions. */ + gcc_checking_assert (gimple_code (gsi_stmt (loc->si)) == GIMPLE_COND + || (gimple_code (gsi_stmt (loc->si)) + == GIMPLE_SWITCH)); - /* Register the necessary assertions for each operand in the - conditional predicate. */ - auto_vec asserts; - FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE) - register_edge_assert_for (op, e, - gimple_cond_code (last), - gimple_cond_lhs (last), - gimple_cond_rhs (last), asserts); - finish_register_edge_assert_for (e, bsi, asserts); + gsi_insert_on_edge (loc->e, assert_stmt); + return true; } -} -struct case_info -{ - tree expr; - basic_block bb; -}; + /* If the stmt iterator points at the end then this is an insertion + at the beginning of a block. */ + if (gsi_end_p (loc->si)) + { + gimple_stmt_iterator si = gsi_after_labels (loc->bb); + gsi_insert_before (&si, assert_stmt, GSI_SAME_STMT); + return false; -/* Compare two case labels sorting first by the destination bb index - and then by the case value. */ + } + /* Otherwise, we can insert right after LOC->SI iff the + statement must not be the last statement in the block. */ + stmt = gsi_stmt (loc->si); + if (!stmt_ends_bb_p (stmt)) + { + gsi_insert_after (&loc->si, assert_stmt, GSI_SAME_STMT); + return false; + } + + /* 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 + STMT is not control flow, there may only be one non-abnormal/eh edge + out of BB. */ + FOR_EACH_EDGE (e, ei, loc->bb->succs) + if (!(e->flags & (EDGE_ABNORMAL|EDGE_EH))) + { + gsi_insert_on_edge (e, assert_stmt); + return true; + } + + gcc_unreachable (); +} + +/* Qsort helper for sorting assert locations. If stable is true, don't + use iterative_hash_expr because it can be unstable for -fcompare-debug, + on the other side some pointers might be NULL. */ +template static int -compare_case_labels (const void *p1, const void *p2) +compare_assert_loc (const void *pa, const void *pb) { - const struct case_info *ci1 = (const struct case_info *) p1; - const struct case_info *ci2 = (const struct case_info *) p2; - int idx1 = ci1->bb->index; - int idx2 = ci2->bb->index; + assert_locus * const a = *(assert_locus * const *)pa; + assert_locus * const b = *(assert_locus * const *)pb; - if (idx1 < idx2) - return -1; - else if (idx1 == idx2) + /* If stable, some asserts might be optimized away already, sort + them last. */ + if (stable) { - /* Make sure the default label is first in a group. */ - if (!CASE_LOW (ci1->expr)) + if (a == NULL) + return b != NULL; + else if (b == NULL) return -1; - else if (!CASE_LOW (ci2->expr)) - return 1; - else - return tree_int_cst_compare (CASE_LOW (ci1->expr), - CASE_LOW (ci2->expr)); } - else + + if (a->e == NULL && b->e != NULL) return 1; -} + else if (a->e != NULL && b->e == NULL) + return -1; -/* Determine whether the outgoing edges of BB should receive an - ASSERT_EXPR for each of the operands of BB's LAST statement. - The last statement of BB must be a SWITCH_EXPR. + /* After the above checks, we know that (a->e == NULL) == (b->e == NULL), + no need to test both a->e and b->e. */ - 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 - list of assertions for the corresponding operands. */ + /* Sort after destination index. */ + if (a->e == NULL) + ; + else if (a->e->dest->index > b->e->dest->index) + return 1; + else if (a->e->dest->index < b->e->dest->index) + return -1; -static void -find_switch_asserts (basic_block bb, gswitch *last) -{ - gimple_stmt_iterator bsi; - tree op; - edge e; - struct case_info *ci; - size_t n = gimple_switch_num_labels (last); -#if GCC_VERSION >= 4000 - unsigned int idx; -#else - /* Work around GCC 3.4 bug (PR 37086). */ - volatile unsigned int idx; -#endif + /* Sort after comp_code. */ + if (a->comp_code > b->comp_code) + return 1; + else if (a->comp_code < b->comp_code) + return -1; - bsi = gsi_for_stmt (last); - op = gimple_switch_index (last); - if (TREE_CODE (op) != SSA_NAME) - return; + hashval_t ha, hb; - /* Build a vector of case labels sorted by destination label. */ - ci = XNEWVEC (struct case_info, n); - for (idx = 0; idx < n; ++idx) + /* E.g. if a->val is ADDR_EXPR of a VAR_DECL, iterative_hash_expr + uses DECL_UID of the VAR_DECL, so sorting might differ between + -g and -g0. When doing the removal of redundant assert exprs + and commonization to successors, this does not matter, but for + the final sort needs to be stable. */ + if (stable) { - ci[idx].expr = gimple_switch_label (last, idx); - ci[idx].bb = label_to_block (CASE_LABEL (ci[idx].expr)); + ha = 0; + hb = 0; } - edge default_edge = find_edge (bb, ci[0].bb); - qsort (ci, n, sizeof (struct case_info), compare_case_labels); - - for (idx = 0; idx < n; ++idx) + else { - tree min, max; - tree cl = ci[idx].expr; - basic_block cbb = ci[idx].bb; - - min = CASE_LOW (cl); - max = CASE_HIGH (cl); - - /* If there are multiple case labels with the same destination - we need to combine them to a single value range for the edge. */ - if (idx + 1 < n && cbb == ci[idx + 1].bb) - { - /* Skip labels until the last of the group. */ - do { - ++idx; - } while (idx < n && cbb == ci[idx].bb); - --idx; - - /* Pick up the maximum of the case label range. */ - if (CASE_HIGH (ci[idx].expr)) - max = CASE_HIGH (ci[idx].expr); - else - max = CASE_LOW (ci[idx].expr); - } - - /* Can't extract a useful assertion out of a range that includes the - default label. */ - if (min == NULL_TREE) - continue; - - /* Find the edge to register the assert expr on. */ - e = find_edge (bb, cbb); - - /* Register the necessary assertions for the operand in the - SWITCH_EXPR. */ - auto_vec asserts; - register_edge_assert_for (op, e, - max ? GE_EXPR : EQ_EXPR, - op, fold_convert (TREE_TYPE (op), min), - asserts); - if (max) - register_edge_assert_for (op, e, LE_EXPR, op, - fold_convert (TREE_TYPE (op), max), - asserts); - finish_register_edge_assert_for (e, bsi, asserts); + ha = iterative_hash_expr (a->expr, iterative_hash_expr (a->val, 0)); + hb = iterative_hash_expr (b->expr, iterative_hash_expr (b->val, 0)); } - XDELETEVEC (ci); + /* Break the tie using hashing and source/bb index. */ + if (ha == hb) + return (a->e != NULL + ? a->e->src->index - b->e->src->index + : a->bb->index - b->bb->index); + return ha > hb ? 1 : -1; +} - if (!live_on_edge (default_edge, op)) - return; +/* Process all the insertions registered for every name N_i registered + in NEED_ASSERT_FOR. The list of assertions to be inserted are + found in ASSERTS_FOR[i]. */ - /* Now register along the default label assertions that correspond to the - anti-range of each label. */ - int insertion_limit = PARAM_VALUE (PARAM_MAX_VRP_SWITCH_ASSERTIONS); - if (insertion_limit == 0) - return; +static void +process_assert_insertions (void) +{ + unsigned i; + bitmap_iterator bi; + bool update_edges_p = false; + int num_asserts = 0; - /* We can't do this if the default case shares a label with another case. */ - tree default_cl = gimple_switch_default_label (last); - for (idx = 1; idx < n; idx++) + if (dump_file && (dump_flags & TDF_DETAILS)) + dump_all_asserts (dump_file); + + EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi) { - tree min, max; - tree cl = gimple_switch_label (last, idx); - if (CASE_LABEL (cl) == CASE_LABEL (default_cl)) - continue; + assert_locus *loc = asserts_for[i]; + gcc_assert (loc); - min = CASE_LOW (cl); - max = CASE_HIGH (cl); + auto_vec asserts; + for (; loc; loc = loc->next) + asserts.safe_push (loc); + asserts.qsort (compare_assert_loc); - /* Combine contiguous case ranges to reduce the number of assertions - to insert. */ - for (idx = idx + 1; idx < n; idx++) + /* Push down common asserts to successors and remove redundant ones. */ + unsigned ecnt = 0; + assert_locus *common = NULL; + unsigned commonj = 0; + for (unsigned j = 0; j < asserts.length (); ++j) { - tree next_min, next_max; - tree next_cl = gimple_switch_label (last, idx); - if (CASE_LABEL (next_cl) == CASE_LABEL (default_cl)) - break; - - next_min = CASE_LOW (next_cl); - next_max = CASE_HIGH (next_cl); - - wide_int difference = (wi::to_wide (next_min) - - wi::to_wide (max ? max : min)); - if (wi::eq_p (difference, 1)) - max = next_max ? next_max : next_min; + loc = asserts[j]; + if (! loc->e) + common = NULL; + else if (! common + || loc->e->dest != common->e->dest + || loc->comp_code != common->comp_code + || ! operand_equal_p (loc->val, common->val, 0) + || ! operand_equal_p (loc->expr, common->expr, 0)) + { + commonj = j; + common = loc; + ecnt = 1; + } + else if (loc->e == asserts[j-1]->e) + { + /* Remove duplicate asserts. */ + if (commonj == j - 1) + { + commonj = j; + common = loc; + } + free (asserts[j-1]); + asserts[j-1] = NULL; + } else - break; + { + ecnt++; + if (EDGE_COUNT (common->e->dest->preds) == ecnt) + { + /* We have the same assertion on all incoming edges of a BB. + Insert it at the beginning of that block. */ + loc->bb = loc->e->dest; + loc->e = NULL; + loc->si = gsi_none (); + common = NULL; + /* Clear asserts commoned. */ + for (; commonj != j; ++commonj) + if (asserts[commonj]) + { + free (asserts[commonj]); + asserts[commonj] = NULL; + } + } + } } - idx--; - if (max == NULL_TREE) + /* The asserts vector sorting above might be unstable for + -fcompare-debug, sort again to ensure a stable sort. */ + asserts.qsort (compare_assert_loc); + for (unsigned j = 0; j < asserts.length (); ++j) { - /* Register the assertion OP != MIN. */ - auto_vec asserts; - min = fold_convert (TREE_TYPE (op), min); - register_edge_assert_for (op, default_edge, NE_EXPR, op, min, - asserts); - finish_register_edge_assert_for (default_edge, bsi, asserts); + loc = asserts[j]; + if (! loc) + break; + update_edges_p |= process_assert_insertions_for (ssa_name (i), loc); + num_asserts++; + free (loc); } - else - { - /* Register the assertion (unsigned)OP - MIN > (MAX - MIN), - which will give OP the anti-range ~[MIN,MAX]. */ - tree uop = fold_convert (unsigned_type_for (TREE_TYPE (op)), op); - min = fold_convert (TREE_TYPE (uop), min); - max = fold_convert (TREE_TYPE (uop), max); + } - tree lhs = fold_build2 (MINUS_EXPR, TREE_TYPE (uop), uop, min); - tree rhs = int_const_binop (MINUS_EXPR, max, min); - register_new_assert_for (op, lhs, GT_EXPR, rhs, - NULL, default_edge, bsi); - } + if (update_edges_p) + gsi_commit_edge_inserts (); - if (--insertion_limit == 0) - break; - } + statistics_counter_event (cfun, "Number of ASSERT_EXPR expressions inserted", + num_asserts); } -/* Traverse all the statements in block BB looking for statements that - 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 - list of assertions already generated for N_i is scanned to - determine if A is actually needed. +/* Traverse the flowgraph looking for conditional jumps to insert range + expressions. These range expressions are meant to provide information + to optimizations that need to reason in terms of value ranges. They + will not be expanded into RTL. For instance, given: - If N_i already had the assertion A at a location dominating the - current location, then nothing needs to be done. Otherwise, the - new location for A is recorded instead. + x = ... + y = ... + if (x < y) + y = x - 2; + else + x = y + 3; - 1- For every statement S in BB, all the variables used by S are - added to bitmap FOUND_IN_SUBGRAPH. + this pass will transform the code into: - 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 - ASSERT_EXPR, create a new assert location for N. For instance, - if N is a pointer and the statement dereferences it, we can - assume that N is not NULL. - - 3- COND_EXPRs are a special case of #2. We can derive range - information from the predicate but need to insert different - ASSERT_EXPRs for each of the sub-graphs rooted at the - conditional block. If the last statement of BB is a conditional - expression of the form 'X op Y', then - - a) Remove X and Y from the set FOUND_IN_SUBGRAPH. - - b) If the conditional is the only entry point to the sub-graph - corresponding to the THEN_CLAUSE, recurse into it. On - return, if X and/or Y are marked in FOUND_IN_SUBGRAPH, then - an ASSERT_EXPR is added for the corresponding variable. - - c) Repeat step (b) on the ELSE_CLAUSE. - - d) Mark X and Y in FOUND_IN_SUBGRAPH. - - For instance, - - if (a == 9) - b = a; - else - b = c + 1; - - In this case, an assertion on the THEN clause is useful to - determine that 'a' is always 9 on that edge. However, an assertion - on the ELSE clause would be unnecessary. - - 4- If BB does not end in a conditional expression, then we recurse - into BB's dominator children. + x = ... + y = ... + if (x < y) + { + x = ASSERT_EXPR + y = x - 2 + } + else + { + y = ASSERT_EXPR = y> + x = y + 3 + } - 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 - location for name N is found, it is registered by calling - register_new_assert_for. That function keeps track of all the - registered assertions to prevent adding unnecessary assertions. - For instance, if a pointer P_4 is dereferenced more than once in a - dominator tree, only the location dominating all the dereference of - P_4 will receive an ASSERT_EXPR. */ + The idea is that once copy and constant propagation have run, other + optimizations will be able to determine what ranges of values can 'x' + take in different paths of the code, simply by checking the reaching + definition of 'x'. */ static void -find_assert_locations_1 (basic_block bb, sbitmap live) +insert_range_assertions (void) { - gimple *last; - - last = last_stmt (bb); + need_assert_for = BITMAP_ALLOC (NULL); + asserts_for = XCNEWVEC (assert_locus *, num_ssa_names); - /* If BB's last statement is a conditional statement involving integer - operands, determine if we need to add ASSERT_EXPRs. */ - if (last - && gimple_code (last) == GIMPLE_COND - && !fp_predicate (last) - && !ZERO_SSA_OPERANDS (last, SSA_OP_USE)) - find_conditional_asserts (bb, as_a (last)); + calculate_dominance_info (CDI_DOMINATORS); - /* If BB's last statement is a switch statement involving integer - operands, determine if we need to add ASSERT_EXPRs. */ - if (last - && gimple_code (last) == GIMPLE_SWITCH - && !ZERO_SSA_OPERANDS (last, SSA_OP_USE)) - find_switch_asserts (bb, as_a (last)); + find_assert_locations (); + if (!bitmap_empty_p (need_assert_for)) + { + process_assert_insertions (); + update_ssa (TODO_update_ssa_no_phi); + } - /* Traverse all the statements in BB marking used names and looking - for statements that may infer assertions for their used operands. */ - for (gimple_stmt_iterator si = gsi_last_bb (bb); !gsi_end_p (si); - gsi_prev (&si)) + if (dump_file && (dump_flags & TDF_DETAILS)) { - gimple *stmt; - tree op; - ssa_op_iter i; + fprintf (dump_file, "\nSSA form after inserting ASSERT_EXPRs\n"); + dump_function_to_file (current_function_decl, dump_file, dump_flags); + } - stmt = gsi_stmt (si); + free (asserts_for); + BITMAP_FREE (need_assert_for); +} - if (is_gimple_debug (stmt)) - continue; +class vrp_prop : public ssa_propagation_engine +{ + public: + enum ssa_prop_result visit_stmt (gimple *, edge *, tree *) FINAL OVERRIDE; + enum ssa_prop_result visit_phi (gphi *) FINAL OVERRIDE; - /* See if we can derive an assertion for any of STMT's operands. */ - FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE) - { - tree value; - enum tree_code comp_code; + void vrp_initialize (void); + void vrp_finalize (bool); + void check_all_array_refs (void); + void check_array_ref (location_t, tree, bool); + void search_for_addr_array (tree, location_t); - /* If op is not live beyond this stmt, do not bother to insert - asserts for it. */ - if (!bitmap_bit_p (live, SSA_NAME_VERSION (op))) - continue; + class vr_values vr_values; + /* Temporary delegator to minimize code churn. */ + value_range *get_value_range (const_tree op) + { return vr_values.get_value_range (op); } + void set_defs_to_varying (gimple *stmt) + { return vr_values.set_defs_to_varying (stmt); } + void extract_range_from_stmt (gimple *stmt, edge *taken_edge_p, + tree *output_p, value_range *vr) + { vr_values.extract_range_from_stmt (stmt, taken_edge_p, output_p, vr); } + bool update_value_range (const_tree op, value_range *vr) + { return vr_values.update_value_range (op, vr); } + void extract_range_basic (value_range *vr, gimple *stmt) + { vr_values.extract_range_basic (vr, stmt); } + void extract_range_from_phi_node (gphi *phi, value_range *vr) + { vr_values.extract_range_from_phi_node (phi, vr); } +}; +/* Checks one ARRAY_REF in REF, located at LOCUS. Ignores flexible arrays + and "struct" hacks. If VRP can determine that the + array subscript is a constant, check if it is outside valid + range. If the array subscript is a RANGE, warn if it is + non-overlapping with valid range. + IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside a ADDR_EXPR. */ - /* 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 - it, create a new assertion location node for OP. */ - if (infer_value_range (stmt, op, &comp_code, &value)) - { - /* If we are able to infer a nonzero value range for OP, - then walk backwards through the use-def chain to see if OP - was set via a typecast. +void +vrp_prop::check_array_ref (location_t location, tree ref, + bool ignore_off_by_one) +{ + value_range *vr = NULL; + tree low_sub, up_sub; + tree low_bound, up_bound, up_bound_p1; - If so, then we can also infer a nonzero value range - for the operand of the NOP_EXPR. */ - if (comp_code == NE_EXPR && integer_zerop (value)) - { - tree t = op; - gimple *def_stmt = SSA_NAME_DEF_STMT (t); + if (TREE_NO_WARNING (ref)) + return; - while (is_gimple_assign (def_stmt) - && CONVERT_EXPR_CODE_P - (gimple_assign_rhs_code (def_stmt)) - && TREE_CODE - (gimple_assign_rhs1 (def_stmt)) == SSA_NAME - && POINTER_TYPE_P - (TREE_TYPE (gimple_assign_rhs1 (def_stmt)))) - { - t = gimple_assign_rhs1 (def_stmt); - def_stmt = SSA_NAME_DEF_STMT (t); + low_sub = up_sub = TREE_OPERAND (ref, 1); + up_bound = array_ref_up_bound (ref); - /* Note we want to register the assert for the - operand of the NOP_EXPR after SI, not after the - conversion. */ - if (bitmap_bit_p (live, SSA_NAME_VERSION (t))) - register_new_assert_for (t, t, comp_code, value, - bb, NULL, si); - } - } + /* Can not check flexible arrays. */ + if (!up_bound + || TREE_CODE (up_bound) != INTEGER_CST) + return; - register_new_assert_for (op, op, comp_code, value, bb, NULL, si); - } - } + /* Accesses to trailing arrays via pointers may access storage + beyond the types array bounds. */ + if (warn_array_bounds < 2 + && array_at_struct_end_p (ref)) + return; - /* Update live. */ - FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE) - bitmap_set_bit (live, SSA_NAME_VERSION (op)); - FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_DEF) - bitmap_clear_bit (live, SSA_NAME_VERSION (op)); - } + low_bound = array_ref_low_bound (ref); + up_bound_p1 = int_const_binop (PLUS_EXPR, up_bound, + build_int_cst (TREE_TYPE (up_bound), 1)); - /* Traverse all PHI nodes in BB, updating live. */ - for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si); - gsi_next (&si)) + /* Empty array. */ + if (tree_int_cst_equal (low_bound, up_bound_p1)) { - use_operand_p arg_p; - ssa_op_iter i; - gphi *phi = si.phi (); - tree res = gimple_phi_result (phi); - - if (virtual_operand_p (res)) - continue; - - FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_USE) - { - tree arg = USE_FROM_PTR (arg_p); - if (TREE_CODE (arg) == SSA_NAME) - bitmap_set_bit (live, SSA_NAME_VERSION (arg)); - } - - bitmap_clear_bit (live, SSA_NAME_VERSION (res)); + warning_at (location, OPT_Warray_bounds, + "array subscript is above array bounds"); + TREE_NO_WARNING (ref) = 1; } -} - -/* Do an RPO walk over the function computing SSA name liveness - on-the-fly and deciding on assert expressions to insert. */ - -static void -find_assert_locations (void) -{ - int *rpo = XNEWVEC (int, last_basic_block_for_fn (cfun)); - int *bb_rpo = XNEWVEC (int, last_basic_block_for_fn (cfun)); - int *last_rpo = XCNEWVEC (int, last_basic_block_for_fn (cfun)); - int rpo_cnt, i; - - live = XCNEWVEC (sbitmap, last_basic_block_for_fn (cfun)); - rpo_cnt = pre_and_rev_post_order_compute (NULL, rpo, false); - for (i = 0; i < rpo_cnt; ++i) - bb_rpo[rpo[i]] = i; - /* Pre-seed loop latch liveness from loop header PHI nodes. Due to - the order we compute liveness and insert asserts we otherwise - fail to insert asserts into the loop latch. */ - loop_p loop; - FOR_EACH_LOOP (loop, 0) + if (TREE_CODE (low_sub) == SSA_NAME) { - i = loop->latch->index; - unsigned int j = single_succ_edge (loop->latch)->dest_idx; - for (gphi_iterator gsi = gsi_start_phis (loop->header); - !gsi_end_p (gsi); gsi_next (&gsi)) + vr = get_value_range (low_sub); + if (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE) + { + low_sub = vr->type == VR_RANGE ? vr->max : vr->min; + up_sub = vr->type == VR_RANGE ? vr->min : vr->max; + } + } + + if (vr && vr->type == VR_ANTI_RANGE) + { + if (TREE_CODE (up_sub) == INTEGER_CST + && (ignore_off_by_one + ? tree_int_cst_lt (up_bound, up_sub) + : tree_int_cst_le (up_bound, up_sub)) + && TREE_CODE (low_sub) == INTEGER_CST + && tree_int_cst_le (low_sub, low_bound)) + { + warning_at (location, OPT_Warray_bounds, + "array subscript is outside array bounds"); + TREE_NO_WARNING (ref) = 1; + } + } + else if (TREE_CODE (up_sub) == INTEGER_CST + && (ignore_off_by_one + ? !tree_int_cst_le (up_sub, up_bound_p1) + : !tree_int_cst_le (up_sub, up_bound))) + { + if (dump_file && (dump_flags & TDF_DETAILS)) { - gphi *phi = gsi.phi (); - if (virtual_operand_p (gimple_phi_result (phi))) - continue; - tree arg = gimple_phi_arg_def (phi, j); - if (TREE_CODE (arg) == SSA_NAME) - { - if (live[i] == NULL) - { - live[i] = sbitmap_alloc (num_ssa_names); - bitmap_clear (live[i]); - } - bitmap_set_bit (live[i], SSA_NAME_VERSION (arg)); - } + fprintf (dump_file, "Array bound warning for "); + dump_generic_expr (MSG_NOTE, TDF_SLIM, ref); + fprintf (dump_file, "\n"); } + warning_at (location, OPT_Warray_bounds, + "array subscript is above array bounds"); + TREE_NO_WARNING (ref) = 1; } - - for (i = rpo_cnt - 1; i >= 0; --i) + else if (TREE_CODE (low_sub) == INTEGER_CST + && tree_int_cst_lt (low_sub, low_bound)) { - basic_block bb = BASIC_BLOCK_FOR_FN (cfun, rpo[i]); - edge e; - edge_iterator ei; - - if (!live[rpo[i]]) + if (dump_file && (dump_flags & TDF_DETAILS)) { - live[rpo[i]] = sbitmap_alloc (num_ssa_names); - bitmap_clear (live[rpo[i]]); + fprintf (dump_file, "Array bound warning for "); + dump_generic_expr (MSG_NOTE, TDF_SLIM, ref); + fprintf (dump_file, "\n"); } + warning_at (location, OPT_Warray_bounds, + "array subscript is below array bounds"); + TREE_NO_WARNING (ref) = 1; + } +} - /* Process BB and update the live information with uses in - this block. */ - find_assert_locations_1 (bb, live[rpo[i]]); +/* Searches if the expr T, located at LOCATION computes + address of an ARRAY_REF, and call check_array_ref on it. */ - /* Merge liveness into the predecessor blocks and free it. */ - if (!bitmap_empty_p (live[rpo[i]])) - { - int pred_rpo = i; - FOR_EACH_EDGE (e, ei, bb->preds) - { - int pred = e->src->index; - if ((e->flags & EDGE_DFS_BACK) || pred == ENTRY_BLOCK) - continue; +void +vrp_prop::search_for_addr_array (tree t, location_t location) +{ + /* Check each ARRAY_REFs in the reference chain. */ + do + { + if (TREE_CODE (t) == ARRAY_REF) + check_array_ref (location, t, true /*ignore_off_by_one*/); - if (!live[pred]) - { - live[pred] = sbitmap_alloc (num_ssa_names); - bitmap_clear (live[pred]); - } - bitmap_ior (live[pred], live[pred], live[rpo[i]]); + t = TREE_OPERAND (t, 0); + } + while (handled_component_p (t)); - if (bb_rpo[pred] < pred_rpo) - pred_rpo = bb_rpo[pred]; - } + if (TREE_CODE (t) == MEM_REF + && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR + && !TREE_NO_WARNING (t)) + { + tree tem = TREE_OPERAND (TREE_OPERAND (t, 0), 0); + tree low_bound, up_bound, el_sz; + offset_int idx; + if (TREE_CODE (TREE_TYPE (tem)) != ARRAY_TYPE + || TREE_CODE (TREE_TYPE (TREE_TYPE (tem))) == ARRAY_TYPE + || !TYPE_DOMAIN (TREE_TYPE (tem))) + return; - /* Record the RPO number of the last visited block that needs - live information from this block. */ - last_rpo[rpo[i]] = pred_rpo; + low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (tem))); + up_bound = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (tem))); + el_sz = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (tem))); + if (!low_bound + || TREE_CODE (low_bound) != INTEGER_CST + || !up_bound + || TREE_CODE (up_bound) != INTEGER_CST + || !el_sz + || TREE_CODE (el_sz) != INTEGER_CST) + return; + + idx = mem_ref_offset (t); + idx = wi::sdiv_trunc (idx, wi::to_offset (el_sz)); + if (idx < 0) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "Array bound warning for "); + dump_generic_expr (MSG_NOTE, TDF_SLIM, t); + fprintf (dump_file, "\n"); + } + warning_at (location, OPT_Warray_bounds, + "array subscript is below array bounds"); + TREE_NO_WARNING (t) = 1; } - else + else if (idx > (wi::to_offset (up_bound) + - wi::to_offset (low_bound) + 1)) { - sbitmap_free (live[rpo[i]]); - live[rpo[i]] = NULL; + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "Array bound warning for "); + dump_generic_expr (MSG_NOTE, TDF_SLIM, t); + fprintf (dump_file, "\n"); + } + warning_at (location, OPT_Warray_bounds, + "array subscript is above array bounds"); + TREE_NO_WARNING (t) = 1; } - - /* We can free all successors live bitmaps if all their - predecessors have been visited already. */ - FOR_EACH_EDGE (e, ei, bb->succs) - if (last_rpo[e->dest->index] == i - && live[e->dest->index]) - { - sbitmap_free (live[e->dest->index]); - live[e->dest->index] = NULL; - } } - - XDELETEVEC (rpo); - XDELETEVEC (bb_rpo); - XDELETEVEC (last_rpo); - for (i = 0; i < last_basic_block_for_fn (cfun); ++i) - if (live[i]) - sbitmap_free (live[i]); - XDELETEVEC (live); } -/* Create an ASSERT_EXPR for NAME and insert it in the location - indicated by LOC. Return true if we made any edge insertions. */ +/* walk_tree() callback that checks if *TP is + an ARRAY_REF inside an ADDR_EXPR (in which an array + subscript one outside the valid range is allowed). Call + check_array_ref for each ARRAY_REF found. The location is + passed in DATA. */ -static bool -process_assert_insertions_for (tree name, assert_locus *loc) +static tree +check_array_bounds (tree *tp, int *walk_subtree, void *data) { - /* Build the comparison expression NAME_i COMP_CODE VAL. */ - gimple *stmt; - tree cond; - gimple *assert_stmt; - edge_iterator ei; - edge e; - - /* If we have X <=> X do not insert an assert expr for that. */ - if (loc->expr == loc->val) - return false; + tree t = *tp; + struct walk_stmt_info *wi = (struct walk_stmt_info *) data; + location_t location; - cond = build2 (loc->comp_code, boolean_type_node, loc->expr, loc->val); - assert_stmt = build_assert_expr_for (cond, name); - if (loc->e) - { - /* We have been asked to insert the assertion on an edge. This - is used only by COND_EXPR and SWITCH_EXPR assertions. */ - gcc_checking_assert (gimple_code (gsi_stmt (loc->si)) == GIMPLE_COND - || (gimple_code (gsi_stmt (loc->si)) - == GIMPLE_SWITCH)); + if (EXPR_HAS_LOCATION (t)) + location = EXPR_LOCATION (t); + else + location = gimple_location (wi->stmt); - gsi_insert_on_edge (loc->e, assert_stmt); - return true; - } + *walk_subtree = TRUE; - /* If the stmt iterator points at the end then this is an insertion - at the beginning of a block. */ - if (gsi_end_p (loc->si)) - { - gimple_stmt_iterator si = gsi_after_labels (loc->bb); - gsi_insert_before (&si, assert_stmt, GSI_SAME_STMT); - return false; + vrp_prop *vrp_prop = (class vrp_prop *)wi->info; + if (TREE_CODE (t) == ARRAY_REF) + vrp_prop->check_array_ref (location, t, false /*ignore_off_by_one*/); - } - /* Otherwise, we can insert right after LOC->SI iff the - statement must not be the last statement in the block. */ - stmt = gsi_stmt (loc->si); - if (!stmt_ends_bb_p (stmt)) + else if (TREE_CODE (t) == ADDR_EXPR) { - gsi_insert_after (&loc->si, assert_stmt, GSI_SAME_STMT); - return false; + vrp_prop->search_for_addr_array (t, location); + *walk_subtree = FALSE; } - /* 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 - STMT is not control flow, there may only be one non-abnormal/eh edge - out of BB. */ - FOR_EACH_EDGE (e, ei, loc->bb->succs) - if (!(e->flags & (EDGE_ABNORMAL|EDGE_EH))) - { - gsi_insert_on_edge (e, assert_stmt); - return true; - } - - gcc_unreachable (); + return NULL_TREE; } -/* Qsort helper for sorting assert locations. If stable is true, don't - use iterative_hash_expr because it can be unstable for -fcompare-debug, - on the other side some pointers might be NULL. */ +/* Walk over all statements of all reachable BBs and call check_array_bounds + on them. */ -template -static int -compare_assert_loc (const void *pa, const void *pb) +void +vrp_prop::check_all_array_refs () { - assert_locus * const a = *(assert_locus * const *)pa; - assert_locus * const b = *(assert_locus * const *)pb; + basic_block bb; + gimple_stmt_iterator si; - /* If stable, some asserts might be optimized away already, sort - them last. */ - if (stable) + FOR_EACH_BB_FN (bb, cfun) { - if (a == NULL) - return b != NULL; - else if (b == NULL) - return -1; - } - - if (a->e == NULL && b->e != NULL) - return 1; - else if (a->e != NULL && b->e == NULL) - return -1; + edge_iterator ei; + edge e; + bool executable = false; - /* After the above checks, we know that (a->e == NULL) == (b->e == NULL), - no need to test both a->e and b->e. */ + /* Skip blocks that were found to be unreachable. */ + FOR_EACH_EDGE (e, ei, bb->preds) + executable |= !!(e->flags & EDGE_EXECUTABLE); + if (!executable) + continue; - /* Sort after destination index. */ - if (a->e == NULL) - ; - else if (a->e->dest->index > b->e->dest->index) - return 1; - else if (a->e->dest->index < b->e->dest->index) - return -1; + for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) + { + gimple *stmt = gsi_stmt (si); + struct walk_stmt_info wi; + if (!gimple_has_location (stmt) + || is_gimple_debug (stmt)) + continue; - /* Sort after comp_code. */ - if (a->comp_code > b->comp_code) - return 1; - else if (a->comp_code < b->comp_code) - return -1; + memset (&wi, 0, sizeof (wi)); - hashval_t ha, hb; + wi.info = this; - /* E.g. if a->val is ADDR_EXPR of a VAR_DECL, iterative_hash_expr - uses DECL_UID of the VAR_DECL, so sorting might differ between - -g and -g0. When doing the removal of redundant assert exprs - and commonization to successors, this does not matter, but for - the final sort needs to be stable. */ - if (stable) - { - ha = 0; - hb = 0; - } - else - { - ha = iterative_hash_expr (a->expr, iterative_hash_expr (a->val, 0)); - hb = iterative_hash_expr (b->expr, iterative_hash_expr (b->val, 0)); + walk_gimple_op (gsi_stmt (si), + check_array_bounds, + &wi); + } } +} - /* Break the tie using hashing and source/bb index. */ - if (ha == hb) - return (a->e != NULL - ? a->e->src->index - b->e->src->index - : a->bb->index - b->bb->index); - return ha > hb ? 1 : -1; +/* Return true if all imm uses of VAR are either in STMT, or + feed (optionally through a chain of single imm uses) GIMPLE_COND + in basic block COND_BB. */ + +static bool +all_imm_uses_in_stmt_or_feed_cond (tree var, gimple *stmt, basic_block cond_bb) +{ + use_operand_p use_p, use2_p; + imm_use_iterator iter; + + FOR_EACH_IMM_USE_FAST (use_p, iter, var) + if (USE_STMT (use_p) != stmt) + { + gimple *use_stmt = USE_STMT (use_p), *use_stmt2; + if (is_gimple_debug (use_stmt)) + continue; + while (is_gimple_assign (use_stmt) + && TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME + && single_imm_use (gimple_assign_lhs (use_stmt), + &use2_p, &use_stmt2)) + use_stmt = use_stmt2; + if (gimple_code (use_stmt) != GIMPLE_COND + || gimple_bb (use_stmt) != cond_bb) + return false; + } + return true; } -/* Process all the insertions registered for every name N_i registered - in NEED_ASSERT_FOR. The list of assertions to be inserted are - found in ASSERTS_FOR[i]. */ +/* Handle + _4 = x_3 & 31; + if (_4 != 0) + goto ; + else + goto ; + : + __builtin_unreachable (); + : + x_5 = ASSERT_EXPR ; + If x_3 has no other immediate uses (checked by caller), + var is the x_3 var from ASSERT_EXPR, we can clear low 5 bits + from the non-zero bitmask. */ static void -process_assert_insertions (void) +maybe_set_nonzero_bits (basic_block bb, tree var) { - unsigned i; - bitmap_iterator bi; - bool update_edges_p = false; - int num_asserts = 0; + edge e = single_pred_edge (bb); + basic_block cond_bb = e->src; + gimple *stmt = last_stmt (cond_bb); + tree cst; - if (dump_file && (dump_flags & TDF_DETAILS)) - dump_all_asserts (dump_file); + if (stmt == NULL + || gimple_code (stmt) != GIMPLE_COND + || gimple_cond_code (stmt) != ((e->flags & EDGE_TRUE_VALUE) + ? EQ_EXPR : NE_EXPR) + || TREE_CODE (gimple_cond_lhs (stmt)) != SSA_NAME + || !integer_zerop (gimple_cond_rhs (stmt))) + return; - EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi) + stmt = SSA_NAME_DEF_STMT (gimple_cond_lhs (stmt)); + if (!is_gimple_assign (stmt) + || gimple_assign_rhs_code (stmt) != BIT_AND_EXPR + || TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST) + return; + if (gimple_assign_rhs1 (stmt) != var) { - assert_locus *loc = asserts_for[i]; - gcc_assert (loc); - - auto_vec asserts; - for (; loc; loc = loc->next) - asserts.safe_push (loc); - asserts.qsort (compare_assert_loc); - - /* Push down common asserts to successors and remove redundant ones. */ - unsigned ecnt = 0; - assert_locus *common = NULL; - unsigned commonj = 0; - for (unsigned j = 0; j < asserts.length (); ++j) - { - loc = asserts[j]; - if (! loc->e) - common = NULL; - else if (! common - || loc->e->dest != common->e->dest - || loc->comp_code != common->comp_code - || ! operand_equal_p (loc->val, common->val, 0) - || ! operand_equal_p (loc->expr, common->expr, 0)) - { - commonj = j; - common = loc; - ecnt = 1; - } - else if (loc->e == asserts[j-1]->e) - { - /* Remove duplicate asserts. */ - if (commonj == j - 1) - { - commonj = j; - common = loc; - } - free (asserts[j-1]); - asserts[j-1] = NULL; - } - else - { - ecnt++; - if (EDGE_COUNT (common->e->dest->preds) == ecnt) - { - /* We have the same assertion on all incoming edges of a BB. - Insert it at the beginning of that block. */ - loc->bb = loc->e->dest; - loc->e = NULL; - loc->si = gsi_none (); - common = NULL; - /* Clear asserts commoned. */ - for (; commonj != j; ++commonj) - if (asserts[commonj]) - { - free (asserts[commonj]); - asserts[commonj] = NULL; - } - } - } - } + gimple *stmt2; - /* The asserts vector sorting above might be unstable for - -fcompare-debug, sort again to ensure a stable sort. */ - asserts.qsort (compare_assert_loc); - for (unsigned j = 0; j < asserts.length (); ++j) - { - loc = asserts[j]; - if (! loc) - break; - update_edges_p |= process_assert_insertions_for (ssa_name (i), loc); - num_asserts++; - free (loc); - } + if (TREE_CODE (gimple_assign_rhs1 (stmt)) != SSA_NAME) + return; + stmt2 = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt)); + if (!gimple_assign_cast_p (stmt2) + || gimple_assign_rhs1 (stmt2) != var + || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt2)) + || (TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (stmt))) + != TYPE_PRECISION (TREE_TYPE (var)))) + return; } - - if (update_edges_p) - gsi_commit_edge_inserts (); - - statistics_counter_event (cfun, "Number of ASSERT_EXPR expressions inserted", - num_asserts); + cst = gimple_assign_rhs2 (stmt); + set_nonzero_bits (var, wi::bit_and_not (get_nonzero_bits (var), + wi::to_wide (cst))); } +/* Convert range assertion expressions into the implied copies and + copy propagate away the copies. Doing the trivial copy propagation + here avoids the need to run the full copy propagation pass after + VRP. -/* Traverse the flowgraph looking for conditional jumps to insert range - expressions. These range expressions are meant to provide information - to optimizations that need to reason in terms of value ranges. They - will not be expanded into RTL. For instance, given: + FIXME, this will eventually lead to copy propagation removing the + names that had useful range information attached to them. For + instance, if we had the assertion N_i = ASSERT_EXPR 3>, + then N_i will have the range [3, +INF]. - x = ... - y = ... - if (x < y) - y = x - 2; - else - x = y + 3; + However, by converting the assertion into the implied copy + 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 + ASSERT_EXPRs a little while longer as the ranges could be used in + things like jump threading. - this pass will transform the code into: - - x = ... - y = ... - if (x < y) - { - x = ASSERT_EXPR - y = x - 2 - } - else - { - y = ASSERT_EXPR = y> - x = y + 3 - } + The problem with keeping ASSERT_EXPRs around is that passes after + VRP need to handle them appropriately. - The idea is that once copy and constant propagation have run, other - optimizations will be able to determine what ranges of values can 'x' - take in different paths of the code, simply by checking the reaching - definition of 'x'. */ + Another approach would be to make the range information a first + 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 + multiple ranges to be associated with one SSA_NAME. */ static void -insert_range_assertions (void) -{ - need_assert_for = BITMAP_ALLOC (NULL); - asserts_for = XCNEWVEC (assert_locus *, num_ssa_names); - - calculate_dominance_info (CDI_DOMINATORS); - - find_assert_locations (); - if (!bitmap_empty_p (need_assert_for)) - { - process_assert_insertions (); - update_ssa (TODO_update_ssa_no_phi); - } - - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "\nSSA form after inserting ASSERT_EXPRs\n"); - dump_function_to_file (current_function_decl, dump_file, dump_flags); - } - - free (asserts_for); - BITMAP_FREE (need_assert_for); -} - -class vrp_prop : public ssa_propagation_engine -{ - public: - enum ssa_prop_result visit_stmt (gimple *, edge *, tree *) FINAL OVERRIDE; - enum ssa_prop_result visit_phi (gphi *) FINAL OVERRIDE; - - void vrp_initialize (void); - void vrp_finalize (bool); - void check_all_array_refs (void); - void check_array_ref (location_t, tree, bool); - void search_for_addr_array (tree, location_t); - - class vr_values vr_values; - /* Temporary delegator to minimize code churn. */ - value_range *get_value_range (const_tree op) - { return vr_values.get_value_range (op); } - void set_defs_to_varying (gimple *stmt) - { return vr_values.set_defs_to_varying (stmt); } - void extract_range_from_stmt (gimple *stmt, edge *taken_edge_p, - tree *output_p, value_range *vr) - { vr_values.extract_range_from_stmt (stmt, taken_edge_p, output_p, vr); } - bool update_value_range (const_tree op, value_range *vr) - { return vr_values.update_value_range (op, vr); } - void extract_range_basic (value_range *vr, gimple *stmt) - { vr_values.extract_range_basic (vr, stmt); } - void extract_range_from_phi_node (gphi *phi, value_range *vr) - { vr_values.extract_range_from_phi_node (phi, vr); } -}; - -/* Checks one ARRAY_REF in REF, located at LOCUS. Ignores flexible arrays - and "struct" hacks. If VRP can determine that the - array subscript is a constant, check if it is outside valid - range. If the array subscript is a RANGE, warn if it is - non-overlapping with valid range. - IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside a ADDR_EXPR. */ - -void -vrp_prop::check_array_ref (location_t location, tree ref, - bool ignore_off_by_one) +remove_range_assertions (void) { - value_range *vr = NULL; - tree low_sub, up_sub; - tree low_bound, up_bound, up_bound_p1; - - if (TREE_NO_WARNING (ref)) - return; - - low_sub = up_sub = TREE_OPERAND (ref, 1); - up_bound = array_ref_up_bound (ref); + basic_block bb; + gimple_stmt_iterator si; + /* 1 if looking at ASSERT_EXPRs immediately at the beginning of + a basic block preceeded by GIMPLE_COND branching to it and + __builtin_trap, -1 if not yet checked, 0 otherwise. */ + int is_unreachable; - /* Can not check flexible arrays. */ - if (!up_bound - || TREE_CODE (up_bound) != INTEGER_CST) - return; + /* Note that the BSI iterator bump happens at the bottom of the + loop and no bump is necessary if we're removing the statement + referenced by the current BSI. */ + FOR_EACH_BB_FN (bb, cfun) + for (si = gsi_after_labels (bb), is_unreachable = -1; !gsi_end_p (si);) + { + gimple *stmt = gsi_stmt (si); - /* Accesses to trailing arrays via pointers may access storage - beyond the types array bounds. */ - if (warn_array_bounds < 2 - && array_at_struct_end_p (ref)) - return; + if (is_gimple_assign (stmt) + && gimple_assign_rhs_code (stmt) == ASSERT_EXPR) + { + tree lhs = gimple_assign_lhs (stmt); + tree rhs = gimple_assign_rhs1 (stmt); + tree var; - low_bound = array_ref_low_bound (ref); - up_bound_p1 = int_const_binop (PLUS_EXPR, up_bound, - build_int_cst (TREE_TYPE (up_bound), 1)); + var = ASSERT_EXPR_VAR (rhs); - /* Empty array. */ - if (tree_int_cst_equal (low_bound, up_bound_p1)) - { - warning_at (location, OPT_Warray_bounds, - "array subscript is above array bounds"); - TREE_NO_WARNING (ref) = 1; - } + if (TREE_CODE (var) == SSA_NAME + && !POINTER_TYPE_P (TREE_TYPE (lhs)) + && SSA_NAME_RANGE_INFO (lhs)) + { + if (is_unreachable == -1) + { + is_unreachable = 0; + if (single_pred_p (bb) + && assert_unreachable_fallthru_edge_p + (single_pred_edge (bb))) + is_unreachable = 1; + } + /* Handle + if (x_7 >= 10 && x_7 < 20) + __builtin_unreachable (); + x_8 = ASSERT_EXPR ; + if the only uses of x_7 are in the ASSERT_EXPR and + in the condition. In that case, we can copy the + range info from x_8 computed in this pass also + for x_7. */ + if (is_unreachable + && all_imm_uses_in_stmt_or_feed_cond (var, stmt, + single_pred (bb))) + { + set_range_info (var, SSA_NAME_RANGE_TYPE (lhs), + SSA_NAME_RANGE_INFO (lhs)->get_min (), + SSA_NAME_RANGE_INFO (lhs)->get_max ()); + maybe_set_nonzero_bits (bb, var); + } + } - if (TREE_CODE (low_sub) == SSA_NAME) - { - vr = get_value_range (low_sub); - if (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE) - { - low_sub = vr->type == VR_RANGE ? vr->max : vr->min; - up_sub = vr->type == VR_RANGE ? vr->min : vr->max; - } - } + /* Propagate the RHS into every use of the LHS. For SSA names + also propagate abnormals as it merely restores the original + IL in this case (an replace_uses_by would assert). */ + if (TREE_CODE (var) == SSA_NAME) + { + imm_use_iterator iter; + use_operand_p use_p; + gimple *use_stmt; + FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) + FOR_EACH_IMM_USE_ON_STMT (use_p, iter) + SET_USE (use_p, var); + } + else + replace_uses_by (lhs, var); - if (vr && vr->type == VR_ANTI_RANGE) - { - if (TREE_CODE (up_sub) == INTEGER_CST - && (ignore_off_by_one - ? tree_int_cst_lt (up_bound, up_sub) - : tree_int_cst_le (up_bound, up_sub)) - && TREE_CODE (low_sub) == INTEGER_CST - && tree_int_cst_le (low_sub, low_bound)) - { - warning_at (location, OPT_Warray_bounds, - "array subscript is outside array bounds"); - TREE_NO_WARNING (ref) = 1; - } - } - else if (TREE_CODE (up_sub) == INTEGER_CST - && (ignore_off_by_one - ? !tree_int_cst_le (up_sub, up_bound_p1) - : !tree_int_cst_le (up_sub, up_bound))) - { - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "Array bound warning for "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, ref); - fprintf (dump_file, "\n"); - } - warning_at (location, OPT_Warray_bounds, - "array subscript is above array bounds"); - TREE_NO_WARNING (ref) = 1; - } - else if (TREE_CODE (low_sub) == INTEGER_CST - && tree_int_cst_lt (low_sub, low_bound)) - { - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "Array bound warning for "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, ref); - fprintf (dump_file, "\n"); - } - warning_at (location, OPT_Warray_bounds, - "array subscript is below array bounds"); - TREE_NO_WARNING (ref) = 1; - } + /* And finally, remove the copy, it is not needed. */ + gsi_remove (&si, true); + release_defs (stmt); + } + else + { + if (!is_gimple_debug (gsi_stmt (si))) + is_unreachable = 0; + gsi_next (&si); + } + } } -/* Searches if the expr T, located at LOCATION computes - address of an ARRAY_REF, and call check_array_ref on it. */ -void -vrp_prop::search_for_addr_array (tree t, location_t location) +/* Return true if STMT is interesting for VRP. */ + +bool +stmt_interesting_for_vrp (gimple *stmt) { - /* Check each ARRAY_REFs in the reference chain. */ - do + if (gimple_code (stmt) == GIMPLE_PHI) { - if (TREE_CODE (t) == ARRAY_REF) - check_array_ref (location, t, true /*ignore_off_by_one*/); - - t = TREE_OPERAND (t, 0); - } - while (handled_component_p (t)); - - if (TREE_CODE (t) == MEM_REF - && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR - && !TREE_NO_WARNING (t)) - { - tree tem = TREE_OPERAND (TREE_OPERAND (t, 0), 0); - tree low_bound, up_bound, el_sz; - offset_int idx; - if (TREE_CODE (TREE_TYPE (tem)) != ARRAY_TYPE - || TREE_CODE (TREE_TYPE (TREE_TYPE (tem))) == ARRAY_TYPE - || !TYPE_DOMAIN (TREE_TYPE (tem))) - return; - - low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (tem))); - up_bound = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (tem))); - el_sz = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (tem))); - if (!low_bound - || TREE_CODE (low_bound) != INTEGER_CST - || !up_bound - || TREE_CODE (up_bound) != INTEGER_CST - || !el_sz - || TREE_CODE (el_sz) != INTEGER_CST) - return; - - idx = mem_ref_offset (t); - idx = wi::sdiv_trunc (idx, wi::to_offset (el_sz)); - if (idx < 0) - { - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "Array bound warning for "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, t); - fprintf (dump_file, "\n"); - } - warning_at (location, OPT_Warray_bounds, - "array subscript is below array bounds"); - TREE_NO_WARNING (t) = 1; - } - else if (idx > (wi::to_offset (up_bound) - - wi::to_offset (low_bound) + 1)) - { - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "Array bound warning for "); - dump_generic_expr (MSG_NOTE, TDF_SLIM, t); - fprintf (dump_file, "\n"); - } - warning_at (location, OPT_Warray_bounds, - "array subscript is above array bounds"); - TREE_NO_WARNING (t) = 1; - } - } -} - -/* walk_tree() callback that checks if *TP is - an ARRAY_REF inside an ADDR_EXPR (in which an array - subscript one outside the valid range is allowed). Call - check_array_ref for each ARRAY_REF found. The location is - passed in DATA. */ - -static tree -check_array_bounds (tree *tp, int *walk_subtree, void *data) -{ - tree t = *tp; - struct walk_stmt_info *wi = (struct walk_stmt_info *) data; - location_t location; - - if (EXPR_HAS_LOCATION (t)) - location = EXPR_LOCATION (t); - else - location = gimple_location (wi->stmt); - - *walk_subtree = TRUE; - - vrp_prop *vrp_prop = (class vrp_prop *)wi->info; - if (TREE_CODE (t) == ARRAY_REF) - vrp_prop->check_array_ref (location, t, false /*ignore_off_by_one*/); - - else if (TREE_CODE (t) == ADDR_EXPR) - { - vrp_prop->search_for_addr_array (t, location); - *walk_subtree = FALSE; - } - - return NULL_TREE; -} - -/* Walk over all statements of all reachable BBs and call check_array_bounds - on them. */ - -void -vrp_prop::check_all_array_refs () -{ - basic_block bb; - gimple_stmt_iterator si; - - FOR_EACH_BB_FN (bb, cfun) - { - edge_iterator ei; - edge e; - bool executable = false; - - /* Skip blocks that were found to be unreachable. */ - FOR_EACH_EDGE (e, ei, bb->preds) - executable |= !!(e->flags & EDGE_EXECUTABLE); - if (!executable) - continue; - - for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) - { - gimple *stmt = gsi_stmt (si); - struct walk_stmt_info wi; - if (!gimple_has_location (stmt) - || is_gimple_debug (stmt)) - continue; - - memset (&wi, 0, sizeof (wi)); - - wi.info = this; - - walk_gimple_op (gsi_stmt (si), - check_array_bounds, - &wi); - } - } -} - -/* Return true if all imm uses of VAR are either in STMT, or - feed (optionally through a chain of single imm uses) GIMPLE_COND - in basic block COND_BB. */ - -static bool -all_imm_uses_in_stmt_or_feed_cond (tree var, gimple *stmt, basic_block cond_bb) -{ - use_operand_p use_p, use2_p; - imm_use_iterator iter; - - FOR_EACH_IMM_USE_FAST (use_p, iter, var) - if (USE_STMT (use_p) != stmt) - { - gimple *use_stmt = USE_STMT (use_p), *use_stmt2; - if (is_gimple_debug (use_stmt)) - continue; - while (is_gimple_assign (use_stmt) - && TREE_CODE (gimple_assign_lhs (use_stmt)) == SSA_NAME - && single_imm_use (gimple_assign_lhs (use_stmt), - &use2_p, &use_stmt2)) - use_stmt = use_stmt2; - if (gimple_code (use_stmt) != GIMPLE_COND - || gimple_bb (use_stmt) != cond_bb) - return false; - } - return true; -} - -/* Handle - _4 = x_3 & 31; - if (_4 != 0) - goto ; - else - goto ; - : - __builtin_unreachable (); - : - x_5 = ASSERT_EXPR ; - If x_3 has no other immediate uses (checked by caller), - var is the x_3 var from ASSERT_EXPR, we can clear low 5 bits - from the non-zero bitmask. */ - -static void -maybe_set_nonzero_bits (basic_block bb, tree var) -{ - edge e = single_pred_edge (bb); - basic_block cond_bb = e->src; - gimple *stmt = last_stmt (cond_bb); - tree cst; - - if (stmt == NULL - || gimple_code (stmt) != GIMPLE_COND - || gimple_cond_code (stmt) != ((e->flags & EDGE_TRUE_VALUE) - ? EQ_EXPR : NE_EXPR) - || TREE_CODE (gimple_cond_lhs (stmt)) != SSA_NAME - || !integer_zerop (gimple_cond_rhs (stmt))) - return; - - stmt = SSA_NAME_DEF_STMT (gimple_cond_lhs (stmt)); - if (!is_gimple_assign (stmt) - || gimple_assign_rhs_code (stmt) != BIT_AND_EXPR - || TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST) - return; - if (gimple_assign_rhs1 (stmt) != var) - { - gimple *stmt2; - - if (TREE_CODE (gimple_assign_rhs1 (stmt)) != SSA_NAME) - return; - stmt2 = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt)); - if (!gimple_assign_cast_p (stmt2) - || gimple_assign_rhs1 (stmt2) != var - || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt2)) - || (TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (stmt))) - != TYPE_PRECISION (TREE_TYPE (var)))) - return; - } - cst = gimple_assign_rhs2 (stmt); - set_nonzero_bits (var, wi::bit_and_not (get_nonzero_bits (var), - wi::to_wide (cst))); -} - -/* Convert range assertion expressions into the implied copies and - copy propagate away the copies. Doing the trivial copy propagation - here avoids the need to run the full copy propagation pass after - VRP. - - FIXME, this will eventually lead to copy propagation removing the - names that had useful range information attached to them. For - instance, if we had the assertion N_i = ASSERT_EXPR 3>, - then N_i will have the range [3, +INF]. - - However, by converting the assertion into the implied copy - 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 - ASSERT_EXPRs a little while longer as the ranges could be used in - things like jump threading. - - The problem with keeping ASSERT_EXPRs around is that passes after - VRP need to handle them appropriately. - - Another approach would be to make the range information a first - 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 - multiple ranges to be associated with one SSA_NAME. */ - -static void -remove_range_assertions (void) -{ - basic_block bb; - gimple_stmt_iterator si; - /* 1 if looking at ASSERT_EXPRs immediately at the beginning of - a basic block preceeded by GIMPLE_COND branching to it and - __builtin_trap, -1 if not yet checked, 0 otherwise. */ - int is_unreachable; - - /* Note that the BSI iterator bump happens at the bottom of the - loop and no bump is necessary if we're removing the statement - referenced by the current BSI. */ - FOR_EACH_BB_FN (bb, cfun) - for (si = gsi_after_labels (bb), is_unreachable = -1; !gsi_end_p (si);) - { - gimple *stmt = gsi_stmt (si); - - if (is_gimple_assign (stmt) - && gimple_assign_rhs_code (stmt) == ASSERT_EXPR) - { - tree lhs = gimple_assign_lhs (stmt); - tree rhs = gimple_assign_rhs1 (stmt); - tree var; - - var = ASSERT_EXPR_VAR (rhs); - - if (TREE_CODE (var) == SSA_NAME - && !POINTER_TYPE_P (TREE_TYPE (lhs)) - && SSA_NAME_RANGE_INFO (lhs)) - { - if (is_unreachable == -1) - { - is_unreachable = 0; - if (single_pred_p (bb) - && assert_unreachable_fallthru_edge_p - (single_pred_edge (bb))) - is_unreachable = 1; - } - /* Handle - if (x_7 >= 10 && x_7 < 20) - __builtin_unreachable (); - x_8 = ASSERT_EXPR ; - if the only uses of x_7 are in the ASSERT_EXPR and - in the condition. In that case, we can copy the - range info from x_8 computed in this pass also - for x_7. */ - if (is_unreachable - && all_imm_uses_in_stmt_or_feed_cond (var, stmt, - single_pred (bb))) - { - set_range_info (var, SSA_NAME_RANGE_TYPE (lhs), - SSA_NAME_RANGE_INFO (lhs)->get_min (), - SSA_NAME_RANGE_INFO (lhs)->get_max ()); - maybe_set_nonzero_bits (bb, var); - } - } - - /* Propagate the RHS into every use of the LHS. For SSA names - also propagate abnormals as it merely restores the original - IL in this case (an replace_uses_by would assert). */ - if (TREE_CODE (var) == SSA_NAME) - { - imm_use_iterator iter; - use_operand_p use_p; - gimple *use_stmt; - FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) - FOR_EACH_IMM_USE_ON_STMT (use_p, iter) - SET_USE (use_p, var); - } - else - replace_uses_by (lhs, var); - - /* And finally, remove the copy, it is not needed. */ - gsi_remove (&si, true); - release_defs (stmt); - } - else - { - if (!is_gimple_debug (gsi_stmt (si))) - is_unreachable = 0; - gsi_next (&si); - } - } -} - - -/* Return true if STMT is interesting for VRP. */ - -bool -stmt_interesting_for_vrp (gimple *stmt) -{ - if (gimple_code (stmt) == GIMPLE_PHI) - { - tree res = gimple_phi_result (stmt); - return (!virtual_operand_p (res) - && (INTEGRAL_TYPE_P (TREE_TYPE (res)) - || POINTER_TYPE_P (TREE_TYPE (res)))); - } - else if (is_gimple_assign (stmt) || is_gimple_call (stmt)) - { - tree lhs = gimple_get_lhs (stmt); - - /* In general, assignments with virtual operands are not useful - for deriving ranges, with the obvious exception of calls to - builtin functions. */ - if (lhs && TREE_CODE (lhs) == SSA_NAME - && (INTEGRAL_TYPE_P (TREE_TYPE (lhs)) - || POINTER_TYPE_P (TREE_TYPE (lhs))) - && (is_gimple_call (stmt) - || !gimple_vuse (stmt))) - return true; - else if (is_gimple_call (stmt) && gimple_call_internal_p (stmt)) - switch (gimple_call_internal_fn (stmt)) - { - case IFN_ADD_OVERFLOW: - case IFN_SUB_OVERFLOW: - case IFN_MUL_OVERFLOW: - case IFN_ATOMIC_COMPARE_EXCHANGE: - /* These internal calls return _Complex integer type, - but are interesting to VRP nevertheless. */ - if (lhs && TREE_CODE (lhs) == SSA_NAME) - return true; - break; - default: - break; - } - } - else if (gimple_code (stmt) == GIMPLE_COND - || gimple_code (stmt) == GIMPLE_SWITCH) - return true; - - return false; -} - -/* Initialize VRP lattice. */ - -vr_values::vr_values () : vrp_value_range_pool ("Tree VRP value ranges") -{ - values_propagated = false; - num_vr_values = num_ssa_names; - vr_value = XCNEWVEC (value_range *, num_vr_values); - vr_phi_edge_counts = XCNEWVEC (int, num_ssa_names); - bitmap_obstack_initialize (&vrp_equiv_obstack); -} - -/* Initialization required by ssa_propagate engine. */ - -void -vrp_prop::vrp_initialize () -{ - basic_block bb; - - FOR_EACH_BB_FN (bb, cfun) - { - for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si); - gsi_next (&si)) - { - gphi *phi = si.phi (); - if (!stmt_interesting_for_vrp (phi)) - { - tree lhs = PHI_RESULT (phi); - set_value_range_to_varying (get_value_range (lhs)); - prop_set_simulate_again (phi, false); - } - else - prop_set_simulate_again (phi, true); - } - - for (gimple_stmt_iterator si = gsi_start_bb (bb); !gsi_end_p (si); - gsi_next (&si)) - { - gimple *stmt = gsi_stmt (si); - - /* If the statement is a control insn, then we do not - want to avoid simulating the statement once. Failure - to do so means that those edges will never get added. */ - if (stmt_ends_bb_p (stmt)) - prop_set_simulate_again (stmt, true); - else if (!stmt_interesting_for_vrp (stmt)) - { - set_defs_to_varying (stmt); - prop_set_simulate_again (stmt, false); - } - else - prop_set_simulate_again (stmt, true); - } - } -} - -/* A hack. */ -static class vr_values *x_vr_values; - -/* Return the singleton value-range for NAME or NAME. */ - -static inline tree -vrp_valueize (tree name) -{ - if (TREE_CODE (name) == SSA_NAME) - { - value_range *vr = x_vr_values->get_value_range (name); - if (vr->type == VR_RANGE - && (TREE_CODE (vr->min) == SSA_NAME - || is_gimple_min_invariant (vr->min)) - && vrp_operand_equal_p (vr->min, vr->max)) - return vr->min; - } - return name; -} - -/* Return the singleton value-range for NAME if that is a constant - but signal to not follow SSA edges. */ - -static inline tree -vrp_valueize_1 (tree name) -{ - if (TREE_CODE (name) == SSA_NAME) - { - /* If the definition may be simulated again we cannot follow - this SSA edge as the SSA propagator does not necessarily - re-visit the use. */ - gimple *def_stmt = SSA_NAME_DEF_STMT (name); - if (!gimple_nop_p (def_stmt) - && prop_simulate_again_p (def_stmt)) - return NULL_TREE; - value_range *vr = x_vr_values->get_value_range (name); - if (range_int_cst_singleton_p (vr)) - return vr->min; - } - return name; -} - -/* Visit assignment STMT. If it produces an interesting range, record - the range in VR and set LHS to OUTPUT_P. */ - -void -vr_values::vrp_visit_assignment_or_call (gimple *stmt, tree *output_p, - value_range *vr) -{ - tree lhs; - enum gimple_code code = gimple_code (stmt); - lhs = gimple_get_lhs (stmt); - *output_p = NULL_TREE; - - /* We only keep track of ranges in integral and pointer types. */ - if (TREE_CODE (lhs) == SSA_NAME - && ((INTEGRAL_TYPE_P (TREE_TYPE (lhs)) - /* It is valid to have NULL MIN/MAX values on a type. See - build_range_type. */ - && TYPE_MIN_VALUE (TREE_TYPE (lhs)) - && TYPE_MAX_VALUE (TREE_TYPE (lhs))) - || POINTER_TYPE_P (TREE_TYPE (lhs)))) - { - *output_p = lhs; - - /* Try folding the statement to a constant first. */ - x_vr_values = this; - tree tem = gimple_fold_stmt_to_constant_1 (stmt, vrp_valueize, - vrp_valueize_1); - x_vr_values = NULL; - if (tem) - { - if (TREE_CODE (tem) == SSA_NAME - && (SSA_NAME_IS_DEFAULT_DEF (tem) - || ! prop_simulate_again_p (SSA_NAME_DEF_STMT (tem)))) - { - extract_range_from_ssa_name (vr, tem); - return; - } - else if (is_gimple_min_invariant (tem)) - { - set_value_range_to_value (vr, tem, NULL); - return; - } - } - /* Then dispatch to value-range extracting functions. */ - if (code == GIMPLE_CALL) - extract_range_basic (vr, stmt); - else - extract_range_from_assignment (vr, as_a (stmt)); - } -} - -/* Helper that gets the value range of the SSA_NAME with version I - or a symbolic range containing the SSA_NAME only if the value range - is varying or undefined. */ - -value_range -vr_values::get_vr_for_comparison (int i) -{ - value_range vr = *get_value_range (ssa_name (i)); - - /* 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 - have N_i in their ranges. */ - if (vr.type == VR_VARYING || vr.type == VR_UNDEFINED) - { - vr.type = VR_RANGE; - vr.min = ssa_name (i); - vr.max = ssa_name (i); - } - - return vr; -} - -/* Compare all the value ranges for names equivalent to VAR with VAL - using comparison code COMP. Return the same value returned by - compare_range_with_value, including the setting of - *STRICT_OVERFLOW_P. */ - -tree -vr_values::compare_name_with_value (enum tree_code comp, tree var, tree val, - bool *strict_overflow_p, bool use_equiv_p) -{ - bitmap_iterator bi; - unsigned i; - bitmap e; - tree retval, t; - int used_strict_overflow; - bool sop; - value_range equiv_vr; - - /* Get the set of equivalences for VAR. */ - e = get_value_range (var)->equiv; - - /* Start at -1. Set it to 0 if we do a comparison without relying - on overflow, or 1 if all comparisons rely on overflow. */ - used_strict_overflow = -1; - - /* Compare vars' value range with val. */ - equiv_vr = get_vr_for_comparison (SSA_NAME_VERSION (var)); - sop = false; - retval = compare_range_with_value (comp, &equiv_vr, val, &sop); - if (retval) - used_strict_overflow = sop ? 1 : 0; - - /* If the equiv set is empty we have done all work we need to do. */ - if (e == NULL) - { - if (retval - && used_strict_overflow > 0) - *strict_overflow_p = true; - return retval; - } - - EXECUTE_IF_SET_IN_BITMAP (e, 0, i, bi) - { - tree name = ssa_name (i); - if (! name) - continue; - - if (! use_equiv_p - && ! SSA_NAME_IS_DEFAULT_DEF (name) - && prop_simulate_again_p (SSA_NAME_DEF_STMT (name))) - continue; - - equiv_vr = get_vr_for_comparison (i); - sop = false; - t = compare_range_with_value (comp, &equiv_vr, val, &sop); - if (t) - { - /* If we get different answers from different members - of the equivalence set this check must be in a dead - code region. Folding it to a trap representation - would be correct here. For now just return don't-know. */ - if (retval != NULL - && t != retval) - { - retval = NULL_TREE; - break; - } - retval = t; - - if (!sop) - used_strict_overflow = 0; - else if (used_strict_overflow < 0) - used_strict_overflow = 1; - } - } - - if (retval - && used_strict_overflow > 0) - *strict_overflow_p = true; - - return retval; -} - - -/* Given a comparison code COMP and names N1 and N2, compare all the - ranges equivalent to N1 against all the ranges equivalent to N2 - to determine the value of N1 COMP N2. Return the same value - returned by compare_ranges. Set *STRICT_OVERFLOW_P to indicate - whether we relied on undefined signed overflow in the comparison. */ - - -tree -vr_values::compare_names (enum tree_code comp, tree n1, tree n2, - bool *strict_overflow_p) -{ - tree t, retval; - bitmap e1, e2; - bitmap_iterator bi1, bi2; - unsigned i1, i2; - int used_strict_overflow; - static bitmap_obstack *s_obstack = NULL; - static bitmap s_e1 = NULL, s_e2 = NULL; - - /* Compare the ranges of every name equivalent to N1 against the - ranges of every name equivalent to N2. */ - e1 = get_value_range (n1)->equiv; - e2 = get_value_range (n2)->equiv; - - /* Use the fake bitmaps if e1 or e2 are not available. */ - if (s_obstack == NULL) - { - s_obstack = XNEW (bitmap_obstack); - bitmap_obstack_initialize (s_obstack); - s_e1 = BITMAP_ALLOC (s_obstack); - s_e2 = BITMAP_ALLOC (s_obstack); - } - if (e1 == NULL) - e1 = s_e1; - if (e2 == NULL) - e2 = s_e2; - - /* Add N1 and N2 to their own set of equivalences to avoid - duplicating the body of the loop just to check N1 and N2 - ranges. */ - bitmap_set_bit (e1, SSA_NAME_VERSION (n1)); - bitmap_set_bit (e2, SSA_NAME_VERSION (n2)); - - /* If the equivalence sets have a common intersection, then the two - names can be compared without checking their ranges. */ - if (bitmap_intersect_p (e1, e2)) - { - bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); - bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); - - return (comp == EQ_EXPR || comp == GE_EXPR || comp == LE_EXPR) - ? boolean_true_node - : boolean_false_node; - } - - /* Start at -1. Set it to 0 if we do a comparison without relying - on overflow, or 1 if all comparisons rely on overflow. */ - used_strict_overflow = -1; - - /* Otherwise, compare all the equivalent ranges. First, add N1 and - N2 to their own set of equivalences to avoid duplicating the body - of the loop just to check N1 and N2 ranges. */ - EXECUTE_IF_SET_IN_BITMAP (e1, 0, i1, bi1) - { - if (! ssa_name (i1)) - continue; - - value_range vr1 = get_vr_for_comparison (i1); - - t = retval = NULL_TREE; - EXECUTE_IF_SET_IN_BITMAP (e2, 0, i2, bi2) - { - if (! ssa_name (i2)) - continue; - - bool sop = false; - - value_range vr2 = get_vr_for_comparison (i2); - - t = compare_ranges (comp, &vr1, &vr2, &sop); - if (t) - { - /* If we get different answers from different members - of the equivalence set this check must be in a dead - code region. Folding it to a trap representation - would be correct here. For now just return don't-know. */ - if (retval != NULL - && t != retval) - { - bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); - bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); - return NULL_TREE; - } - retval = t; - - if (!sop) - used_strict_overflow = 0; - else if (used_strict_overflow < 0) - used_strict_overflow = 1; - } - } - - if (retval) - { - bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); - bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); - if (used_strict_overflow > 0) - *strict_overflow_p = true; - return retval; - } - } - - /* None of the equivalent ranges are useful in computing this - comparison. */ - bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); - bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); - return NULL_TREE; -} - -/* Helper function for vrp_evaluate_conditional_warnv & other - optimizers. */ - -tree -vr_values::vrp_evaluate_conditional_warnv_with_ops_using_ranges - (enum tree_code code, tree op0, tree op1, bool * strict_overflow_p) -{ - value_range *vr0, *vr1; - - vr0 = (TREE_CODE (op0) == SSA_NAME) ? get_value_range (op0) : NULL; - vr1 = (TREE_CODE (op1) == SSA_NAME) ? get_value_range (op1) : NULL; - - tree res = NULL_TREE; - if (vr0 && vr1) - res = compare_ranges (code, vr0, vr1, strict_overflow_p); - if (!res && vr0) - res = compare_range_with_value (code, vr0, op1, strict_overflow_p); - if (!res && vr1) - res = (compare_range_with_value - (swap_tree_comparison (code), vr1, op0, strict_overflow_p)); - return res; -} - -/* Helper function for vrp_evaluate_conditional_warnv. */ - -tree -vr_values::vrp_evaluate_conditional_warnv_with_ops (enum tree_code code, - tree op0, tree op1, - bool use_equiv_p, - bool *strict_overflow_p, - bool *only_ranges) -{ - tree ret; - if (only_ranges) - *only_ranges = true; - - /* We only deal with integral and pointer types. */ - if (!INTEGRAL_TYPE_P (TREE_TYPE (op0)) - && !POINTER_TYPE_P (TREE_TYPE (op0))) - return NULL_TREE; - - /* If OP0 CODE OP1 is an overflow comparison, if it can be expressed - as a simple equality test, then prefer that over its current form - for evaluation. - - An overflow test which collapses to an equality test can always be - expressed as a comparison of one argument against zero. Overflow - occurs when the chosen argument is zero and does not occur if the - chosen argument is not zero. */ - tree x; - if (overflow_comparison_p (code, op0, op1, use_equiv_p, &x)) - { - wide_int max = wi::max_value (TYPE_PRECISION (TREE_TYPE (op0)), UNSIGNED); - /* B = A - 1; if (A < B) -> B = A - 1; if (A == 0) - B = A - 1; if (A > B) -> B = A - 1; if (A != 0) - B = A + 1; if (B < A) -> B = A + 1; if (B == 0) - B = A + 1; if (B > A) -> B = A + 1; if (B != 0) */ - if (integer_zerop (x)) - { - op1 = x; - code = (code == LT_EXPR || code == LE_EXPR) ? EQ_EXPR : NE_EXPR; - } - /* B = A + 1; if (A > B) -> B = A + 1; if (B == 0) - B = A + 1; if (A < B) -> B = A + 1; if (B != 0) - B = A - 1; if (B > A) -> B = A - 1; if (A == 0) - B = A - 1; if (B < A) -> B = A - 1; if (A != 0) */ - else if (wi::to_wide (x) == max - 1) - { - op0 = op1; - op1 = wide_int_to_tree (TREE_TYPE (op0), 0); - code = (code == GT_EXPR || code == GE_EXPR) ? EQ_EXPR : NE_EXPR; - } - } - - if ((ret = vrp_evaluate_conditional_warnv_with_ops_using_ranges - (code, op0, op1, strict_overflow_p))) - return ret; - if (only_ranges) - *only_ranges = false; - /* Do not use compare_names during propagation, it's quadratic. */ - if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME - && use_equiv_p) - return compare_names (code, op0, op1, strict_overflow_p); - else if (TREE_CODE (op0) == SSA_NAME) - return compare_name_with_value (code, op0, op1, - strict_overflow_p, use_equiv_p); - else if (TREE_CODE (op1) == SSA_NAME) - return compare_name_with_value (swap_tree_comparison (code), op1, op0, - strict_overflow_p, use_equiv_p); - return NULL_TREE; -} - -/* Given (CODE OP0 OP1) within STMT, try to simplify it based on value range - information. Return NULL if the conditional can not be evaluated. - 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 - based on undefined signed overflow, issue a warning if - appropriate. */ - -tree -vr_values::vrp_evaluate_conditional (tree_code code, tree op0, - tree op1, gimple *stmt) -{ - bool sop; - tree ret; - bool only_ranges; - - /* Some passes and foldings leak constants with overflow flag set - into the IL. Avoid doing wrong things with these and bail out. */ - if ((TREE_CODE (op0) == INTEGER_CST - && TREE_OVERFLOW (op0)) - || (TREE_CODE (op1) == INTEGER_CST - && TREE_OVERFLOW (op1))) - return NULL_TREE; - - sop = false; - ret = vrp_evaluate_conditional_warnv_with_ops (code, op0, op1, true, &sop, - &only_ranges); - - if (ret && sop) - { - enum warn_strict_overflow_code wc; - const char* warnmsg; - - if (is_gimple_min_invariant (ret)) - { - wc = WARN_STRICT_OVERFLOW_CONDITIONAL; - warnmsg = G_("assuming signed overflow does not occur when " - "simplifying conditional to constant"); - } - else - { - wc = WARN_STRICT_OVERFLOW_COMPARISON; - warnmsg = G_("assuming signed overflow does not occur when " - "simplifying conditional"); - } - - if (issue_strict_overflow_warning (wc)) - { - location_t location; - - if (!gimple_has_location (stmt)) - location = input_location; - else - location = gimple_location (stmt); - warning_at (location, OPT_Wstrict_overflow, "%s", warnmsg); - } - } - - if (warn_type_limits - && ret && only_ranges - && TREE_CODE_CLASS (code) == tcc_comparison - && TREE_CODE (op0) == SSA_NAME) - { - /* If the comparison is being folded and the operand on the LHS - is being compared against a constant value that is outside of - the natural range of OP0's type, then the predicate will - always fold regardless of the value of OP0. If -Wtype-limits - was specified, emit a warning. */ - tree type = TREE_TYPE (op0); - value_range *vr0 = get_value_range (op0); - - if (vr0->type == VR_RANGE - && INTEGRAL_TYPE_P (type) - && vrp_val_is_min (vr0->min) - && vrp_val_is_max (vr0->max) - && is_gimple_min_invariant (op1)) - { - location_t location; - - if (!gimple_has_location (stmt)) - location = input_location; - else - location = gimple_location (stmt); - - warning_at (location, OPT_Wtype_limits, - integer_zerop (ret) - ? G_("comparison always false " - "due to limited range of data type") - : G_("comparison always true " - "due to limited range of data type")); - } - } - - return ret; -} - - -/* Visit conditional statement STMT. If we can determine which edge - will be taken out of STMT's basic block, record it in - *TAKEN_EDGE_P. Otherwise, set *TAKEN_EDGE_P to NULL. */ - -void -vr_values::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p) -{ - tree val; - - *taken_edge_p = NULL; - - if (dump_file && (dump_flags & TDF_DETAILS)) - { - tree use; - ssa_op_iter i; - - fprintf (dump_file, "\nVisiting conditional with predicate: "); - print_gimple_stmt (dump_file, stmt, 0); - fprintf (dump_file, "\nWith known ranges\n"); - - FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE) - { - fprintf (dump_file, "\t"); - print_generic_expr (dump_file, use); - fprintf (dump_file, ": "); - dump_value_range (dump_file, vr_value[SSA_NAME_VERSION (use)]); - } - - fprintf (dump_file, "\n"); - } - - /* Compute the value of the predicate COND by checking the known - ranges of each of its operands. - - Note that we cannot evaluate all the equivalent ranges here - because those ranges may not yet be final and with the current - propagation strategy, we cannot determine when the value ranges - of the names in the equivalence set have changed. - - For instance, given the following code fragment - - i_5 = PHI <8, i_13> - ... - i_14 = ASSERT_EXPR - if (i_14 == 1) - ... - - 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 - 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 - the first time, since i_14 is equivalent to the range [8, 8], we - determine that the predicate is always false. - - On the next round of propagation, i_13 is determined to be - 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 - 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 - registered, so vrp_visit_assignment thinks that the range for - i_14 has not changed. Therefore, the predicate 'if (i_14 == 1)' - is not visited again, which stops propagation from visiting - statements in the THEN clause of that if(). - - 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 - discovered that from one visit to the other i_5 changed from - range [8, 8] to VR_VARYING. - - However, fixing this apparent limitation may not be worth the - additional checking. Testing on several code bases (GCC, DLV, - MICO, TRAMP3D and SPEC2000) showed that doing this results in - 4 more predicates folded in SPEC. */ - - bool sop; - val = vrp_evaluate_conditional_warnv_with_ops (gimple_cond_code (stmt), - gimple_cond_lhs (stmt), - gimple_cond_rhs (stmt), - false, &sop, NULL); - if (val) - *taken_edge_p = find_taken_edge (gimple_bb (stmt), val); - - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "\nPredicate evaluates to: "); - if (val == NULL_TREE) - fprintf (dump_file, "DON'T KNOW\n"); - else - print_generic_stmt (dump_file, val); - } -} - -/* Searches the case label vector VEC for the index *IDX of the CASE_LABEL - that includes the value VAL. The search is restricted to the range - [START_IDX, n - 1] where n is the size of VEC. - - If there is a CASE_LABEL for VAL, its index is placed in IDX and true is - returned. - - If there is no CASE_LABEL for VAL and there is one that is larger than VAL, - it is placed in IDX and false is returned. - - If VAL is larger than any CASE_LABEL, n is placed on IDX and false is - returned. */ - -static bool -find_case_label_index (gswitch *stmt, size_t start_idx, tree val, size_t *idx) -{ - size_t n = gimple_switch_num_labels (stmt); - size_t low, high; - - /* Find case label for minimum of the value range or the next one. - At each iteration we are searching in [low, high - 1]. */ - - for (low = start_idx, high = n; high != low; ) - { - tree t; - int cmp; - /* Note that i != high, so we never ask for n. */ - size_t i = (high + low) / 2; - t = gimple_switch_label (stmt, i); - - /* Cache the result of comparing CASE_LOW and val. */ - cmp = tree_int_cst_compare (CASE_LOW (t), val); - - if (cmp == 0) - { - /* Ranges cannot be empty. */ - *idx = i; - return true; - } - else if (cmp > 0) - high = i; - else - { - low = i + 1; - if (CASE_HIGH (t) != NULL - && tree_int_cst_compare (CASE_HIGH (t), val) >= 0) - { - *idx = i; - return true; - } - } - } - - *idx = high; - return false; -} - -/* Searches the case label vector VEC for the range of CASE_LABELs that is used - for values between MIN and MAX. The first index is placed in MIN_IDX. The - last index is placed in MAX_IDX. If the range of CASE_LABELs is empty - then MAX_IDX < MIN_IDX. - Returns true if the default label is not needed. */ - -static bool -find_case_label_range (gswitch *stmt, tree min, tree max, size_t *min_idx, - size_t *max_idx) -{ - size_t i, j; - bool min_take_default = !find_case_label_index (stmt, 1, min, &i); - bool max_take_default = !find_case_label_index (stmt, i, max, &j); - - if (i == j - && min_take_default - && max_take_default) - { - /* Only the default case label reached. - Return an empty range. */ - *min_idx = 1; - *max_idx = 0; - return false; - } - else - { - bool take_default = min_take_default || max_take_default; - tree low, high; - size_t k; - - if (max_take_default) - j--; - - /* If the case label range is continuous, we do not need - the default case label. Verify that. */ - high = CASE_LOW (gimple_switch_label (stmt, i)); - if (CASE_HIGH (gimple_switch_label (stmt, i))) - high = CASE_HIGH (gimple_switch_label (stmt, i)); - for (k = i + 1; k <= j; ++k) - { - low = CASE_LOW (gimple_switch_label (stmt, k)); - if (!integer_onep (int_const_binop (MINUS_EXPR, low, high))) - { - take_default = true; - break; - } - high = low; - if (CASE_HIGH (gimple_switch_label (stmt, k))) - high = CASE_HIGH (gimple_switch_label (stmt, k)); - } - - *min_idx = i; - *max_idx = j; - return !take_default; - } -} - -/* Searches the case label vector VEC for the ranges of CASE_LABELs that are - used in range VR. The indices are placed in MIN_IDX1, MAX_IDX, MIN_IDX2 and - MAX_IDX2. If the ranges of CASE_LABELs are empty then MAX_IDX1 < MIN_IDX1. - Returns true if the default label is not needed. */ - -static bool -find_case_label_ranges (gswitch *stmt, value_range *vr, size_t *min_idx1, - size_t *max_idx1, size_t *min_idx2, - size_t *max_idx2) -{ - size_t i, j, k, l; - unsigned int n = gimple_switch_num_labels (stmt); - bool take_default; - tree case_low, case_high; - tree min = vr->min, max = vr->max; - - gcc_checking_assert (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE); - - take_default = !find_case_label_range (stmt, min, max, &i, &j); - - /* Set second range to emtpy. */ - *min_idx2 = 1; - *max_idx2 = 0; - - if (vr->type == VR_RANGE) - { - *min_idx1 = i; - *max_idx1 = j; - return !take_default; - } - - /* Set first range to all case labels. */ - *min_idx1 = 1; - *max_idx1 = n - 1; - - if (i > j) - return false; - - /* Make sure all the values of case labels [i , j] are contained in - range [MIN, MAX]. */ - case_low = CASE_LOW (gimple_switch_label (stmt, i)); - case_high = CASE_HIGH (gimple_switch_label (stmt, j)); - if (tree_int_cst_compare (case_low, min) < 0) - i += 1; - if (case_high != NULL_TREE - && tree_int_cst_compare (max, case_high) < 0) - j -= 1; - - if (i > j) - return false; - - /* If the range spans case labels [i, j], the corresponding anti-range spans - the labels [1, i - 1] and [j + 1, n - 1]. */ - k = j + 1; - l = n - 1; - if (k > l) - { - k = 1; - l = 0; - } - - j = i - 1; - i = 1; - if (i > j) - { - i = k; - j = l; - k = 1; - l = 0; - } - - *min_idx1 = i; - *max_idx1 = j; - *min_idx2 = k; - *max_idx2 = l; - return false; -} - -/* Visit switch statement STMT. If we can determine which edge - will be taken out of STMT's basic block, record it in - *TAKEN_EDGE_P. Otherwise, *TAKEN_EDGE_P set to NULL. */ - -void -vr_values::vrp_visit_switch_stmt (gswitch *stmt, edge *taken_edge_p) -{ - tree op, val; - value_range *vr; - size_t i = 0, j = 0, k, l; - bool take_default; - - *taken_edge_p = NULL; - op = gimple_switch_index (stmt); - if (TREE_CODE (op) != SSA_NAME) - return; - - vr = get_value_range (op); - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "\nVisiting switch expression with operand "); - print_generic_expr (dump_file, op); - fprintf (dump_file, " with known range "); - dump_value_range (dump_file, vr); - fprintf (dump_file, "\n"); - } - - if ((vr->type != VR_RANGE - && vr->type != VR_ANTI_RANGE) - || symbolic_range_p (vr)) - return; - - /* Find the single edge that is taken from the switch expression. */ - take_default = !find_case_label_ranges (stmt, vr, &i, &j, &k, &l); - - /* Check if the range spans no CASE_LABEL. If so, we only reach the default - label */ - if (j < i) - { - gcc_assert (take_default); - val = gimple_switch_default_label (stmt); - } - else - { - /* Check if labels with index i to j and maybe the default label - are all reaching the same label. */ - - val = gimple_switch_label (stmt, i); - if (take_default - && CASE_LABEL (gimple_switch_default_label (stmt)) - != CASE_LABEL (val)) - { - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, " not a single destination for this " - "range\n"); - return; - } - for (++i; i <= j; ++i) - { - if (CASE_LABEL (gimple_switch_label (stmt, i)) != CASE_LABEL (val)) - { - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, " not a single destination for this " - "range\n"); - return; - } - } - for (; k <= l; ++k) - { - if (CASE_LABEL (gimple_switch_label (stmt, k)) != CASE_LABEL (val)) - { - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, " not a single destination for this " - "range\n"); - return; - } - } - } - - *taken_edge_p = find_edge (gimple_bb (stmt), - label_to_block (CASE_LABEL (val))); - - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, " will take edge to "); - print_generic_stmt (dump_file, CASE_LABEL (val)); - } -} - - -/* Evaluate statement STMT. If the statement produces a useful range, - set VR and corepsponding OUTPUT_P. - - If STMT is a conditional branch and we can determine its truth - value, the taken edge is recorded in *TAKEN_EDGE_P. */ - -void -vr_values::extract_range_from_stmt (gimple *stmt, edge *taken_edge_p, - tree *output_p, value_range *vr) -{ - - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "\nVisiting statement:\n"); - print_gimple_stmt (dump_file, stmt, 0, dump_flags); - } - - if (!stmt_interesting_for_vrp (stmt)) - gcc_assert (stmt_ends_bb_p (stmt)); - else if (is_gimple_assign (stmt) || is_gimple_call (stmt)) - vrp_visit_assignment_or_call (stmt, output_p, vr); - else if (gimple_code (stmt) == GIMPLE_COND) - vrp_visit_cond_stmt (as_a (stmt), taken_edge_p); - else if (gimple_code (stmt) == GIMPLE_SWITCH) - vrp_visit_switch_stmt (as_a (stmt), taken_edge_p); -} - -/* Evaluate statement STMT. If the statement produces a useful range, - return SSA_PROP_INTERESTING and record the SSA name with the - interesting range into *OUTPUT_P. - - If STMT is a conditional branch and we can determine its truth - value, the taken edge is recorded in *TAKEN_EDGE_P. - - If STMT produces a varying value, return SSA_PROP_VARYING. */ - -enum ssa_prop_result -vrp_prop::visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p) -{ - value_range vr = VR_INITIALIZER; - tree lhs = gimple_get_lhs (stmt); - extract_range_from_stmt (stmt, taken_edge_p, output_p, &vr); - - if (*output_p) - { - if (update_value_range (*output_p, &vr)) - { - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "Found new range for "); - print_generic_expr (dump_file, *output_p); - fprintf (dump_file, ": "); - dump_value_range (dump_file, &vr); - fprintf (dump_file, "\n"); - } - - if (vr.type == VR_VARYING) - return SSA_PROP_VARYING; - - return SSA_PROP_INTERESTING; - } - return SSA_PROP_NOT_INTERESTING; - } - - if (is_gimple_call (stmt) && gimple_call_internal_p (stmt)) - switch (gimple_call_internal_fn (stmt)) - { - case IFN_ADD_OVERFLOW: - case IFN_SUB_OVERFLOW: - case IFN_MUL_OVERFLOW: - case IFN_ATOMIC_COMPARE_EXCHANGE: - /* These internal calls return _Complex integer type, - which VRP does not track, but the immediate uses - thereof might be interesting. */ - if (lhs && TREE_CODE (lhs) == SSA_NAME) - { - imm_use_iterator iter; - use_operand_p use_p; - enum ssa_prop_result res = SSA_PROP_VARYING; - - set_value_range_to_varying (get_value_range (lhs)); - - FOR_EACH_IMM_USE_FAST (use_p, iter, lhs) - { - gimple *use_stmt = USE_STMT (use_p); - if (!is_gimple_assign (use_stmt)) - continue; - enum tree_code rhs_code = gimple_assign_rhs_code (use_stmt); - if (rhs_code != REALPART_EXPR && rhs_code != IMAGPART_EXPR) - continue; - tree rhs1 = gimple_assign_rhs1 (use_stmt); - tree use_lhs = gimple_assign_lhs (use_stmt); - if (TREE_CODE (rhs1) != rhs_code - || TREE_OPERAND (rhs1, 0) != lhs - || TREE_CODE (use_lhs) != SSA_NAME - || !stmt_interesting_for_vrp (use_stmt) - || (!INTEGRAL_TYPE_P (TREE_TYPE (use_lhs)) - || !TYPE_MIN_VALUE (TREE_TYPE (use_lhs)) - || !TYPE_MAX_VALUE (TREE_TYPE (use_lhs)))) - continue; - - /* If there is a change in the value range for any of the - REALPART_EXPR/IMAGPART_EXPR immediate uses, return - SSA_PROP_INTERESTING. If there are any REALPART_EXPR - or IMAGPART_EXPR immediate uses, but none of them have - a change in their value ranges, return - SSA_PROP_NOT_INTERESTING. If there are no - {REAL,IMAG}PART_EXPR uses at all, - return SSA_PROP_VARYING. */ - value_range new_vr = VR_INITIALIZER; - extract_range_basic (&new_vr, use_stmt); - value_range *old_vr = get_value_range (use_lhs); - if (old_vr->type != new_vr.type - || !vrp_operand_equal_p (old_vr->min, new_vr.min) - || !vrp_operand_equal_p (old_vr->max, new_vr.max) - || !vrp_bitmap_equal_p (old_vr->equiv, new_vr.equiv)) - res = SSA_PROP_INTERESTING; - else - res = SSA_PROP_NOT_INTERESTING; - BITMAP_FREE (new_vr.equiv); - if (res == SSA_PROP_INTERESTING) - { - *output_p = lhs; - return res; - } - } - - return res; - } - break; - default: - break; - } - - /* All other statements produce nothing of interest for VRP, so mark - their outputs varying and prevent further simulation. */ - set_defs_to_varying (stmt); - - return (*taken_edge_p) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING; -} - -/* Union the two value-ranges { *VR0TYPE, *VR0MIN, *VR0MAX } and - { VR1TYPE, VR0MIN, VR0MAX } and store the result - in { *VR0TYPE, *VR0MIN, *VR0MAX }. This may not be the smallest - possible such range. The resulting range is not canonicalized. */ - -static void -union_ranges (enum value_range_type *vr0type, - tree *vr0min, tree *vr0max, - enum value_range_type vr1type, - tree vr1min, tree vr1max) -{ - bool mineq = vrp_operand_equal_p (*vr0min, vr1min); - bool maxeq = vrp_operand_equal_p (*vr0max, vr1max); - - /* [] is vr0, () is vr1 in the following classification comments. */ - if (mineq && maxeq) - { - /* [( )] */ - if (*vr0type == vr1type) - /* Nothing to do for equal ranges. */ - ; - else if ((*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) - || (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE)) - { - /* For anti-range with range union the result is varying. */ - goto give_up; - } - else - gcc_unreachable (); - } - else if (operand_less_p (*vr0max, vr1min) == 1 - || operand_less_p (vr1max, *vr0min) == 1) - { - /* [ ] ( ) or ( ) [ ] - If the ranges have an empty intersection, result of the union - operation is the anti-range or if both are anti-ranges - it covers all. */ - if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_ANTI_RANGE) - goto give_up; - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE) - ; - else if (*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) - { - *vr0type = vr1type; - *vr0min = vr1min; - *vr0max = vr1max; - } - else if (*vr0type == VR_RANGE - && vr1type == VR_RANGE) - { - /* The result is the convex hull of both ranges. */ - if (operand_less_p (*vr0max, vr1min) == 1) - { - /* If the result can be an anti-range, create one. */ - if (TREE_CODE (*vr0max) == INTEGER_CST - && TREE_CODE (vr1min) == INTEGER_CST - && vrp_val_is_min (*vr0min) - && vrp_val_is_max (vr1max)) - { - tree min = int_const_binop (PLUS_EXPR, - *vr0max, - build_int_cst (TREE_TYPE (*vr0max), 1)); - tree max = int_const_binop (MINUS_EXPR, - vr1min, - build_int_cst (TREE_TYPE (vr1min), 1)); - if (!operand_less_p (max, min)) - { - *vr0type = VR_ANTI_RANGE; - *vr0min = min; - *vr0max = max; - } - else - *vr0max = vr1max; - } - else - *vr0max = vr1max; - } - else - { - /* If the result can be an anti-range, create one. */ - if (TREE_CODE (vr1max) == INTEGER_CST - && TREE_CODE (*vr0min) == INTEGER_CST - && vrp_val_is_min (vr1min) - && vrp_val_is_max (*vr0max)) - { - tree min = int_const_binop (PLUS_EXPR, - vr1max, - build_int_cst (TREE_TYPE (vr1max), 1)); - tree max = int_const_binop (MINUS_EXPR, - *vr0min, - build_int_cst (TREE_TYPE (*vr0min), 1)); - if (!operand_less_p (max, min)) - { - *vr0type = VR_ANTI_RANGE; - *vr0min = min; - *vr0max = max; - } - else - *vr0min = vr1min; - } - else - *vr0min = vr1min; - } - } - else - gcc_unreachable (); - } - else if ((maxeq || operand_less_p (vr1max, *vr0max) == 1) - && (mineq || operand_less_p (*vr0min, vr1min) == 1)) - { - /* [ ( ) ] or [( ) ] or [ ( )] */ - if (*vr0type == VR_RANGE - && vr1type == VR_RANGE) - ; - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_ANTI_RANGE) - { - *vr0type = vr1type; - *vr0min = vr1min; - *vr0max = vr1max; - } - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE) - { - /* Arbitrarily choose the right or left gap. */ - if (!mineq && TREE_CODE (vr1min) == INTEGER_CST) - *vr0max = int_const_binop (MINUS_EXPR, vr1min, - build_int_cst (TREE_TYPE (vr1min), 1)); - else if (!maxeq && TREE_CODE (vr1max) == INTEGER_CST) - *vr0min = int_const_binop (PLUS_EXPR, vr1max, - build_int_cst (TREE_TYPE (vr1max), 1)); - else - goto give_up; - } - else if (*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) - /* The result covers everything. */ - goto give_up; - else - gcc_unreachable (); - } - else if ((maxeq || operand_less_p (*vr0max, vr1max) == 1) - && (mineq || operand_less_p (vr1min, *vr0min) == 1)) - { - /* ( [ ] ) or ([ ] ) or ( [ ]) */ - if (*vr0type == VR_RANGE - && vr1type == VR_RANGE) - { - *vr0type = vr1type; - *vr0min = vr1min; - *vr0max = vr1max; - } - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_ANTI_RANGE) - ; - else if (*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) - { - *vr0type = VR_ANTI_RANGE; - if (!mineq && TREE_CODE (*vr0min) == INTEGER_CST) - { - *vr0max = int_const_binop (MINUS_EXPR, *vr0min, - build_int_cst (TREE_TYPE (*vr0min), 1)); - *vr0min = vr1min; - } - else if (!maxeq && TREE_CODE (*vr0max) == INTEGER_CST) - { - *vr0min = int_const_binop (PLUS_EXPR, *vr0max, - build_int_cst (TREE_TYPE (*vr0max), 1)); - *vr0max = vr1max; - } - else - goto give_up; - } - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE) - /* The result covers everything. */ - goto give_up; - else - gcc_unreachable (); - } - else if ((operand_less_p (vr1min, *vr0max) == 1 - || operand_equal_p (vr1min, *vr0max, 0)) - && operand_less_p (*vr0min, vr1min) == 1 - && operand_less_p (*vr0max, vr1max) == 1) - { - /* [ ( ] ) or [ ]( ) */ - if (*vr0type == VR_RANGE - && vr1type == VR_RANGE) - *vr0max = vr1max; - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_ANTI_RANGE) - *vr0min = vr1min; - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE) - { - if (TREE_CODE (vr1min) == INTEGER_CST) - *vr0max = int_const_binop (MINUS_EXPR, vr1min, - build_int_cst (TREE_TYPE (vr1min), 1)); - else - goto give_up; - } - else if (*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) - { - if (TREE_CODE (*vr0max) == INTEGER_CST) - { - *vr0type = vr1type; - *vr0min = int_const_binop (PLUS_EXPR, *vr0max, - build_int_cst (TREE_TYPE (*vr0max), 1)); - *vr0max = vr1max; - } - else - goto give_up; - } - else - gcc_unreachable (); - } - else if ((operand_less_p (*vr0min, vr1max) == 1 - || operand_equal_p (*vr0min, vr1max, 0)) - && operand_less_p (vr1min, *vr0min) == 1 - && operand_less_p (vr1max, *vr0max) == 1) - { - /* ( [ ) ] or ( )[ ] */ - if (*vr0type == VR_RANGE - && vr1type == VR_RANGE) - *vr0min = vr1min; - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_ANTI_RANGE) - *vr0max = vr1max; - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE) - { - if (TREE_CODE (vr1max) == INTEGER_CST) - *vr0min = int_const_binop (PLUS_EXPR, vr1max, - build_int_cst (TREE_TYPE (vr1max), 1)); - else - goto give_up; - } - else if (*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) - { - if (TREE_CODE (*vr0min) == INTEGER_CST) - { - *vr0type = vr1type; - *vr0min = vr1min; - *vr0max = int_const_binop (MINUS_EXPR, *vr0min, - build_int_cst (TREE_TYPE (*vr0min), 1)); - } - else - goto give_up; - } - else - gcc_unreachable (); - } - else - goto give_up; - - return; - -give_up: - *vr0type = VR_VARYING; - *vr0min = NULL_TREE; - *vr0max = NULL_TREE; -} - -/* Intersect the two value-ranges { *VR0TYPE, *VR0MIN, *VR0MAX } and - { VR1TYPE, VR0MIN, VR0MAX } and store the result - in { *VR0TYPE, *VR0MIN, *VR0MAX }. This may not be the smallest - possible such range. The resulting range is not canonicalized. */ - -static void -intersect_ranges (enum value_range_type *vr0type, - tree *vr0min, tree *vr0max, - enum value_range_type vr1type, - tree vr1min, tree vr1max) -{ - bool mineq = vrp_operand_equal_p (*vr0min, vr1min); - bool maxeq = vrp_operand_equal_p (*vr0max, vr1max); - - /* [] is vr0, () is vr1 in the following classification comments. */ - if (mineq && maxeq) - { - /* [( )] */ - if (*vr0type == vr1type) - /* Nothing to do for equal ranges. */ - ; - else if ((*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) - || (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE)) - { - /* For anti-range with range intersection the result is empty. */ - *vr0type = VR_UNDEFINED; - *vr0min = NULL_TREE; - *vr0max = NULL_TREE; - } - else - gcc_unreachable (); - } - else if (operand_less_p (*vr0max, vr1min) == 1 - || operand_less_p (vr1max, *vr0min) == 1) - { - /* [ ] ( ) or ( ) [ ] - If the ranges have an empty intersection, the result of the - intersect operation is the range for intersecting an - anti-range with a range or empty when intersecting two ranges. */ - if (*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) - ; - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE) - { - *vr0type = vr1type; - *vr0min = vr1min; - *vr0max = vr1max; - } - else if (*vr0type == VR_RANGE - && vr1type == VR_RANGE) - { - *vr0type = VR_UNDEFINED; - *vr0min = NULL_TREE; - *vr0max = NULL_TREE; - } - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_ANTI_RANGE) - { - /* If the anti-ranges are adjacent to each other merge them. */ - if (TREE_CODE (*vr0max) == INTEGER_CST - && TREE_CODE (vr1min) == INTEGER_CST - && operand_less_p (*vr0max, vr1min) == 1 - && integer_onep (int_const_binop (MINUS_EXPR, - vr1min, *vr0max))) - *vr0max = vr1max; - else if (TREE_CODE (vr1max) == INTEGER_CST - && TREE_CODE (*vr0min) == INTEGER_CST - && operand_less_p (vr1max, *vr0min) == 1 - && integer_onep (int_const_binop (MINUS_EXPR, - *vr0min, vr1max))) - *vr0min = vr1min; - /* Else arbitrarily take VR0. */ - } - } - else if ((maxeq || operand_less_p (vr1max, *vr0max) == 1) - && (mineq || operand_less_p (*vr0min, vr1min) == 1)) - { - /* [ ( ) ] or [( ) ] or [ ( )] */ - if (*vr0type == VR_RANGE - && vr1type == VR_RANGE) - { - /* If both are ranges the result is the inner one. */ - *vr0type = vr1type; - *vr0min = vr1min; - *vr0max = vr1max; - } - else if (*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) - { - /* Choose the right gap if the left one is empty. */ - if (mineq) - { - if (TREE_CODE (vr1max) != INTEGER_CST) - *vr0min = vr1max; - else if (TYPE_PRECISION (TREE_TYPE (vr1max)) == 1 - && !TYPE_UNSIGNED (TREE_TYPE (vr1max))) - *vr0min - = int_const_binop (MINUS_EXPR, vr1max, - build_int_cst (TREE_TYPE (vr1max), -1)); - else - *vr0min - = int_const_binop (PLUS_EXPR, vr1max, - build_int_cst (TREE_TYPE (vr1max), 1)); - } - /* Choose the left gap if the right one is empty. */ - else if (maxeq) - { - if (TREE_CODE (vr1min) != INTEGER_CST) - *vr0max = vr1min; - else if (TYPE_PRECISION (TREE_TYPE (vr1min)) == 1 - && !TYPE_UNSIGNED (TREE_TYPE (vr1min))) - *vr0max - = int_const_binop (PLUS_EXPR, vr1min, - build_int_cst (TREE_TYPE (vr1min), -1)); - else - *vr0max - = int_const_binop (MINUS_EXPR, vr1min, - build_int_cst (TREE_TYPE (vr1min), 1)); - } - /* Choose the anti-range if the range is effectively varying. */ - else if (vrp_val_is_min (*vr0min) - && vrp_val_is_max (*vr0max)) - { - *vr0type = vr1type; - *vr0min = vr1min; - *vr0max = vr1max; - } - /* Else choose the range. */ - } - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_ANTI_RANGE) - /* If both are anti-ranges the result is the outer one. */ - ; - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE) - { - /* The intersection is empty. */ - *vr0type = VR_UNDEFINED; - *vr0min = NULL_TREE; - *vr0max = NULL_TREE; - } - else - gcc_unreachable (); - } - else if ((maxeq || operand_less_p (*vr0max, vr1max) == 1) - && (mineq || operand_less_p (vr1min, *vr0min) == 1)) - { - /* ( [ ] ) or ([ ] ) or ( [ ]) */ - if (*vr0type == VR_RANGE - && vr1type == VR_RANGE) - /* Choose the inner range. */ - ; - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE) - { - /* Choose the right gap if the left is empty. */ - if (mineq) - { - *vr0type = VR_RANGE; - if (TREE_CODE (*vr0max) != INTEGER_CST) - *vr0min = *vr0max; - else if (TYPE_PRECISION (TREE_TYPE (*vr0max)) == 1 - && !TYPE_UNSIGNED (TREE_TYPE (*vr0max))) - *vr0min - = int_const_binop (MINUS_EXPR, *vr0max, - build_int_cst (TREE_TYPE (*vr0max), -1)); - else - *vr0min - = int_const_binop (PLUS_EXPR, *vr0max, - build_int_cst (TREE_TYPE (*vr0max), 1)); - *vr0max = vr1max; - } - /* Choose the left gap if the right is empty. */ - else if (maxeq) - { - *vr0type = VR_RANGE; - if (TREE_CODE (*vr0min) != INTEGER_CST) - *vr0max = *vr0min; - else if (TYPE_PRECISION (TREE_TYPE (*vr0min)) == 1 - && !TYPE_UNSIGNED (TREE_TYPE (*vr0min))) - *vr0max - = int_const_binop (PLUS_EXPR, *vr0min, - build_int_cst (TREE_TYPE (*vr0min), -1)); - else - *vr0max - = int_const_binop (MINUS_EXPR, *vr0min, - build_int_cst (TREE_TYPE (*vr0min), 1)); - *vr0min = vr1min; - } - /* Choose the anti-range if the range is effectively varying. */ - else if (vrp_val_is_min (vr1min) - && vrp_val_is_max (vr1max)) - ; - /* Choose the anti-range if it is ~[0,0], that range is special - enough to special case when vr1's range is relatively wide. */ - else if (*vr0min == *vr0max - && integer_zerop (*vr0min) - && (TYPE_PRECISION (TREE_TYPE (*vr0min)) - == TYPE_PRECISION (ptr_type_node)) - && TREE_CODE (vr1max) == INTEGER_CST - && TREE_CODE (vr1min) == INTEGER_CST - && (wi::clz (wi::to_wide (vr1max) - wi::to_wide (vr1min)) - < TYPE_PRECISION (TREE_TYPE (*vr0min)) / 2)) - ; - /* Else choose the range. */ - else - { - *vr0type = vr1type; - *vr0min = vr1min; - *vr0max = vr1max; - } - } - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_ANTI_RANGE) - { - /* If both are anti-ranges the result is the outer one. */ - *vr0type = vr1type; - *vr0min = vr1min; - *vr0max = vr1max; - } - else if (vr1type == VR_ANTI_RANGE - && *vr0type == VR_RANGE) - { - /* The intersection is empty. */ - *vr0type = VR_UNDEFINED; - *vr0min = NULL_TREE; - *vr0max = NULL_TREE; - } - else - gcc_unreachable (); + tree res = gimple_phi_result (stmt); + return (!virtual_operand_p (res) + && (INTEGRAL_TYPE_P (TREE_TYPE (res)) + || POINTER_TYPE_P (TREE_TYPE (res)))); } - else if ((operand_less_p (vr1min, *vr0max) == 1 - || operand_equal_p (vr1min, *vr0max, 0)) - && operand_less_p (*vr0min, vr1min) == 1) + else if (is_gimple_assign (stmt) || is_gimple_call (stmt)) { - /* [ ( ] ) or [ ]( ) */ - if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_ANTI_RANGE) - *vr0max = vr1max; - else if (*vr0type == VR_RANGE - && vr1type == VR_RANGE) - *vr0min = vr1min; - else if (*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) - { - if (TREE_CODE (vr1min) == INTEGER_CST) - *vr0max = int_const_binop (MINUS_EXPR, vr1min, - build_int_cst (TREE_TYPE (vr1min), 1)); - else - *vr0max = vr1min; - } - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE) - { - *vr0type = VR_RANGE; - if (TREE_CODE (*vr0max) == INTEGER_CST) - *vr0min = int_const_binop (PLUS_EXPR, *vr0max, - build_int_cst (TREE_TYPE (*vr0max), 1)); - else - *vr0min = *vr0max; - *vr0max = vr1max; - } - else - gcc_unreachable (); + tree lhs = gimple_get_lhs (stmt); + + /* In general, assignments with virtual operands are not useful + for deriving ranges, with the obvious exception of calls to + builtin functions. */ + if (lhs && TREE_CODE (lhs) == SSA_NAME + && (INTEGRAL_TYPE_P (TREE_TYPE (lhs)) + || POINTER_TYPE_P (TREE_TYPE (lhs))) + && (is_gimple_call (stmt) + || !gimple_vuse (stmt))) + return true; + else if (is_gimple_call (stmt) && gimple_call_internal_p (stmt)) + switch (gimple_call_internal_fn (stmt)) + { + case IFN_ADD_OVERFLOW: + case IFN_SUB_OVERFLOW: + case IFN_MUL_OVERFLOW: + case IFN_ATOMIC_COMPARE_EXCHANGE: + /* These internal calls return _Complex integer type, + but are interesting to VRP nevertheless. */ + if (lhs && TREE_CODE (lhs) == SSA_NAME) + return true; + break; + default: + break; + } } - else if ((operand_less_p (*vr0min, vr1max) == 1 - || operand_equal_p (*vr0min, vr1max, 0)) - && operand_less_p (vr1min, *vr0min) == 1) + else if (gimple_code (stmt) == GIMPLE_COND + || gimple_code (stmt) == GIMPLE_SWITCH) + return true; + + return false; +} + +/* Initialization required by ssa_propagate engine. */ + +void +vrp_prop::vrp_initialize () +{ + basic_block bb; + + FOR_EACH_BB_FN (bb, cfun) { - /* ( [ ) ] or ( )[ ] */ - if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_ANTI_RANGE) - *vr0min = vr1min; - else if (*vr0type == VR_RANGE - && vr1type == VR_RANGE) - *vr0max = vr1max; - else if (*vr0type == VR_RANGE - && vr1type == VR_ANTI_RANGE) + for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si); + gsi_next (&si)) { - if (TREE_CODE (vr1max) == INTEGER_CST) - *vr0min = int_const_binop (PLUS_EXPR, vr1max, - build_int_cst (TREE_TYPE (vr1max), 1)); + gphi *phi = si.phi (); + if (!stmt_interesting_for_vrp (phi)) + { + tree lhs = PHI_RESULT (phi); + set_value_range_to_varying (get_value_range (lhs)); + prop_set_simulate_again (phi, false); + } else - *vr0min = vr1max; + prop_set_simulate_again (phi, true); } - else if (*vr0type == VR_ANTI_RANGE - && vr1type == VR_RANGE) - { - *vr0type = VR_RANGE; - if (TREE_CODE (*vr0min) == INTEGER_CST) - *vr0max = int_const_binop (MINUS_EXPR, *vr0min, - build_int_cst (TREE_TYPE (*vr0min), 1)); + + for (gimple_stmt_iterator si = gsi_start_bb (bb); !gsi_end_p (si); + gsi_next (&si)) + { + gimple *stmt = gsi_stmt (si); + + /* If the statement is a control insn, then we do not + want to avoid simulating the statement once. Failure + to do so means that those edges will never get added. */ + if (stmt_ends_bb_p (stmt)) + prop_set_simulate_again (stmt, true); + else if (!stmt_interesting_for_vrp (stmt)) + { + set_defs_to_varying (stmt); + prop_set_simulate_again (stmt, false); + } else - *vr0max = *vr0min; - *vr0min = vr1min; + prop_set_simulate_again (stmt, true); } - else - gcc_unreachable (); } +} - /* As a fallback simply use { *VRTYPE, *VR0MIN, *VR0MAX } as - result for the intersection. That's always a conservative - correct estimate unless VR1 is a constant singleton range - in which case we choose that. */ - if (vr1type == VR_RANGE - && is_gimple_min_invariant (vr1min) - && vrp_operand_equal_p (vr1min, vr1max)) - { - *vr0type = vr1type; - *vr0min = vr1min; - *vr0max = vr1max; - } +/* Searches the case label vector VEC for the index *IDX of the CASE_LABEL + that includes the value VAL. The search is restricted to the range + [START_IDX, n - 1] where n is the size of VEC. - return; -} + If there is a CASE_LABEL for VAL, its index is placed in IDX and true is + returned. + If there is no CASE_LABEL for VAL and there is one that is larger than VAL, + it is placed in IDX and false is returned. -/* Intersect the two value-ranges *VR0 and *VR1 and store the result - in *VR0. This may not be the smallest possible such range. */ + If VAL is larger than any CASE_LABEL, n is placed on IDX and false is + returned. */ -static void -vrp_intersect_ranges_1 (value_range *vr0, value_range *vr1) +bool +find_case_label_index (gswitch *stmt, size_t start_idx, tree val, size_t *idx) { - value_range saved; + size_t n = gimple_switch_num_labels (stmt); + size_t low, high; - /* If either range is VR_VARYING the other one wins. */ - if (vr1->type == VR_VARYING) - return; - if (vr0->type == VR_VARYING) - { - copy_value_range (vr0, vr1); - return; - } + /* Find case label for minimum of the value range or the next one. + At each iteration we are searching in [low, high - 1]. */ - /* When either range is VR_UNDEFINED the resulting range is - VR_UNDEFINED, too. */ - if (vr0->type == VR_UNDEFINED) - return; - if (vr1->type == VR_UNDEFINED) + for (low = start_idx, high = n; high != low; ) { - set_value_range_to_undefined (vr0); - return; - } + tree t; + int cmp; + /* Note that i != high, so we never ask for n. */ + size_t i = (high + low) / 2; + t = gimple_switch_label (stmt, i); - /* Save the original vr0 so we can return it as conservative intersection - result when our worker turns things to varying. */ - saved = *vr0; - intersect_ranges (&vr0->type, &vr0->min, &vr0->max, - vr1->type, vr1->min, vr1->max); - /* Make sure to canonicalize the result though as the inversion of a - VR_RANGE can still be a VR_RANGE. */ - set_and_canonicalize_value_range (vr0, vr0->type, - vr0->min, vr0->max, vr0->equiv); - /* If that failed, use the saved original VR0. */ - if (vr0->type == VR_VARYING) - { - *vr0 = saved; - return; - } - /* If the result is VR_UNDEFINED there is no need to mess with - the equivalencies. */ - if (vr0->type == VR_UNDEFINED) - return; + /* Cache the result of comparing CASE_LOW and val. */ + cmp = tree_int_cst_compare (CASE_LOW (t), val); - /* The resulting set of equivalences for range intersection is the union of - the two sets. */ - if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv) - bitmap_ior_into (vr0->equiv, vr1->equiv); - else if (vr1->equiv && !vr0->equiv) - { - /* All equivalence bitmaps are allocated from the same obstack. So - we can use the obstack associated with VR to allocate vr0->equiv. */ - vr0->equiv = BITMAP_ALLOC (vr1->equiv->obstack); - bitmap_copy (vr0->equiv, vr1->equiv); + if (cmp == 0) + { + /* Ranges cannot be empty. */ + *idx = i; + return true; + } + else if (cmp > 0) + high = i; + else + { + low = i + 1; + if (CASE_HIGH (t) != NULL + && tree_int_cst_compare (CASE_HIGH (t), val) >= 0) + { + *idx = i; + return true; + } + } } + + *idx = high; + return false; } -void -vrp_intersect_ranges (value_range *vr0, value_range *vr1) +/* Searches the case label vector VEC for the range of CASE_LABELs that is used + for values between MIN and MAX. The first index is placed in MIN_IDX. The + last index is placed in MAX_IDX. If the range of CASE_LABELs is empty + then MAX_IDX < MIN_IDX. + Returns true if the default label is not needed. */ + +bool +find_case_label_range (gswitch *stmt, tree min, tree max, size_t *min_idx, + size_t *max_idx) { - if (dump_file && (dump_flags & TDF_DETAILS)) + size_t i, j; + bool min_take_default = !find_case_label_index (stmt, 1, min, &i); + bool max_take_default = !find_case_label_index (stmt, i, max, &j); + + if (i == j + && min_take_default + && max_take_default) { - fprintf (dump_file, "Intersecting\n "); - dump_value_range (dump_file, vr0); - fprintf (dump_file, "\nand\n "); - dump_value_range (dump_file, vr1); - fprintf (dump_file, "\n"); + /* Only the default case label reached. + Return an empty range. */ + *min_idx = 1; + *max_idx = 0; + return false; } - vrp_intersect_ranges_1 (vr0, vr1); - if (dump_file && (dump_flags & TDF_DETAILS)) + else { - fprintf (dump_file, "to\n "); - dump_value_range (dump_file, vr0); - fprintf (dump_file, "\n"); + bool take_default = min_take_default || max_take_default; + tree low, high; + size_t k; + + if (max_take_default) + j--; + + /* If the case label range is continuous, we do not need + the default case label. Verify that. */ + high = CASE_LOW (gimple_switch_label (stmt, i)); + if (CASE_HIGH (gimple_switch_label (stmt, i))) + high = CASE_HIGH (gimple_switch_label (stmt, i)); + for (k = i + 1; k <= j; ++k) + { + low = CASE_LOW (gimple_switch_label (stmt, k)); + if (!integer_onep (int_const_binop (MINUS_EXPR, low, high))) + { + take_default = true; + break; + } + high = low; + if (CASE_HIGH (gimple_switch_label (stmt, k))) + high = CASE_HIGH (gimple_switch_label (stmt, k)); + } + + *min_idx = i; + *max_idx = j; + return !take_default; } } -/* Meet operation for value ranges. Given two value ranges VR0 and - VR1, store in VR0 a range that contains both VR0 and VR1. This - may not be the smallest possible such range. */ +/* Evaluate statement STMT. If the statement produces a useful range, + return SSA_PROP_INTERESTING and record the SSA name with the + interesting range into *OUTPUT_P. -static void -vrp_meet_1 (value_range *vr0, const value_range *vr1) + If STMT is a conditional branch and we can determine its truth + value, the taken edge is recorded in *TAKEN_EDGE_P. + + If STMT produces a varying value, return SSA_PROP_VARYING. */ + +enum ssa_prop_result +vrp_prop::visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p) { - value_range saved; + value_range vr = VR_INITIALIZER; + tree lhs = gimple_get_lhs (stmt); + extract_range_from_stmt (stmt, taken_edge_p, output_p, &vr); - if (vr0->type == VR_UNDEFINED) + if (*output_p) { - set_value_range (vr0, vr1->type, vr1->min, vr1->max, vr1->equiv); - return; - } + if (update_value_range (*output_p, &vr)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "Found new range for "); + print_generic_expr (dump_file, *output_p); + fprintf (dump_file, ": "); + dump_value_range (dump_file, &vr); + fprintf (dump_file, "\n"); + } - if (vr1->type == VR_UNDEFINED) - { - /* VR0 already has the resulting range. */ - return; - } + if (vr.type == VR_VARYING) + return SSA_PROP_VARYING; - if (vr0->type == VR_VARYING) - { - /* Nothing to do. VR0 already has the resulting range. */ - return; + return SSA_PROP_INTERESTING; + } + return SSA_PROP_NOT_INTERESTING; } - if (vr1->type == VR_VARYING) - { - set_value_range_to_varying (vr0); - return; - } + if (is_gimple_call (stmt) && gimple_call_internal_p (stmt)) + switch (gimple_call_internal_fn (stmt)) + { + case IFN_ADD_OVERFLOW: + case IFN_SUB_OVERFLOW: + case IFN_MUL_OVERFLOW: + case IFN_ATOMIC_COMPARE_EXCHANGE: + /* These internal calls return _Complex integer type, + which VRP does not track, but the immediate uses + thereof might be interesting. */ + if (lhs && TREE_CODE (lhs) == SSA_NAME) + { + imm_use_iterator iter; + use_operand_p use_p; + enum ssa_prop_result res = SSA_PROP_VARYING; - saved = *vr0; - union_ranges (&vr0->type, &vr0->min, &vr0->max, - vr1->type, vr1->min, vr1->max); - if (vr0->type == VR_VARYING) - { - /* Failed to find an efficient meet. Before giving up and setting - the result to VARYING, see if we can at least derive a useful - anti-range. FIXME, all this nonsense about distinguishing - anti-ranges from ranges is necessary because of the odd - semantics of range_includes_zero_p and friends. */ - if (((saved.type == VR_RANGE - && range_includes_zero_p (saved.min, saved.max) == 0) - || (saved.type == VR_ANTI_RANGE - && range_includes_zero_p (saved.min, saved.max) == 1)) - && ((vr1->type == VR_RANGE - && range_includes_zero_p (vr1->min, vr1->max) == 0) - || (vr1->type == VR_ANTI_RANGE - && range_includes_zero_p (vr1->min, vr1->max) == 1))) - { - set_value_range_to_nonnull (vr0, TREE_TYPE (saved.min)); + set_value_range_to_varying (get_value_range (lhs)); - /* Since this meet operation did not result from the meeting of - two equivalent names, VR0 cannot have any equivalences. */ - if (vr0->equiv) - bitmap_clear (vr0->equiv); - return; - } + FOR_EACH_IMM_USE_FAST (use_p, iter, lhs) + { + gimple *use_stmt = USE_STMT (use_p); + if (!is_gimple_assign (use_stmt)) + continue; + enum tree_code rhs_code = gimple_assign_rhs_code (use_stmt); + if (rhs_code != REALPART_EXPR && rhs_code != IMAGPART_EXPR) + continue; + tree rhs1 = gimple_assign_rhs1 (use_stmt); + tree use_lhs = gimple_assign_lhs (use_stmt); + if (TREE_CODE (rhs1) != rhs_code + || TREE_OPERAND (rhs1, 0) != lhs + || TREE_CODE (use_lhs) != SSA_NAME + || !stmt_interesting_for_vrp (use_stmt) + || (!INTEGRAL_TYPE_P (TREE_TYPE (use_lhs)) + || !TYPE_MIN_VALUE (TREE_TYPE (use_lhs)) + || !TYPE_MAX_VALUE (TREE_TYPE (use_lhs)))) + continue; - set_value_range_to_varying (vr0); - return; - } - set_and_canonicalize_value_range (vr0, vr0->type, vr0->min, vr0->max, - vr0->equiv); - if (vr0->type == VR_VARYING) - return; + /* If there is a change in the value range for any of the + REALPART_EXPR/IMAGPART_EXPR immediate uses, return + SSA_PROP_INTERESTING. If there are any REALPART_EXPR + or IMAGPART_EXPR immediate uses, but none of them have + a change in their value ranges, return + SSA_PROP_NOT_INTERESTING. If there are no + {REAL,IMAG}PART_EXPR uses at all, + return SSA_PROP_VARYING. */ + value_range new_vr = VR_INITIALIZER; + extract_range_basic (&new_vr, use_stmt); + value_range *old_vr = get_value_range (use_lhs); + if (old_vr->type != new_vr.type + || !vrp_operand_equal_p (old_vr->min, new_vr.min) + || !vrp_operand_equal_p (old_vr->max, new_vr.max) + || !vrp_bitmap_equal_p (old_vr->equiv, new_vr.equiv)) + res = SSA_PROP_INTERESTING; + else + res = SSA_PROP_NOT_INTERESTING; + BITMAP_FREE (new_vr.equiv); + if (res == SSA_PROP_INTERESTING) + { + *output_p = lhs; + return res; + } + } - /* The resulting set of equivalences is always the intersection of - the two sets. */ - if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv) - bitmap_and_into (vr0->equiv, vr1->equiv); - else if (vr0->equiv && !vr1->equiv) - bitmap_clear (vr0->equiv); -} + return res; + } + break; + default: + break; + } -void -vrp_meet (value_range *vr0, const value_range *vr1) -{ - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "Meeting\n "); - dump_value_range (dump_file, vr0); - fprintf (dump_file, "\nand\n "); - dump_value_range (dump_file, vr1); - fprintf (dump_file, "\n"); - } - vrp_meet_1 (vr0, vr1); - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "to\n "); - dump_value_range (dump_file, vr0); - fprintf (dump_file, "\n"); - } -} + /* All other statements produce nothing of interest for VRP, so mark + their outputs varying and prevent further simulation. */ + set_defs_to_varying (stmt); + return (*taken_edge_p) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING; +} -/* Visit all arguments for PHI node PHI that flow through executable - edges. If a valid value range can be derived from all the incoming - value ranges, set a new range in VR_RESULT. */ +/* Union the two value-ranges { *VR0TYPE, *VR0MIN, *VR0MAX } and + { VR1TYPE, VR0MIN, VR0MAX } and store the result + in { *VR0TYPE, *VR0MIN, *VR0MAX }. This may not be the smallest + possible such range. The resulting range is not canonicalized. */ -void -vr_values::extract_range_from_phi_node (gphi *phi, value_range *vr_result) +static void +union_ranges (enum value_range_type *vr0type, + tree *vr0min, tree *vr0max, + enum value_range_type vr1type, + tree vr1min, tree vr1max) { - size_t i; - tree lhs = PHI_RESULT (phi); - value_range *lhs_vr = get_value_range (lhs); - bool first = true; - int edges, old_edges; - struct loop *l; + bool mineq = vrp_operand_equal_p (*vr0min, vr1min); + bool maxeq = vrp_operand_equal_p (*vr0max, vr1max); - if (dump_file && (dump_flags & TDF_DETAILS)) + /* [] is vr0, () is vr1 in the following classification comments. */ + if (mineq && maxeq) { - fprintf (dump_file, "\nVisiting PHI node: "); - print_gimple_stmt (dump_file, phi, 0, dump_flags); + /* [( )] */ + if (*vr0type == vr1type) + /* Nothing to do for equal ranges. */ + ; + else if ((*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) + || (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE)) + { + /* For anti-range with range union the result is varying. */ + goto give_up; + } + else + gcc_unreachable (); } - - bool may_simulate_backedge_again = false; - edges = 0; - for (i = 0; i < gimple_phi_num_args (phi); i++) + else if (operand_less_p (*vr0max, vr1min) == 1 + || operand_less_p (vr1max, *vr0min) == 1) { - edge e = gimple_phi_arg_edge (phi, i); - - if (dump_file && (dump_flags & TDF_DETAILS)) + /* [ ] ( ) or ( ) [ ] + If the ranges have an empty intersection, result of the union + operation is the anti-range or if both are anti-ranges + it covers all. */ + if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_ANTI_RANGE) + goto give_up; + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE) + ; + else if (*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) { - fprintf (dump_file, - " Argument #%d (%d -> %d %sexecutable)\n", - (int) i, e->src->index, e->dest->index, - (e->flags & EDGE_EXECUTABLE) ? "" : "not "); + *vr0type = vr1type; + *vr0min = vr1min; + *vr0max = vr1max; } - - if (e->flags & EDGE_EXECUTABLE) + else if (*vr0type == VR_RANGE + && vr1type == VR_RANGE) { - tree arg = PHI_ARG_DEF (phi, i); - value_range vr_arg; - - ++edges; - - if (TREE_CODE (arg) == SSA_NAME) + /* The result is the convex hull of both ranges. */ + if (operand_less_p (*vr0max, vr1min) == 1) { - /* See if we are eventually going to change one of the args. */ - gimple *def_stmt = SSA_NAME_DEF_STMT (arg); - if (! gimple_nop_p (def_stmt) - && prop_simulate_again_p (def_stmt) - && e->flags & EDGE_DFS_BACK) - may_simulate_backedge_again = true; - - vr_arg = *(get_value_range (arg)); - /* Do not allow equivalences or symbolic ranges to leak in from - backedges. That creates invalid equivalencies. - See PR53465 and PR54767. */ - if (e->flags & EDGE_DFS_BACK) + /* If the result can be an anti-range, create one. */ + if (TREE_CODE (*vr0max) == INTEGER_CST + && TREE_CODE (vr1min) == INTEGER_CST + && vrp_val_is_min (*vr0min) + && vrp_val_is_max (vr1max)) { - if (vr_arg.type == VR_RANGE - || vr_arg.type == VR_ANTI_RANGE) + tree min = int_const_binop (PLUS_EXPR, + *vr0max, + build_int_cst (TREE_TYPE (*vr0max), 1)); + tree max = int_const_binop (MINUS_EXPR, + vr1min, + build_int_cst (TREE_TYPE (vr1min), 1)); + if (!operand_less_p (max, min)) { - vr_arg.equiv = NULL; - if (symbolic_range_p (&vr_arg)) - { - vr_arg.type = VR_VARYING; - vr_arg.min = NULL_TREE; - vr_arg.max = NULL_TREE; - } + *vr0type = VR_ANTI_RANGE; + *vr0min = min; + *vr0max = max; } + else + *vr0max = vr1max; } else + *vr0max = vr1max; + } + else + { + /* If the result can be an anti-range, create one. */ + if (TREE_CODE (vr1max) == INTEGER_CST + && TREE_CODE (*vr0min) == INTEGER_CST + && vrp_val_is_min (vr1min) + && vrp_val_is_max (*vr0max)) { - /* If the non-backedge arguments range is VR_VARYING then - we can still try recording a simple equivalence. */ - if (vr_arg.type == VR_VARYING) + tree min = int_const_binop (PLUS_EXPR, + vr1max, + build_int_cst (TREE_TYPE (vr1max), 1)); + tree max = int_const_binop (MINUS_EXPR, + *vr0min, + build_int_cst (TREE_TYPE (*vr0min), 1)); + if (!operand_less_p (max, min)) { - vr_arg.type = VR_RANGE; - vr_arg.min = arg; - vr_arg.max = arg; - vr_arg.equiv = NULL; + *vr0type = VR_ANTI_RANGE; + *vr0min = min; + *vr0max = max; } + else + *vr0min = vr1min; } + else + *vr0min = vr1min; } - else - { - if (TREE_OVERFLOW_P (arg)) - arg = drop_tree_overflow (arg); - - vr_arg.type = VR_RANGE; - vr_arg.min = arg; - vr_arg.max = arg; - vr_arg.equiv = NULL; - } - - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "\t"); - print_generic_expr (dump_file, arg, dump_flags); - fprintf (dump_file, ": "); - dump_value_range (dump_file, &vr_arg); - fprintf (dump_file, "\n"); - } - - if (first) - copy_value_range (vr_result, &vr_arg); - else - vrp_meet (vr_result, &vr_arg); - first = false; - - if (vr_result->type == VR_VARYING) - break; - } - } - - if (vr_result->type == VR_VARYING) - goto varying; - else if (vr_result->type == VR_UNDEFINED) - goto update_range; - - old_edges = vr_phi_edge_counts[SSA_NAME_VERSION (lhs)]; - vr_phi_edge_counts[SSA_NAME_VERSION (lhs)] = edges; - - /* To prevent infinite iterations in the algorithm, derive ranges - when the new value is slightly bigger or smaller than the - previous one. We don't do this if we have seen a new executable - edge; this helps us avoid an infinity for conditionals - which are not in a loop. If the old value-range was VR_UNDEFINED - use the updated range and iterate one more time. If we will not - simulate this PHI again via the backedge allow us to iterate. */ - if (edges > 0 - && gimple_phi_num_args (phi) > 1 - && edges == old_edges - && lhs_vr->type != VR_UNDEFINED - && may_simulate_backedge_again) - { - /* Compare old and new ranges, fall back to varying if the - values are not comparable. */ - int cmp_min = compare_values (lhs_vr->min, vr_result->min); - if (cmp_min == -2) - goto varying; - int cmp_max = compare_values (lhs_vr->max, vr_result->max); - if (cmp_max == -2) - goto varying; - - /* For non VR_RANGE or for pointers fall back to varying if - the range changed. */ - if ((lhs_vr->type != VR_RANGE || vr_result->type != VR_RANGE - || POINTER_TYPE_P (TREE_TYPE (lhs))) - && (cmp_min != 0 || cmp_max != 0)) - goto varying; - - /* If the new minimum is larger than the previous one - retain the old value. If the new minimum value is smaller - than the previous one and not -INF go all the way to -INF + 1. - In the first case, to avoid infinite bouncing between different - minimums, and in the other case to avoid iterating millions of - times to reach -INF. Going to -INF + 1 also lets the following - iteration compute whether there will be any overflow, at the - expense of one additional iteration. */ - if (cmp_min < 0) - vr_result->min = lhs_vr->min; - else if (cmp_min > 0 - && !vrp_val_is_min (vr_result->min)) - vr_result->min - = int_const_binop (PLUS_EXPR, - vrp_val_min (TREE_TYPE (vr_result->min)), - build_int_cst (TREE_TYPE (vr_result->min), 1)); - - /* Similarly for the maximum value. */ - if (cmp_max > 0) - vr_result->max = lhs_vr->max; - else if (cmp_max < 0 - && !vrp_val_is_max (vr_result->max)) - vr_result->max - = int_const_binop (MINUS_EXPR, - vrp_val_max (TREE_TYPE (vr_result->min)), - build_int_cst (TREE_TYPE (vr_result->min), 1)); - - /* If we dropped either bound to +-INF then if this is a loop - PHI node SCEV may known more about its value-range. */ - if (cmp_min > 0 || cmp_min < 0 - || cmp_max < 0 || cmp_max > 0) - goto scev_check; - - goto infinite_check; - } - - goto update_range; - -varying: - set_value_range_to_varying (vr_result); - -scev_check: - /* If this is a loop PHI node SCEV may known more about its value-range. - scev_check can be reached from two paths, one is a fall through from above - "varying" label, the other is direct goto from code block which tries to - avoid infinite simulation. */ - if ((l = loop_containing_stmt (phi)) - && l->header == gimple_bb (phi)) - adjust_range_with_scev (vr_result, l, phi, lhs); - -infinite_check: - /* If we will end up with a (-INF, +INF) range, set it to - VARYING. Same if the previous max value was invalid for - the type and we end up with vr_result.min > vr_result.max. */ - if ((vr_result->type == VR_RANGE || vr_result->type == VR_ANTI_RANGE) - && !((vrp_val_is_max (vr_result->max) && vrp_val_is_min (vr_result->min)) - || compare_values (vr_result->min, vr_result->max) > 0)) - ; - else - set_value_range_to_varying (vr_result); - - /* If the new range is different than the previous value, keep - iterating. */ -update_range: - return; -} - -/* Visit all arguments for PHI node PHI that flow through executable - edges. If a valid value range can be derived from all the incoming - value ranges, set a new range for the LHS of PHI. */ - -enum ssa_prop_result -vrp_prop::visit_phi (gphi *phi) -{ - tree lhs = PHI_RESULT (phi); - value_range vr_result = VR_INITIALIZER; - extract_range_from_phi_node (phi, &vr_result); - if (update_value_range (lhs, &vr_result)) - { - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "Found new range for "); - print_generic_expr (dump_file, lhs); - fprintf (dump_file, ": "); - dump_value_range (dump_file, &vr_result); - fprintf (dump_file, "\n"); } - - if (vr_result.type == VR_VARYING) - return SSA_PROP_VARYING; - - return SSA_PROP_INTERESTING; - } - - /* Nothing changed, don't add outgoing edges. */ - return SSA_PROP_NOT_INTERESTING; -} - -/* Simplify boolean operations if the source is known - to be already a boolean. */ -bool -vr_values::simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, - gimple *stmt) -{ - enum tree_code rhs_code = gimple_assign_rhs_code (stmt); - tree lhs, op0, op1; - bool need_conversion; - - /* We handle only !=/== case here. */ - gcc_assert (rhs_code == EQ_EXPR || rhs_code == NE_EXPR); - - op0 = gimple_assign_rhs1 (stmt); - if (!op_with_boolean_value_range_p (op0)) - return false; - - op1 = gimple_assign_rhs2 (stmt); - if (!op_with_boolean_value_range_p (op1)) - return false; - - /* Reduce number of cases to handle to NE_EXPR. As there is no - BIT_XNOR_EXPR we cannot replace A == B with a single statement. */ - if (rhs_code == EQ_EXPR) - { - if (TREE_CODE (op1) == INTEGER_CST) - op1 = int_const_binop (BIT_XOR_EXPR, op1, - build_int_cst (TREE_TYPE (op1), 1)); else - return false; - } - - lhs = gimple_assign_lhs (stmt); - need_conversion - = !useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (op0)); - - /* Make sure to not sign-extend a 1-bit 1 when converting the result. */ - if (need_conversion - && !TYPE_UNSIGNED (TREE_TYPE (op0)) - && TYPE_PRECISION (TREE_TYPE (op0)) == 1 - && TYPE_PRECISION (TREE_TYPE (lhs)) > 1) - return false; - - /* For A != 0 we can substitute A itself. */ - if (integer_zerop (op1)) - gimple_assign_set_rhs_with_ops (gsi, - need_conversion - ? NOP_EXPR : TREE_CODE (op0), op0); - /* For A != B we substitute A ^ B. Either with conversion. */ - else if (need_conversion) - { - tree tem = make_ssa_name (TREE_TYPE (op0)); - gassign *newop - = gimple_build_assign (tem, BIT_XOR_EXPR, op0, op1); - gsi_insert_before (gsi, newop, GSI_SAME_STMT); - if (INTEGRAL_TYPE_P (TREE_TYPE (tem)) - && TYPE_PRECISION (TREE_TYPE (tem)) > 1) - set_range_info (tem, VR_RANGE, - wi::zero (TYPE_PRECISION (TREE_TYPE (tem))), - wi::one (TYPE_PRECISION (TREE_TYPE (tem)))); - gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, tem); - } - /* Or without. */ - else - gimple_assign_set_rhs_with_ops (gsi, BIT_XOR_EXPR, op0, op1); - update_stmt (gsi_stmt (*gsi)); - fold_stmt (gsi, follow_single_use_edges); - - return true; -} - -/* Simplify a division or modulo operator to a right shift or bitwise and - if the first operand is unsigned or is greater than zero and the second - operand is an exact power of two. For TRUNC_MOD_EXPR op0 % op1 with - constant op1 (op1min = op1) or with op1 in [op1min, op1max] range, - optimize it into just op0 if op0's range is known to be a subset of - [-op1min + 1, op1min - 1] for signed and [0, op1min - 1] for unsigned - modulo. */ - -bool -vr_values::simplify_div_or_mod_using_ranges (gimple_stmt_iterator *gsi, - gimple *stmt) -{ - enum tree_code rhs_code = gimple_assign_rhs_code (stmt); - tree val = NULL; - tree op0 = gimple_assign_rhs1 (stmt); - tree op1 = gimple_assign_rhs2 (stmt); - tree op0min = NULL_TREE, op0max = NULL_TREE; - tree op1min = op1; - value_range *vr = NULL; - - if (TREE_CODE (op0) == INTEGER_CST) - { - op0min = op0; - op0max = op0; - } - else - { - vr = get_value_range (op0); - if (range_int_cst_p (vr)) - { - op0min = vr->min; - op0max = vr->max; - } - } - - if (rhs_code == TRUNC_MOD_EXPR - && TREE_CODE (op1) == SSA_NAME) - { - value_range *vr1 = get_value_range (op1); - if (range_int_cst_p (vr1)) - op1min = vr1->min; + gcc_unreachable (); } - if (rhs_code == TRUNC_MOD_EXPR - && TREE_CODE (op1min) == INTEGER_CST - && tree_int_cst_sgn (op1min) == 1 - && op0max - && tree_int_cst_lt (op0max, op1min)) + else if ((maxeq || operand_less_p (vr1max, *vr0max) == 1) + && (mineq || operand_less_p (*vr0min, vr1min) == 1)) { - if (TYPE_UNSIGNED (TREE_TYPE (op0)) - || tree_int_cst_sgn (op0min) >= 0 - || tree_int_cst_lt (fold_unary (NEGATE_EXPR, TREE_TYPE (op1min), op1min), - op0min)) + /* [ ( ) ] or [( ) ] or [ ( )] */ + if (*vr0type == VR_RANGE + && vr1type == VR_RANGE) + ; + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_ANTI_RANGE) { - /* If op0 already has the range op0 % op1 has, - then TRUNC_MOD_EXPR won't change anything. */ - gimple_assign_set_rhs_from_tree (gsi, op0); - return true; + *vr0type = vr1type; + *vr0min = vr1min; + *vr0max = vr1max; } - } - - if (TREE_CODE (op0) != SSA_NAME) - return false; - - if (!integer_pow2p (op1)) - { - /* X % -Y can be only optimized into X % Y either if - X is not INT_MIN, or Y is not -1. Fold it now, as after - remove_range_assertions the range info might be not available - anymore. */ - if (rhs_code == TRUNC_MOD_EXPR - && fold_stmt (gsi, follow_single_use_edges)) - return true; - return false; - } - - if (TYPE_UNSIGNED (TREE_TYPE (op0))) - val = integer_one_node; - else - { - bool sop = false; - - val = compare_range_with_value (GE_EXPR, vr, integer_zero_node, &sop); - - if (val - && sop - && integer_onep (val) - && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)) + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE) { - location_t location; - - if (!gimple_has_location (stmt)) - location = input_location; + /* Arbitrarily choose the right or left gap. */ + if (!mineq && TREE_CODE (vr1min) == INTEGER_CST) + *vr0max = int_const_binop (MINUS_EXPR, vr1min, + build_int_cst (TREE_TYPE (vr1min), 1)); + else if (!maxeq && TREE_CODE (vr1max) == INTEGER_CST) + *vr0min = int_const_binop (PLUS_EXPR, vr1max, + build_int_cst (TREE_TYPE (vr1max), 1)); else - location = gimple_location (stmt); - warning_at (location, OPT_Wstrict_overflow, - "assuming signed overflow does not occur when " - "simplifying % or %<%%%> to %<>>%> or %<&%>"); + goto give_up; } + else if (*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) + /* The result covers everything. */ + goto give_up; + else + gcc_unreachable (); } - - if (val && integer_onep (val)) + else if ((maxeq || operand_less_p (*vr0max, vr1max) == 1) + && (mineq || operand_less_p (vr1min, *vr0min) == 1)) { - tree t; - - if (rhs_code == TRUNC_DIV_EXPR) + /* ( [ ] ) or ([ ] ) or ( [ ]) */ + if (*vr0type == VR_RANGE + && vr1type == VR_RANGE) { - t = build_int_cst (integer_type_node, tree_log2 (op1)); - gimple_assign_set_rhs_code (stmt, RSHIFT_EXPR); - gimple_assign_set_rhs1 (stmt, op0); - gimple_assign_set_rhs2 (stmt, t); + *vr0type = vr1type; + *vr0min = vr1min; + *vr0max = vr1max; } - else + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_ANTI_RANGE) + ; + else if (*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) { - t = build_int_cst (TREE_TYPE (op1), 1); - t = int_const_binop (MINUS_EXPR, op1, t); - t = fold_convert (TREE_TYPE (op0), t); - - gimple_assign_set_rhs_code (stmt, BIT_AND_EXPR); - gimple_assign_set_rhs1 (stmt, op0); - gimple_assign_set_rhs2 (stmt, t); + *vr0type = VR_ANTI_RANGE; + if (!mineq && TREE_CODE (*vr0min) == INTEGER_CST) + { + *vr0max = int_const_binop (MINUS_EXPR, *vr0min, + build_int_cst (TREE_TYPE (*vr0min), 1)); + *vr0min = vr1min; + } + else if (!maxeq && TREE_CODE (*vr0max) == INTEGER_CST) + { + *vr0min = int_const_binop (PLUS_EXPR, *vr0max, + build_int_cst (TREE_TYPE (*vr0max), 1)); + *vr0max = vr1max; + } + else + goto give_up; } - - update_stmt (stmt); - fold_stmt (gsi, follow_single_use_edges); - return true; - } - - return false; -} - -/* Simplify a min or max if the ranges of the two operands are - disjoint. Return true if we do simplify. */ - -bool -vr_values::simplify_min_or_max_using_ranges (gimple_stmt_iterator *gsi, - gimple *stmt) -{ - tree op0 = gimple_assign_rhs1 (stmt); - tree op1 = gimple_assign_rhs2 (stmt); - bool sop = false; - tree val; - - val = (vrp_evaluate_conditional_warnv_with_ops_using_ranges - (LE_EXPR, op0, op1, &sop)); - if (!val) - { - sop = false; - val = (vrp_evaluate_conditional_warnv_with_ops_using_ranges - (LT_EXPR, op0, op1, &sop)); + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE) + /* The result covers everything. */ + goto give_up; + else + gcc_unreachable (); } - - if (val) + else if ((operand_less_p (vr1min, *vr0max) == 1 + || operand_equal_p (vr1min, *vr0max, 0)) + && operand_less_p (*vr0min, vr1min) == 1 + && operand_less_p (*vr0max, vr1max) == 1) { - if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)) + /* [ ( ] ) or [ ]( ) */ + if (*vr0type == VR_RANGE + && vr1type == VR_RANGE) + *vr0max = vr1max; + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_ANTI_RANGE) + *vr0min = vr1min; + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE) { - location_t location; - - if (!gimple_has_location (stmt)) - location = input_location; + if (TREE_CODE (vr1min) == INTEGER_CST) + *vr0max = int_const_binop (MINUS_EXPR, vr1min, + build_int_cst (TREE_TYPE (vr1min), 1)); else - location = gimple_location (stmt); - warning_at (location, OPT_Wstrict_overflow, - "assuming signed overflow does not occur when " - "simplifying % to % or %"); + goto give_up; } - - /* VAL == TRUE -> OP0 < or <= op1 - VAL == FALSE -> OP0 > or >= op1. */ - tree res = ((gimple_assign_rhs_code (stmt) == MAX_EXPR) - == integer_zerop (val)) ? op0 : op1; - gimple_assign_set_rhs_from_tree (gsi, res); - return true; + else if (*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) + { + if (TREE_CODE (*vr0max) == INTEGER_CST) + { + *vr0type = vr1type; + *vr0min = int_const_binop (PLUS_EXPR, *vr0max, + build_int_cst (TREE_TYPE (*vr0max), 1)); + *vr0max = vr1max; + } + else + goto give_up; + } + else + gcc_unreachable (); } - - return false; -} - -/* If the operand to an ABS_EXPR is >= 0, then eliminate the - ABS_EXPR. If the operand is <= 0, then simplify the - ABS_EXPR into a NEGATE_EXPR. */ - -bool -vr_values::simplify_abs_using_ranges (gimple_stmt_iterator *gsi, gimple *stmt) -{ - tree op = gimple_assign_rhs1 (stmt); - value_range *vr = get_value_range (op); - - if (vr) + else if ((operand_less_p (*vr0min, vr1max) == 1 + || operand_equal_p (*vr0min, vr1max, 0)) + && operand_less_p (vr1min, *vr0min) == 1 + && operand_less_p (vr1max, *vr0max) == 1) { - tree val = NULL; - bool sop = false; - - val = compare_range_with_value (LE_EXPR, vr, integer_zero_node, &sop); - if (!val) + /* ( [ ) ] or ( )[ ] */ + if (*vr0type == VR_RANGE + && vr1type == VR_RANGE) + *vr0min = vr1min; + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_ANTI_RANGE) + *vr0max = vr1max; + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE) { - /* The range is neither <= 0 nor > 0. Now see if it is - either < 0 or >= 0. */ - sop = false; - val = compare_range_with_value (LT_EXPR, vr, integer_zero_node, - &sop); + if (TREE_CODE (vr1max) == INTEGER_CST) + *vr0min = int_const_binop (PLUS_EXPR, vr1max, + build_int_cst (TREE_TYPE (vr1max), 1)); + else + goto give_up; } - - if (val) + else if (*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) { - if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)) + if (TREE_CODE (*vr0min) == INTEGER_CST) { - location_t location; - - if (!gimple_has_location (stmt)) - location = input_location; - else - location = gimple_location (stmt); - warning_at (location, OPT_Wstrict_overflow, - "assuming signed overflow does not occur when " - "simplifying % to % or %<-X%>"); + *vr0type = vr1type; + *vr0min = vr1min; + *vr0max = int_const_binop (MINUS_EXPR, *vr0min, + build_int_cst (TREE_TYPE (*vr0min), 1)); } - - gimple_assign_set_rhs1 (stmt, op); - if (integer_zerop (val)) - gimple_assign_set_rhs_code (stmt, SSA_NAME); else - gimple_assign_set_rhs_code (stmt, NEGATE_EXPR); - update_stmt (stmt); - fold_stmt (gsi, follow_single_use_edges); - return true; + goto give_up; } + else + gcc_unreachable (); } + else + goto give_up; - return false; + return; + +give_up: + *vr0type = VR_VARYING; + *vr0min = NULL_TREE; + *vr0max = NULL_TREE; } -/* Optimize away redundant BIT_AND_EXPR and BIT_IOR_EXPR. - If all the bits that are being cleared by & are already - known to be zero from VR, or all the bits that are being - set by | are already known to be one from VR, the bit - operation is redundant. */ +/* Intersect the two value-ranges { *VR0TYPE, *VR0MIN, *VR0MAX } and + { VR1TYPE, VR0MIN, VR0MAX } and store the result + in { *VR0TYPE, *VR0MIN, *VR0MAX }. This may not be the smallest + possible such range. The resulting range is not canonicalized. */ -bool -vr_values::simplify_bit_ops_using_ranges (gimple_stmt_iterator *gsi, - gimple *stmt) +static void +intersect_ranges (enum value_range_type *vr0type, + tree *vr0min, tree *vr0max, + enum value_range_type vr1type, + tree vr1min, tree vr1max) { - tree op0 = gimple_assign_rhs1 (stmt); - tree op1 = gimple_assign_rhs2 (stmt); - tree op = NULL_TREE; - value_range vr0 = VR_INITIALIZER; - value_range vr1 = VR_INITIALIZER; - wide_int may_be_nonzero0, may_be_nonzero1; - wide_int must_be_nonzero0, must_be_nonzero1; - wide_int mask; - - if (TREE_CODE (op0) == SSA_NAME) - vr0 = *(get_value_range (op0)); - else if (is_gimple_min_invariant (op0)) - set_value_range_to_value (&vr0, op0, NULL); - else - return false; - - if (TREE_CODE (op1) == SSA_NAME) - vr1 = *(get_value_range (op1)); - else if (is_gimple_min_invariant (op1)) - set_value_range_to_value (&vr1, op1, NULL); - else - return false; - - if (!zero_nonzero_bits_from_vr (TREE_TYPE (op0), &vr0, &may_be_nonzero0, - &must_be_nonzero0)) - return false; - if (!zero_nonzero_bits_from_vr (TREE_TYPE (op1), &vr1, &may_be_nonzero1, - &must_be_nonzero1)) - return false; + bool mineq = vrp_operand_equal_p (*vr0min, vr1min); + bool maxeq = vrp_operand_equal_p (*vr0max, vr1max); - switch (gimple_assign_rhs_code (stmt)) + /* [] is vr0, () is vr1 in the following classification comments. */ + if (mineq && maxeq) { - case BIT_AND_EXPR: - mask = wi::bit_and_not (may_be_nonzero0, must_be_nonzero1); - if (mask == 0) - { - op = op0; - break; - } - mask = wi::bit_and_not (may_be_nonzero1, must_be_nonzero0); - if (mask == 0) + /* [( )] */ + if (*vr0type == vr1type) + /* Nothing to do for equal ranges. */ + ; + else if ((*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) + || (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE)) { - op = op1; - break; + /* For anti-range with range intersection the result is empty. */ + *vr0type = VR_UNDEFINED; + *vr0min = NULL_TREE; + *vr0max = NULL_TREE; } - break; - case BIT_IOR_EXPR: - mask = wi::bit_and_not (may_be_nonzero0, must_be_nonzero1); - if (mask == 0) + else + gcc_unreachable (); + } + else if (operand_less_p (*vr0max, vr1min) == 1 + || operand_less_p (vr1max, *vr0min) == 1) + { + /* [ ] ( ) or ( ) [ ] + If the ranges have an empty intersection, the result of the + intersect operation is the range for intersecting an + anti-range with a range or empty when intersecting two ranges. */ + if (*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) + ; + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE) { - op = op1; - break; + *vr0type = vr1type; + *vr0min = vr1min; + *vr0max = vr1max; } - mask = wi::bit_and_not (may_be_nonzero1, must_be_nonzero0); - if (mask == 0) + else if (*vr0type == VR_RANGE + && vr1type == VR_RANGE) { - op = op0; - break; + *vr0type = VR_UNDEFINED; + *vr0min = NULL_TREE; + *vr0max = NULL_TREE; } - break; - default: - gcc_unreachable (); - } - - if (op == NULL_TREE) - return false; - - gimple_assign_set_rhs_with_ops (gsi, TREE_CODE (op), op); - update_stmt (gsi_stmt (*gsi)); - return true; -} - -/* We are comparing trees OP0 and OP1 using COND_CODE. OP0 has - a known value range VR. - - If there is one and only one value which will satisfy the - conditional, then return that value. Else return NULL. - - If signed overflow must be undefined for the value to satisfy - the conditional, then set *STRICT_OVERFLOW_P to true. */ - -static tree -test_for_singularity (enum tree_code cond_code, tree op0, - tree op1, value_range *vr) -{ - tree min = NULL; - tree max = NULL; - - /* Extract minimum/maximum values which satisfy the conditional as it was - written. */ - if (cond_code == LE_EXPR || cond_code == LT_EXPR) - { - min = TYPE_MIN_VALUE (TREE_TYPE (op0)); - - max = op1; - if (cond_code == LT_EXPR) + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_ANTI_RANGE) { - tree one = build_int_cst (TREE_TYPE (op0), 1); - max = fold_build2 (MINUS_EXPR, TREE_TYPE (op0), max, one); - /* Signal to compare_values_warnv this expr doesn't overflow. */ - if (EXPR_P (max)) - TREE_NO_WARNING (max) = 1; + /* If the anti-ranges are adjacent to each other merge them. */ + if (TREE_CODE (*vr0max) == INTEGER_CST + && TREE_CODE (vr1min) == INTEGER_CST + && operand_less_p (*vr0max, vr1min) == 1 + && integer_onep (int_const_binop (MINUS_EXPR, + vr1min, *vr0max))) + *vr0max = vr1max; + else if (TREE_CODE (vr1max) == INTEGER_CST + && TREE_CODE (*vr0min) == INTEGER_CST + && operand_less_p (vr1max, *vr0min) == 1 + && integer_onep (int_const_binop (MINUS_EXPR, + *vr0min, vr1max))) + *vr0min = vr1min; + /* Else arbitrarily take VR0. */ } } - else if (cond_code == GE_EXPR || cond_code == GT_EXPR) + else if ((maxeq || operand_less_p (vr1max, *vr0max) == 1) + && (mineq || operand_less_p (*vr0min, vr1min) == 1)) { - max = TYPE_MAX_VALUE (TREE_TYPE (op0)); - - min = op1; - if (cond_code == GT_EXPR) + /* [ ( ) ] or [( ) ] or [ ( )] */ + if (*vr0type == VR_RANGE + && vr1type == VR_RANGE) { - tree one = build_int_cst (TREE_TYPE (op0), 1); - min = fold_build2 (PLUS_EXPR, TREE_TYPE (op0), min, one); - /* Signal to compare_values_warnv this expr doesn't overflow. */ - if (EXPR_P (min)) - TREE_NO_WARNING (min) = 1; + /* If both are ranges the result is the inner one. */ + *vr0type = vr1type; + *vr0min = vr1min; + *vr0max = vr1max; } - } - - /* Now refine the minimum and maximum values using any - value range information we have for op0. */ - if (min && max) - { - if (compare_values (vr->min, min) == 1) - min = vr->min; - if (compare_values (vr->max, max) == -1) - max = vr->max; - - /* If the new min/max values have converged to a single value, - then there is only one value which can satisfy the condition, - return that value. */ - if (operand_equal_p (min, max, 0) && is_gimple_min_invariant (min)) - return min; - } - return NULL; -} - -/* Return whether the value range *VR fits in an integer type specified - by PRECISION and UNSIGNED_P. */ - -static bool -range_fits_type_p (value_range *vr, unsigned dest_precision, signop dest_sgn) -{ - tree src_type; - unsigned src_precision; - widest_int tem; - signop src_sgn; - - /* We can only handle integral and pointer types. */ - src_type = TREE_TYPE (vr->min); - if (!INTEGRAL_TYPE_P (src_type) - && !POINTER_TYPE_P (src_type)) - return false; - - /* An extension is fine unless VR is SIGNED and dest_sgn is UNSIGNED, - and so is an identity transform. */ - src_precision = TYPE_PRECISION (TREE_TYPE (vr->min)); - src_sgn = TYPE_SIGN (src_type); - if ((src_precision < dest_precision - && !(dest_sgn == UNSIGNED && src_sgn == SIGNED)) - || (src_precision == dest_precision && src_sgn == dest_sgn)) - return true; - - /* Now we can only handle ranges with constant bounds. */ - if (vr->type != VR_RANGE - || TREE_CODE (vr->min) != INTEGER_CST - || TREE_CODE (vr->max) != INTEGER_CST) - return false; - - /* For sign changes, the MSB of the wide_int has to be clear. - An unsigned value with its MSB set cannot be represented by - a signed wide_int, while a negative value cannot be represented - by an unsigned wide_int. */ - if (src_sgn != dest_sgn - && (wi::lts_p (wi::to_wide (vr->min), 0) - || wi::lts_p (wi::to_wide (vr->max), 0))) - return false; - - /* Then we can perform the conversion on both ends and compare - the result for equality. */ - tem = wi::ext (wi::to_widest (vr->min), dest_precision, dest_sgn); - if (tem != wi::to_widest (vr->min)) - return false; - tem = wi::ext (wi::to_widest (vr->max), dest_precision, dest_sgn); - if (tem != wi::to_widest (vr->max)) - return false; - - return true; -} - -/* Simplify a conditional using a relational operator to an equality - test if the range information indicates only one value can satisfy - the original conditional. */ - -bool -vr_values::simplify_cond_using_ranges_1 (gcond *stmt) -{ - tree op0 = gimple_cond_lhs (stmt); - tree op1 = gimple_cond_rhs (stmt); - enum tree_code cond_code = gimple_cond_code (stmt); - - if (cond_code != NE_EXPR - && cond_code != EQ_EXPR - && TREE_CODE (op0) == SSA_NAME - && INTEGRAL_TYPE_P (TREE_TYPE (op0)) - && is_gimple_min_invariant (op1)) - { - value_range *vr = get_value_range (op0); - - /* If we have range information for OP0, then we might be - able to simplify this conditional. */ - if (vr->type == VR_RANGE) + else if (*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) { - tree new_tree = test_for_singularity (cond_code, op0, op1, vr); - if (new_tree) + /* Choose the right gap if the left one is empty. */ + if (mineq) { - if (dump_file) - { - fprintf (dump_file, "Simplified relational "); - print_gimple_stmt (dump_file, stmt, 0); - fprintf (dump_file, " into "); - } - - gimple_cond_set_code (stmt, EQ_EXPR); - gimple_cond_set_lhs (stmt, op0); - gimple_cond_set_rhs (stmt, new_tree); - - update_stmt (stmt); - - if (dump_file) - { - print_gimple_stmt (dump_file, stmt, 0); - fprintf (dump_file, "\n"); - } - - return true; + if (TREE_CODE (vr1max) != INTEGER_CST) + *vr0min = vr1max; + else if (TYPE_PRECISION (TREE_TYPE (vr1max)) == 1 + && !TYPE_UNSIGNED (TREE_TYPE (vr1max))) + *vr0min + = int_const_binop (MINUS_EXPR, vr1max, + build_int_cst (TREE_TYPE (vr1max), -1)); + else + *vr0min + = int_const_binop (PLUS_EXPR, vr1max, + build_int_cst (TREE_TYPE (vr1max), 1)); + } + /* Choose the left gap if the right one is empty. */ + else if (maxeq) + { + if (TREE_CODE (vr1min) != INTEGER_CST) + *vr0max = vr1min; + else if (TYPE_PRECISION (TREE_TYPE (vr1min)) == 1 + && !TYPE_UNSIGNED (TREE_TYPE (vr1min))) + *vr0max + = int_const_binop (PLUS_EXPR, vr1min, + build_int_cst (TREE_TYPE (vr1min), -1)); + else + *vr0max + = int_const_binop (MINUS_EXPR, vr1min, + build_int_cst (TREE_TYPE (vr1min), 1)); } - - /* Try again after inverting the condition. We only deal - with integral types here, so no need to worry about - issues with inverting FP comparisons. */ - new_tree = test_for_singularity - (invert_tree_comparison (cond_code, false), - op0, op1, vr); - if (new_tree) + /* Choose the anti-range if the range is effectively varying. */ + else if (vrp_val_is_min (*vr0min) + && vrp_val_is_max (*vr0max)) { - if (dump_file) - { - fprintf (dump_file, "Simplified relational "); - print_gimple_stmt (dump_file, stmt, 0); - fprintf (dump_file, " into "); - } - - gimple_cond_set_code (stmt, NE_EXPR); - gimple_cond_set_lhs (stmt, op0); - gimple_cond_set_rhs (stmt, new_tree); - - update_stmt (stmt); - - if (dump_file) - { - print_gimple_stmt (dump_file, stmt, 0); - fprintf (dump_file, "\n"); - } - - return true; + *vr0type = vr1type; + *vr0min = vr1min; + *vr0max = vr1max; } + /* Else choose the range. */ + } + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_ANTI_RANGE) + /* If both are anti-ranges the result is the outer one. */ + ; + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE) + { + /* The intersection is empty. */ + *vr0type = VR_UNDEFINED; + *vr0min = NULL_TREE; + *vr0max = NULL_TREE; } + else + gcc_unreachable (); } - return false; -} - -/* STMT is a conditional at the end of a basic block. - - If the conditional is of the form SSA_NAME op constant and the SSA_NAME - was set via a type conversion, try to replace the SSA_NAME with the RHS - of the type conversion. Doing so makes the conversion dead which helps - subsequent passes. */ - -void -vr_values::simplify_cond_using_ranges_2 (gcond *stmt) -{ - tree op0 = gimple_cond_lhs (stmt); - tree op1 = gimple_cond_rhs (stmt); - - /* If we have a comparison of an SSA_NAME (OP0) against a constant, - see if OP0 was set by a type conversion where the source of - the conversion is another SSA_NAME with a range that fits - into the range of OP0's type. - - If so, the conversion is redundant as the earlier SSA_NAME can be - used for the comparison directly if we just massage the constant in the - comparison. */ - if (TREE_CODE (op0) == SSA_NAME - && TREE_CODE (op1) == INTEGER_CST) + else if ((maxeq || operand_less_p (*vr0max, vr1max) == 1) + && (mineq || operand_less_p (vr1min, *vr0min) == 1)) { - gimple *def_stmt = SSA_NAME_DEF_STMT (op0); - tree innerop; - - if (!is_gimple_assign (def_stmt) - || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))) - return; - - innerop = gimple_assign_rhs1 (def_stmt); - - if (TREE_CODE (innerop) == SSA_NAME - && !POINTER_TYPE_P (TREE_TYPE (innerop)) - && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (innerop) - && desired_pro_or_demotion_p (TREE_TYPE (innerop), TREE_TYPE (op0))) + /* ( [ ] ) or ([ ] ) or ( [ ]) */ + if (*vr0type == VR_RANGE + && vr1type == VR_RANGE) + /* Choose the inner range. */ + ; + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE) { - value_range *vr = get_value_range (innerop); - - if (range_int_cst_p (vr) - && range_fits_type_p (vr, - TYPE_PRECISION (TREE_TYPE (op0)), - TYPE_SIGN (TREE_TYPE (op0))) - && int_fits_type_p (op1, TREE_TYPE (innerop))) + /* Choose the right gap if the left is empty. */ + if (mineq) { - tree newconst = fold_convert (TREE_TYPE (innerop), op1); - gimple_cond_set_lhs (stmt, innerop); - gimple_cond_set_rhs (stmt, newconst); - update_stmt (stmt); - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "Folded into: "); - print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); - fprintf (dump_file, "\n"); - } + *vr0type = VR_RANGE; + if (TREE_CODE (*vr0max) != INTEGER_CST) + *vr0min = *vr0max; + else if (TYPE_PRECISION (TREE_TYPE (*vr0max)) == 1 + && !TYPE_UNSIGNED (TREE_TYPE (*vr0max))) + *vr0min + = int_const_binop (MINUS_EXPR, *vr0max, + build_int_cst (TREE_TYPE (*vr0max), -1)); + else + *vr0min + = int_const_binop (PLUS_EXPR, *vr0max, + build_int_cst (TREE_TYPE (*vr0max), 1)); + *vr0max = vr1max; + } + /* Choose the left gap if the right is empty. */ + else if (maxeq) + { + *vr0type = VR_RANGE; + if (TREE_CODE (*vr0min) != INTEGER_CST) + *vr0max = *vr0min; + else if (TYPE_PRECISION (TREE_TYPE (*vr0min)) == 1 + && !TYPE_UNSIGNED (TREE_TYPE (*vr0min))) + *vr0max + = int_const_binop (PLUS_EXPR, *vr0min, + build_int_cst (TREE_TYPE (*vr0min), -1)); + else + *vr0max + = int_const_binop (MINUS_EXPR, *vr0min, + build_int_cst (TREE_TYPE (*vr0min), 1)); + *vr0min = vr1min; + } + /* Choose the anti-range if the range is effectively varying. */ + else if (vrp_val_is_min (vr1min) + && vrp_val_is_max (vr1max)) + ; + /* Choose the anti-range if it is ~[0,0], that range is special + enough to special case when vr1's range is relatively wide. */ + else if (*vr0min == *vr0max + && integer_zerop (*vr0min) + && (TYPE_PRECISION (TREE_TYPE (*vr0min)) + == TYPE_PRECISION (ptr_type_node)) + && TREE_CODE (vr1max) == INTEGER_CST + && TREE_CODE (vr1min) == INTEGER_CST + && (wi::clz (wi::to_wide (vr1max) - wi::to_wide (vr1min)) + < TYPE_PRECISION (TREE_TYPE (*vr0min)) / 2)) + ; + /* Else choose the range. */ + else + { + *vr0type = vr1type; + *vr0min = vr1min; + *vr0max = vr1max; } } + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_ANTI_RANGE) + { + /* If both are anti-ranges the result is the outer one. */ + *vr0type = vr1type; + *vr0min = vr1min; + *vr0max = vr1max; + } + else if (vr1type == VR_ANTI_RANGE + && *vr0type == VR_RANGE) + { + /* The intersection is empty. */ + *vr0type = VR_UNDEFINED; + *vr0min = NULL_TREE; + *vr0max = NULL_TREE; + } + else + gcc_unreachable (); } -} - -/* Simplify a switch statement using the value range of the switch - argument. */ - -bool -vr_values::simplify_switch_using_ranges (gswitch *stmt) -{ - tree op = gimple_switch_index (stmt); - value_range *vr = NULL; - bool take_default; - edge e; - edge_iterator ei; - size_t i = 0, j = 0, n, n2; - tree vec2; - switch_update su; - size_t k = 1, l = 0; - - if (TREE_CODE (op) == SSA_NAME) - { - vr = get_value_range (op); - - /* We can only handle integer ranges. */ - if ((vr->type != VR_RANGE - && vr->type != VR_ANTI_RANGE) - || symbolic_range_p (vr)) - return false; - - /* Find case label for min/max of the value range. */ - take_default = !find_case_label_ranges (stmt, vr, &i, &j, &k, &l); - } - else if (TREE_CODE (op) == INTEGER_CST) + else if ((operand_less_p (vr1min, *vr0max) == 1 + || operand_equal_p (vr1min, *vr0max, 0)) + && operand_less_p (*vr0min, vr1min) == 1) { - take_default = !find_case_label_index (stmt, 1, op, &i); - if (take_default) + /* [ ( ] ) or [ ]( ) */ + if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_ANTI_RANGE) + *vr0max = vr1max; + else if (*vr0type == VR_RANGE + && vr1type == VR_RANGE) + *vr0min = vr1min; + else if (*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) { - i = 1; - j = 0; + if (TREE_CODE (vr1min) == INTEGER_CST) + *vr0max = int_const_binop (MINUS_EXPR, vr1min, + build_int_cst (TREE_TYPE (vr1min), 1)); + else + *vr0max = vr1min; } - else + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE) { - j = i; + *vr0type = VR_RANGE; + if (TREE_CODE (*vr0max) == INTEGER_CST) + *vr0min = int_const_binop (PLUS_EXPR, *vr0max, + build_int_cst (TREE_TYPE (*vr0max), 1)); + else + *vr0min = *vr0max; + *vr0max = vr1max; } + else + gcc_unreachable (); } - else - return false; - - n = gimple_switch_num_labels (stmt); - - /* We can truncate the case label ranges that partially overlap with OP's - value range. */ - size_t min_idx = 1, max_idx = 0; - if (vr != NULL) - find_case_label_range (stmt, vr->min, vr->max, &min_idx, &max_idx); - if (min_idx <= max_idx) + else if ((operand_less_p (*vr0min, vr1max) == 1 + || operand_equal_p (*vr0min, vr1max, 0)) + && operand_less_p (vr1min, *vr0min) == 1) { - tree min_label = gimple_switch_label (stmt, min_idx); - tree max_label = gimple_switch_label (stmt, max_idx); - - /* Avoid changing the type of the case labels when truncating. */ - tree case_label_type = TREE_TYPE (CASE_LOW (min_label)); - tree vr_min = fold_convert (case_label_type, vr->min); - tree vr_max = fold_convert (case_label_type, vr->max); - - if (vr->type == VR_RANGE) + /* ( [ ) ] or ( )[ ] */ + if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_ANTI_RANGE) + *vr0min = vr1min; + else if (*vr0type == VR_RANGE + && vr1type == VR_RANGE) + *vr0max = vr1max; + else if (*vr0type == VR_RANGE + && vr1type == VR_ANTI_RANGE) { - /* If OP's value range is [2,8] and the low label range is - 0 ... 3, truncate the label's range to 2 .. 3. */ - if (tree_int_cst_compare (CASE_LOW (min_label), vr_min) < 0 - && CASE_HIGH (min_label) != NULL_TREE - && tree_int_cst_compare (CASE_HIGH (min_label), vr_min) >= 0) - CASE_LOW (min_label) = vr_min; - - /* If OP's value range is [2,8] and the high label range is - 7 ... 10, truncate the label's range to 7 .. 8. */ - if (tree_int_cst_compare (CASE_LOW (max_label), vr_max) <= 0 - && CASE_HIGH (max_label) != NULL_TREE - && tree_int_cst_compare (CASE_HIGH (max_label), vr_max) > 0) - CASE_HIGH (max_label) = vr_max; + if (TREE_CODE (vr1max) == INTEGER_CST) + *vr0min = int_const_binop (PLUS_EXPR, vr1max, + build_int_cst (TREE_TYPE (vr1max), 1)); + else + *vr0min = vr1max; } - else if (vr->type == VR_ANTI_RANGE) + else if (*vr0type == VR_ANTI_RANGE + && vr1type == VR_RANGE) { - tree one_cst = build_one_cst (case_label_type); - - if (min_label == max_label) - { - /* If OP's value range is ~[7,8] and the label's range is - 7 ... 10, truncate the label's range to 9 ... 10. */ - if (tree_int_cst_compare (CASE_LOW (min_label), vr_min) == 0 - && CASE_HIGH (min_label) != NULL_TREE - && tree_int_cst_compare (CASE_HIGH (min_label), vr_max) > 0) - CASE_LOW (min_label) - = int_const_binop (PLUS_EXPR, vr_max, one_cst); - - /* If OP's value range is ~[7,8] and the label's range is - 5 ... 8, truncate the label's range to 5 ... 6. */ - if (tree_int_cst_compare (CASE_LOW (min_label), vr_min) < 0 - && CASE_HIGH (min_label) != NULL_TREE - && tree_int_cst_compare (CASE_HIGH (min_label), vr_max) == 0) - CASE_HIGH (min_label) - = int_const_binop (MINUS_EXPR, vr_min, one_cst); - } + *vr0type = VR_RANGE; + if (TREE_CODE (*vr0min) == INTEGER_CST) + *vr0max = int_const_binop (MINUS_EXPR, *vr0min, + build_int_cst (TREE_TYPE (*vr0min), 1)); else - { - /* If OP's value range is ~[2,8] and the low label range is - 0 ... 3, truncate the label's range to 0 ... 1. */ - if (tree_int_cst_compare (CASE_LOW (min_label), vr_min) < 0 - && CASE_HIGH (min_label) != NULL_TREE - && tree_int_cst_compare (CASE_HIGH (min_label), vr_min) >= 0) - CASE_HIGH (min_label) - = int_const_binop (MINUS_EXPR, vr_min, one_cst); - - /* If OP's value range is ~[2,8] and the high label range is - 7 ... 10, truncate the label's range to 9 ... 10. */ - if (tree_int_cst_compare (CASE_LOW (max_label), vr_max) <= 0 - && CASE_HIGH (max_label) != NULL_TREE - && tree_int_cst_compare (CASE_HIGH (max_label), vr_max) > 0) - CASE_LOW (max_label) - = int_const_binop (PLUS_EXPR, vr_max, one_cst); - } + *vr0max = *vr0min; + *vr0min = vr1min; } - - /* Canonicalize singleton case ranges. */ - if (tree_int_cst_equal (CASE_LOW (min_label), CASE_HIGH (min_label))) - CASE_HIGH (min_label) = NULL_TREE; - if (tree_int_cst_equal (CASE_LOW (max_label), CASE_HIGH (max_label))) - CASE_HIGH (max_label) = NULL_TREE; + else + gcc_unreachable (); } - /* We can also eliminate case labels that lie completely outside OP's value - range. */ - - /* Bail out if this is just all edges taken. */ - if (i == 1 - && j == n - 1 - && take_default) - return false; + /* As a fallback simply use { *VRTYPE, *VR0MIN, *VR0MAX } as + result for the intersection. That's always a conservative + correct estimate unless VR1 is a constant singleton range + in which case we choose that. */ + if (vr1type == VR_RANGE + && is_gimple_min_invariant (vr1min) + && vrp_operand_equal_p (vr1min, vr1max)) + { + *vr0type = vr1type; + *vr0min = vr1min; + *vr0max = vr1max; + } - /* Build a new vector of taken case labels. */ - vec2 = make_tree_vec (j - i + 1 + l - k + 1 + (int)take_default); - n2 = 0; + return; +} - /* Add the default edge, if necessary. */ - if (take_default) - TREE_VEC_ELT (vec2, n2++) = gimple_switch_default_label (stmt); - for (; i <= j; ++i, ++n2) - TREE_VEC_ELT (vec2, n2) = gimple_switch_label (stmt, i); +/* Intersect the two value-ranges *VR0 and *VR1 and store the result + in *VR0. This may not be the smallest possible such range. */ - for (; k <= l; ++k, ++n2) - TREE_VEC_ELT (vec2, n2) = gimple_switch_label (stmt, k); +static void +vrp_intersect_ranges_1 (value_range *vr0, value_range *vr1) +{ + value_range saved; - /* Mark needed edges. */ - for (i = 0; i < n2; ++i) + /* If either range is VR_VARYING the other one wins. */ + if (vr1->type == VR_VARYING) + return; + if (vr0->type == VR_VARYING) { - e = find_edge (gimple_bb (stmt), - label_to_block (CASE_LABEL (TREE_VEC_ELT (vec2, i)))); - e->aux = (void *)-1; + copy_value_range (vr0, vr1); + return; } - /* Queue not needed edges for later removal. */ - FOR_EACH_EDGE (e, ei, gimple_bb (stmt)->succs) + /* When either range is VR_UNDEFINED the resulting range is + VR_UNDEFINED, too. */ + if (vr0->type == VR_UNDEFINED) + return; + if (vr1->type == VR_UNDEFINED) { - if (e->aux == (void *)-1) - { - e->aux = NULL; - continue; - } + set_value_range_to_undefined (vr0); + return; + } - if (dump_file && (dump_flags & TDF_DETAILS)) - { - fprintf (dump_file, "removing unreachable case label\n"); - } - to_remove_edges.safe_push (e); - e->flags &= ~EDGE_EXECUTABLE; + /* Save the original vr0 so we can return it as conservative intersection + result when our worker turns things to varying. */ + saved = *vr0; + intersect_ranges (&vr0->type, &vr0->min, &vr0->max, + vr1->type, vr1->min, vr1->max); + /* Make sure to canonicalize the result though as the inversion of a + VR_RANGE can still be a VR_RANGE. */ + set_and_canonicalize_value_range (vr0, vr0->type, + vr0->min, vr0->max, vr0->equiv); + /* If that failed, use the saved original VR0. */ + if (vr0->type == VR_VARYING) + { + *vr0 = saved; + return; } + /* If the result is VR_UNDEFINED there is no need to mess with + the equivalencies. */ + if (vr0->type == VR_UNDEFINED) + return; - /* And queue an update for the stmt. */ - su.stmt = stmt; - su.vec = vec2; - to_update_switch_stmts.safe_push (su); - return false; + /* The resulting set of equivalences for range intersection is the union of + the two sets. */ + if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv) + bitmap_ior_into (vr0->equiv, vr1->equiv); + else if (vr1->equiv && !vr0->equiv) + { + /* All equivalence bitmaps are allocated from the same obstack. So + we can use the obstack associated with VR to allocate vr0->equiv. */ + vr0->equiv = BITMAP_ALLOC (vr1->equiv->obstack); + bitmap_copy (vr0->equiv, vr1->equiv); + } } -/* Simplify an integral conversion from an SSA name in STMT. */ - -static bool -simplify_conversion_using_ranges (gimple_stmt_iterator *gsi, gimple *stmt) +void +vrp_intersect_ranges (value_range *vr0, value_range *vr1) { - tree innerop, middleop, finaltype; - gimple *def_stmt; - signop inner_sgn, middle_sgn, final_sgn; - unsigned inner_prec, middle_prec, final_prec; - widest_int innermin, innermed, innermax, middlemin, middlemed, middlemax; - - finaltype = TREE_TYPE (gimple_assign_lhs (stmt)); - if (!INTEGRAL_TYPE_P (finaltype)) - return false; - middleop = gimple_assign_rhs1 (stmt); - def_stmt = SSA_NAME_DEF_STMT (middleop); - if (!is_gimple_assign (def_stmt) - || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))) - return false; - innerop = gimple_assign_rhs1 (def_stmt); - if (TREE_CODE (innerop) != SSA_NAME - || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (innerop)) - return false; - - /* Get the value-range of the inner operand. Use get_range_info in - case innerop was created during substitute-and-fold. */ - wide_int imin, imax; - if (!INTEGRAL_TYPE_P (TREE_TYPE (innerop)) - || get_range_info (innerop, &imin, &imax) != VR_RANGE) - return false; - innermin = widest_int::from (imin, TYPE_SIGN (TREE_TYPE (innerop))); - innermax = widest_int::from (imax, TYPE_SIGN (TREE_TYPE (innerop))); - - /* Simulate the conversion chain to check if the result is equal if - the middle conversion is removed. */ - inner_prec = TYPE_PRECISION (TREE_TYPE (innerop)); - middle_prec = TYPE_PRECISION (TREE_TYPE (middleop)); - final_prec = TYPE_PRECISION (finaltype); - - /* If the first conversion is not injective, the second must not - be widening. */ - if (wi::gtu_p (innermax - innermin, - wi::mask (middle_prec, false)) - && middle_prec < final_prec) - return false; - /* We also want a medium value so that we can track the effect that - narrowing conversions with sign change have. */ - inner_sgn = TYPE_SIGN (TREE_TYPE (innerop)); - if (inner_sgn == UNSIGNED) - innermed = wi::shifted_mask (1, inner_prec - 1, false); - else - innermed = 0; - if (wi::cmp (innermin, innermed, inner_sgn) >= 0 - || wi::cmp (innermed, innermax, inner_sgn) >= 0) - innermed = innermin; - - middle_sgn = TYPE_SIGN (TREE_TYPE (middleop)); - middlemin = wi::ext (innermin, middle_prec, middle_sgn); - middlemed = wi::ext (innermed, middle_prec, middle_sgn); - middlemax = wi::ext (innermax, middle_prec, middle_sgn); - - /* Require that the final conversion applied to both the original - and the intermediate range produces the same result. */ - final_sgn = TYPE_SIGN (finaltype); - if (wi::ext (middlemin, final_prec, final_sgn) - != wi::ext (innermin, final_prec, final_sgn) - || wi::ext (middlemed, final_prec, final_sgn) - != wi::ext (innermed, final_prec, final_sgn) - || wi::ext (middlemax, final_prec, final_sgn) - != wi::ext (innermax, final_prec, final_sgn)) - return false; - - gimple_assign_set_rhs1 (stmt, innerop); - fold_stmt (gsi, follow_single_use_edges); - return true; + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "Intersecting\n "); + dump_value_range (dump_file, vr0); + fprintf (dump_file, "\nand\n "); + dump_value_range (dump_file, vr1); + fprintf (dump_file, "\n"); + } + vrp_intersect_ranges_1 (vr0, vr1); + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "to\n "); + dump_value_range (dump_file, vr0); + fprintf (dump_file, "\n"); + } } -/* Simplify a conversion from integral SSA name to float in STMT. */ +/* Meet operation for value ranges. Given two value ranges VR0 and + VR1, store in VR0 a range that contains both VR0 and VR1. This + may not be the smallest possible such range. */ -bool -vr_values::simplify_float_conversion_using_ranges (gimple_stmt_iterator *gsi, - gimple *stmt) +static void +vrp_meet_1 (value_range *vr0, const value_range *vr1) { - tree rhs1 = gimple_assign_rhs1 (stmt); - value_range *vr = get_value_range (rhs1); - scalar_float_mode fltmode - = SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (gimple_assign_lhs (stmt))); - scalar_int_mode mode; - tree tem; - gassign *conv; - - /* We can only handle constant ranges. */ - if (vr->type != VR_RANGE - || TREE_CODE (vr->min) != INTEGER_CST - || TREE_CODE (vr->max) != INTEGER_CST) - return false; + value_range saved; - /* First check if we can use a signed type in place of an unsigned. */ - scalar_int_mode rhs_mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (rhs1)); - if (TYPE_UNSIGNED (TREE_TYPE (rhs1)) - && can_float_p (fltmode, rhs_mode, 0) != CODE_FOR_nothing - && range_fits_type_p (vr, TYPE_PRECISION (TREE_TYPE (rhs1)), SIGNED)) - mode = rhs_mode; - /* If we can do the conversion in the current input mode do nothing. */ - else if (can_float_p (fltmode, rhs_mode, - TYPE_UNSIGNED (TREE_TYPE (rhs1))) != CODE_FOR_nothing) - return false; - /* Otherwise search for a mode we can use, starting from the narrowest - integer mode available. */ - else + if (vr0->type == VR_UNDEFINED) { - mode = NARROWEST_INT_MODE; - for (;;) - { - /* If we cannot do a signed conversion to float from mode - or if the value-range does not fit in the signed type - try with a wider mode. */ - if (can_float_p (fltmode, mode, 0) != CODE_FOR_nothing - && range_fits_type_p (vr, GET_MODE_PRECISION (mode), SIGNED)) - break; - - /* But do not widen the input. Instead leave that to the - optabs expansion code. */ - if (!GET_MODE_WIDER_MODE (mode).exists (&mode) - || GET_MODE_PRECISION (mode) > TYPE_PRECISION (TREE_TYPE (rhs1))) - return false; - } + set_value_range (vr0, vr1->type, vr1->min, vr1->max, vr1->equiv); + return; } - /* It works, insert a truncation or sign-change before the - float conversion. */ - tem = make_ssa_name (build_nonstandard_integer_type - (GET_MODE_PRECISION (mode), 0)); - conv = gimple_build_assign (tem, NOP_EXPR, rhs1); - gsi_insert_before (gsi, conv, GSI_SAME_STMT); - gimple_assign_set_rhs1 (stmt, tem); - fold_stmt (gsi, follow_single_use_edges); - - return true; -} - -/* Simplify an internal fn call using ranges if possible. */ + if (vr1->type == VR_UNDEFINED) + { + /* VR0 already has the resulting range. */ + return; + } -bool -vr_values::simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, - gimple *stmt) -{ - enum tree_code subcode; - bool is_ubsan = false; - bool ovf = false; - switch (gimple_call_internal_fn (stmt)) - { - case IFN_UBSAN_CHECK_ADD: - subcode = PLUS_EXPR; - is_ubsan = true; - break; - case IFN_UBSAN_CHECK_SUB: - subcode = MINUS_EXPR; - is_ubsan = true; - break; - case IFN_UBSAN_CHECK_MUL: - subcode = MULT_EXPR; - is_ubsan = true; - break; - case IFN_ADD_OVERFLOW: - subcode = PLUS_EXPR; - break; - case IFN_SUB_OVERFLOW: - subcode = MINUS_EXPR; - break; - case IFN_MUL_OVERFLOW: - subcode = MULT_EXPR; - break; - default: - return false; + if (vr0->type == VR_VARYING) + { + /* Nothing to do. VR0 already has the resulting range. */ + return; } - tree op0 = gimple_call_arg (stmt, 0); - tree op1 = gimple_call_arg (stmt, 1); - tree type; - if (is_ubsan) + if (vr1->type == VR_VARYING) { - type = TREE_TYPE (op0); - if (VECTOR_TYPE_P (type)) - return false; + set_value_range_to_varying (vr0); + return; } - else if (gimple_call_lhs (stmt) == NULL_TREE) - return false; - else - type = TREE_TYPE (TREE_TYPE (gimple_call_lhs (stmt))); - if (!check_for_binary_op_overflow (subcode, type, op0, op1, &ovf) - || (is_ubsan && ovf)) - return false; - gimple *g; - location_t loc = gimple_location (stmt); - if (is_ubsan) - g = gimple_build_assign (gimple_call_lhs (stmt), subcode, op0, op1); - else + saved = *vr0; + union_ranges (&vr0->type, &vr0->min, &vr0->max, + vr1->type, vr1->min, vr1->max); + if (vr0->type == VR_VARYING) { - int prec = TYPE_PRECISION (type); - tree utype = type; - if (ovf - || !useless_type_conversion_p (type, TREE_TYPE (op0)) - || !useless_type_conversion_p (type, TREE_TYPE (op1))) - utype = build_nonstandard_integer_type (prec, 1); - if (TREE_CODE (op0) == INTEGER_CST) - op0 = fold_convert (utype, op0); - else if (!useless_type_conversion_p (utype, TREE_TYPE (op0))) - { - g = gimple_build_assign (make_ssa_name (utype), NOP_EXPR, op0); - gimple_set_location (g, loc); - gsi_insert_before (gsi, g, GSI_SAME_STMT); - op0 = gimple_assign_lhs (g); - } - if (TREE_CODE (op1) == INTEGER_CST) - op1 = fold_convert (utype, op1); - else if (!useless_type_conversion_p (utype, TREE_TYPE (op1))) - { - g = gimple_build_assign (make_ssa_name (utype), NOP_EXPR, op1); - gimple_set_location (g, loc); - gsi_insert_before (gsi, g, GSI_SAME_STMT); - op1 = gimple_assign_lhs (g); - } - g = gimple_build_assign (make_ssa_name (utype), subcode, op0, op1); - gimple_set_location (g, loc); - gsi_insert_before (gsi, g, GSI_SAME_STMT); - if (utype != type) + /* Failed to find an efficient meet. Before giving up and setting + the result to VARYING, see if we can at least derive a useful + anti-range. FIXME, all this nonsense about distinguishing + anti-ranges from ranges is necessary because of the odd + semantics of range_includes_zero_p and friends. */ + if (((saved.type == VR_RANGE + && range_includes_zero_p (saved.min, saved.max) == 0) + || (saved.type == VR_ANTI_RANGE + && range_includes_zero_p (saved.min, saved.max) == 1)) + && ((vr1->type == VR_RANGE + && range_includes_zero_p (vr1->min, vr1->max) == 0) + || (vr1->type == VR_ANTI_RANGE + && range_includes_zero_p (vr1->min, vr1->max) == 1))) { - g = gimple_build_assign (make_ssa_name (type), NOP_EXPR, - gimple_assign_lhs (g)); - gimple_set_location (g, loc); - gsi_insert_before (gsi, g, GSI_SAME_STMT); + set_value_range_to_nonnull (vr0, TREE_TYPE (saved.min)); + + /* Since this meet operation did not result from the meeting of + two equivalent names, VR0 cannot have any equivalences. */ + if (vr0->equiv) + bitmap_clear (vr0->equiv); + return; } - g = gimple_build_assign (gimple_call_lhs (stmt), COMPLEX_EXPR, - gimple_assign_lhs (g), - build_int_cst (type, ovf)); + + set_value_range_to_varying (vr0); + return; } - gimple_set_location (g, loc); - gsi_replace (gsi, g, false); - return true; -} + set_and_canonicalize_value_range (vr0, vr0->type, vr0->min, vr0->max, + vr0->equiv); + if (vr0->type == VR_VARYING) + return; -/* Return true if VAR is a two-valued variable. Set a and b with the - two-values when it is true. Return false otherwise. */ + /* The resulting set of equivalences is always the intersection of + the two sets. */ + if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv) + bitmap_and_into (vr0->equiv, vr1->equiv); + else if (vr0->equiv && !vr1->equiv) + bitmap_clear (vr0->equiv); +} -bool -vr_values::two_valued_val_range_p (tree var, tree *a, tree *b) +void +vrp_meet (value_range *vr0, const value_range *vr1) { - value_range *vr = get_value_range (var); - if ((vr->type != VR_RANGE - && vr->type != VR_ANTI_RANGE) - || TREE_CODE (vr->min) != INTEGER_CST - || TREE_CODE (vr->max) != INTEGER_CST) - return false; - - if (vr->type == VR_RANGE - && wi::to_wide (vr->max) - wi::to_wide (vr->min) == 1) + if (dump_file && (dump_flags & TDF_DETAILS)) { - *a = vr->min; - *b = vr->max; - return true; + fprintf (dump_file, "Meeting\n "); + dump_value_range (dump_file, vr0); + fprintf (dump_file, "\nand\n "); + dump_value_range (dump_file, vr1); + fprintf (dump_file, "\n"); } - - /* ~[TYPE_MIN + 1, TYPE_MAX - 1] */ - if (vr->type == VR_ANTI_RANGE - && (wi::to_wide (vr->min) - - wi::to_wide (vrp_val_min (TREE_TYPE (var)))) == 1 - && (wi::to_wide (vrp_val_max (TREE_TYPE (var))) - - wi::to_wide (vr->max)) == 1) + vrp_meet_1 (vr0, vr1); + if (dump_file && (dump_flags & TDF_DETAILS)) { - *a = vrp_val_min (TREE_TYPE (var)); - *b = vrp_val_max (TREE_TYPE (var)); - return true; + fprintf (dump_file, "to\n "); + dump_value_range (dump_file, vr0); + fprintf (dump_file, "\n"); } - - return false; } -/* Simplify STMT using ranges if possible. */ - -bool -vr_values::simplify_stmt_using_ranges (gimple_stmt_iterator *gsi) -{ - gimple *stmt = gsi_stmt (*gsi); - if (is_gimple_assign (stmt)) - { - enum tree_code rhs_code = gimple_assign_rhs_code (stmt); - tree rhs1 = gimple_assign_rhs1 (stmt); - tree rhs2 = gimple_assign_rhs2 (stmt); - tree lhs = gimple_assign_lhs (stmt); - tree val1 = NULL_TREE, val2 = NULL_TREE; - use_operand_p use_p; - gimple *use_stmt; - /* Convert: - LHS = CST BINOP VAR - Where VAR is two-valued and LHS is used in GIMPLE_COND only - To: - LHS = VAR == VAL1 ? (CST BINOP VAL1) : (CST BINOP VAL2) - - Also handles: - LHS = VAR BINOP CST - Where VAR is two-valued and LHS is used in GIMPLE_COND only - To: - LHS = VAR == VAL1 ? (VAL1 BINOP CST) : (VAL2 BINOP CST) */ - - if (TREE_CODE_CLASS (rhs_code) == tcc_binary - && INTEGRAL_TYPE_P (TREE_TYPE (lhs)) - && ((TREE_CODE (rhs1) == INTEGER_CST - && TREE_CODE (rhs2) == SSA_NAME) - || (TREE_CODE (rhs2) == INTEGER_CST - && TREE_CODE (rhs1) == SSA_NAME)) - && single_imm_use (lhs, &use_p, &use_stmt) - && gimple_code (use_stmt) == GIMPLE_COND) +/* Visit all arguments for PHI node PHI that flow through executable + edges. If a valid value range can be derived from all the incoming + value ranges, set a new range for the LHS of PHI. */ +enum ssa_prop_result +vrp_prop::visit_phi (gphi *phi) +{ + tree lhs = PHI_RESULT (phi); + value_range vr_result = VR_INITIALIZER; + extract_range_from_phi_node (phi, &vr_result); + if (update_value_range (lhs, &vr_result)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) { - tree new_rhs1 = NULL_TREE; - tree new_rhs2 = NULL_TREE; - tree cmp_var = NULL_TREE; - - if (TREE_CODE (rhs2) == SSA_NAME - && two_valued_val_range_p (rhs2, &val1, &val2)) - { - /* Optimize RHS1 OP [VAL1, VAL2]. */ - new_rhs1 = int_const_binop (rhs_code, rhs1, val1); - new_rhs2 = int_const_binop (rhs_code, rhs1, val2); - cmp_var = rhs2; - } - else if (TREE_CODE (rhs1) == SSA_NAME - && two_valued_val_range_p (rhs1, &val1, &val2)) - { - /* Optimize [VAL1, VAL2] OP RHS2. */ - new_rhs1 = int_const_binop (rhs_code, val1, rhs2); - new_rhs2 = int_const_binop (rhs_code, val2, rhs2); - cmp_var = rhs1; - } - - /* If we could not find two-vals or the optimzation is invalid as - in divide by zero, new_rhs1 / new_rhs will be NULL_TREE. */ - if (new_rhs1 && new_rhs2) - { - tree cond = build2 (EQ_EXPR, boolean_type_node, cmp_var, val1); - gimple_assign_set_rhs_with_ops (gsi, - COND_EXPR, cond, - new_rhs1, - new_rhs2); - update_stmt (gsi_stmt (*gsi)); - fold_stmt (gsi, follow_single_use_edges); - return true; - } + fprintf (dump_file, "Found new range for "); + print_generic_expr (dump_file, lhs); + fprintf (dump_file, ": "); + dump_value_range (dump_file, &vr_result); + fprintf (dump_file, "\n"); } - switch (rhs_code) - { - case EQ_EXPR: - case NE_EXPR: - /* Transform EQ_EXPR, NE_EXPR into BIT_XOR_EXPR or identity - if the RHS is zero or one, and the LHS are known to be boolean - values. */ - if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) - return simplify_truth_ops_using_ranges (gsi, stmt); - break; - - /* Transform TRUNC_DIV_EXPR and TRUNC_MOD_EXPR into RSHIFT_EXPR - and BIT_AND_EXPR respectively if the first operand is greater - than zero and the second operand is an exact power of two. - Also optimize TRUNC_MOD_EXPR away if the second operand is - constant and the first operand already has the right value - range. */ - case TRUNC_DIV_EXPR: - case TRUNC_MOD_EXPR: - if ((TREE_CODE (rhs1) == SSA_NAME - || TREE_CODE (rhs1) == INTEGER_CST) - && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) - return simplify_div_or_mod_using_ranges (gsi, stmt); - break; - - /* Transform ABS (X) into X or -X as appropriate. */ - case ABS_EXPR: - if (TREE_CODE (rhs1) == SSA_NAME - && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) - return simplify_abs_using_ranges (gsi, stmt); - break; - - case BIT_AND_EXPR: - case BIT_IOR_EXPR: - /* Optimize away BIT_AND_EXPR and BIT_IOR_EXPR - if all the bits being cleared are already cleared or - all the bits being set are already set. */ - if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) - return simplify_bit_ops_using_ranges (gsi, stmt); - break; - - CASE_CONVERT: - if (TREE_CODE (rhs1) == SSA_NAME - && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) - return simplify_conversion_using_ranges (gsi, stmt); - break; - - case FLOAT_EXPR: - if (TREE_CODE (rhs1) == SSA_NAME - && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) - return simplify_float_conversion_using_ranges (gsi, stmt); - break; - - case MIN_EXPR: - case MAX_EXPR: - return simplify_min_or_max_using_ranges (gsi, stmt); + if (vr_result.type == VR_VARYING) + return SSA_PROP_VARYING; - default: - break; - } + return SSA_PROP_INTERESTING; } - else if (gimple_code (stmt) == GIMPLE_COND) - return simplify_cond_using_ranges_1 (as_a (stmt)); - else if (gimple_code (stmt) == GIMPLE_SWITCH) - return simplify_switch_using_ranges (as_a (stmt)); - else if (is_gimple_call (stmt) - && gimple_call_internal_p (stmt)) - return simplify_internal_call_using_ranges (gsi, stmt); - return false; + /* Nothing changed, don't add outgoing edges. */ + return SSA_PROP_NOT_INTERESTING; } class vrp_folder : public substitute_and_fold_engine @@ -10573,6 +6444,9 @@ lhs_of_dominating_assert (tree op, basic_block bb, gimple *stmt) return op; } +/* A hack. */ +static class vr_values *x_vr_values; + /* A trivial wrapper so that we can present the generic jump threading code with a simple API for simplifying statements. STMT is the statement we want to simplify, WITHIN_STMT provides the location @@ -10834,22 +6708,6 @@ identify_jump_threads (class vr_values *vr_values) delete avail_exprs_stack; } -/* Free VRP lattice. */ - -vr_values::~vr_values () -{ - /* Free allocated memory. */ - free (vr_value); - free (vr_phi_edge_counts); - bitmap_obstack_release (&vrp_equiv_obstack); - vrp_value_range_pool.release (); - - /* So that we can distinguish between VRP data being available - and not available. */ - vr_value = NULL; - vr_phi_edge_counts = NULL; -} - /* Traverse all the blocks folding conditionals with known ranges. */ void @@ -10901,14 +6759,6 @@ vrp_prop::vrp_finalize (bool warn_array_bounds_p) check_all_array_refs (); } -void -vr_values::set_vr_value (tree var, value_range *vr) -{ - if (SSA_NAME_VERSION (var) >= num_vr_values) - return; - vr_value[SSA_NAME_VERSION (var)] = vr; -} - /* Main entry point to VRP (Value Range Propagation). This pass is loosely based on J. R. C. Patterson, ``Accurate Static Branch Prediction by Value Range Propagation,'' in SIGPLAN Conference on diff --git a/gcc/tree-vrp.h b/gcc/tree-vrp.h index 455a9ac9252..a0f72db2627 100644 --- a/gcc/tree-vrp.h +++ b/gcc/tree-vrp.h @@ -84,4 +84,46 @@ extern void set_value_range_to_varying (value_range *); extern int range_includes_zero_p (tree, tree); extern bool infer_value_range (gimple *, tree, tree_code *, tree *); +extern void set_value_range_to_nonnull (value_range *, tree); +extern void set_value_range (value_range *, enum value_range_type, tree, + tree, bitmap); +extern void set_and_canonicalize_value_range (value_range *, + enum value_range_type, + tree, tree, bitmap); +extern bool vrp_bitmap_equal_p (const_bitmap, const_bitmap); +extern bool range_is_nonnull (value_range *); +extern tree value_range_constant_singleton (value_range *); +extern bool symbolic_range_p (value_range *); +extern int compare_values (tree, tree); +extern int compare_values_warnv (tree, tree, bool *); +extern bool vrp_val_is_min (const_tree); +extern bool vrp_val_is_max (const_tree); +extern void copy_value_range (value_range *, value_range *); +extern void set_value_range_to_value (value_range *, tree, bitmap); +extern void extract_range_from_binary_expr_1 (value_range *, enum tree_code, + tree, value_range *, + value_range *); +extern tree vrp_val_min (const_tree); +extern tree vrp_val_max (const_tree); +extern void set_value_range_to_null (value_range *, tree); +extern bool range_int_cst_p (value_range *); +extern int operand_less_p (tree, tree); +extern bool find_case_label_range (gswitch *, tree, tree, size_t *, size_t *); +extern bool find_case_label_index (gswitch *, size_t, tree, size_t *); +extern bool zero_nonzero_bits_from_vr (const tree, value_range *, + wide_int *, wide_int *); +extern bool overflow_comparison_p (tree_code, tree, tree, bool, tree *); +extern bool range_int_cst_singleton_p (value_range *); +extern int value_inside_range (tree, tree, tree); +extern tree get_single_symbol (tree, bool *, tree *); + + +struct switch_update { + gswitch *stmt; + tree vec; +}; + +extern vec to_remove_edges; +extern vec to_update_switch_stmts; + #endif /* GCC_TREE_VRP_H */ diff --git a/gcc/vr-values.c b/gcc/vr-values.c new file mode 100644 index 00000000000..d4434ded75d --- /dev/null +++ b/gcc/vr-values.c @@ -0,0 +1,4183 @@ +/* Support routines for Value Range Propagation (VRP). + Copyright (C) 2005-2017 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "backend.h" +#include "insn-codes.h" +#include "tree.h" +#include "gimple.h" +#include "ssa.h" +#include "optabs-tree.h" +#include "gimple-pretty-print.h" +#include "diagnostic-core.h" +#include "flags.h" +#include "fold-const.h" +#include "calls.h" +#include "cfganal.h" +#include "gimple-fold.h" +#include "gimple-iterator.h" +#include "tree-cfg.h" +#include "tree-ssa-loop-niter.h" +#include "tree-ssa-loop.h" +#include "intl.h" +#include "cfgloop.h" +#include "tree-scalar-evolution.h" +#include "tree-ssa-propagate.h" +#include "tree-chrec.h" +#include "omp-general.h" +#include "case-cfn-macros.h" +#include "alloc-pool.h" +#include "attribs.h" +#include "vr-values.h" + +/* Set value range VR to a non-negative range of type TYPE. */ + +static inline void +set_value_range_to_nonnegative (value_range *vr, tree type) +{ + tree zero = build_int_cst (type, 0); + set_value_range (vr, VR_RANGE, zero, vrp_val_max (type), vr->equiv); +} + +/* Set value range VR to a range of a truthvalue of type TYPE. */ + +static inline void +set_value_range_to_truthvalue (value_range *vr, tree type) +{ + if (TYPE_PRECISION (type) == 1) + set_value_range_to_varying (vr); + else + set_value_range (vr, VR_RANGE, + build_int_cst (type, 0), build_int_cst (type, 1), + vr->equiv); +} + + +/* Return value range information for VAR. + + 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. */ + +value_range * +vr_values::get_value_range (const_tree var) +{ + static const value_range vr_const_varying + = { VR_VARYING, NULL_TREE, NULL_TREE, NULL }; + value_range *vr; + tree sym; + unsigned ver = SSA_NAME_VERSION (var); + + /* If we have no recorded ranges, then return NULL. */ + if (! vr_value) + return NULL; + + /* If we query the range for a new SSA name return an unmodifiable VARYING. + We should get here at most from the substitute-and-fold stage which + will never try to change values. */ + if (ver >= num_vr_values) + return CONST_CAST (value_range *, &vr_const_varying); + + vr = vr_value[ver]; + if (vr) + return vr; + + /* After propagation finished do not allocate new value-ranges. */ + if (values_propagated) + return CONST_CAST (value_range *, &vr_const_varying); + + /* Create a default value range. */ + vr_value[ver] = vr = vrp_value_range_pool.allocate (); + memset (vr, 0, sizeof (*vr)); + + /* Defer allocating the equivalence set. */ + vr->equiv = NULL; + + /* If VAR is a default definition of a parameter, the variable can + take any value in VAR's type. */ + if (SSA_NAME_IS_DEFAULT_DEF (var)) + { + sym = SSA_NAME_VAR (var); + if (TREE_CODE (sym) == PARM_DECL) + { + /* Try to use the "nonnull" attribute to create ~[0, 0] + anti-ranges for pointers. Note that this is only valid with + default definitions of PARM_DECLs. */ + if (POINTER_TYPE_P (TREE_TYPE (sym)) + && (nonnull_arg_p (sym) + || get_ptr_nonnull (var))) + set_value_range_to_nonnull (vr, TREE_TYPE (sym)); + else if (INTEGRAL_TYPE_P (TREE_TYPE (sym))) + { + wide_int min, max; + value_range_type rtype = get_range_info (var, &min, &max); + if (rtype == VR_RANGE || rtype == VR_ANTI_RANGE) + set_value_range (vr, rtype, + wide_int_to_tree (TREE_TYPE (var), min), + wide_int_to_tree (TREE_TYPE (var), max), + NULL); + else + set_value_range_to_varying (vr); + } + else + set_value_range_to_varying (vr); + } + else if (TREE_CODE (sym) == RESULT_DECL + && DECL_BY_REFERENCE (sym)) + set_value_range_to_nonnull (vr, TREE_TYPE (sym)); + } + + return vr; +} + +/* Set value-ranges of all SSA names defined by STMT to varying. */ + +void +vr_values::set_defs_to_varying (gimple *stmt) +{ + ssa_op_iter i; + tree def; + FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF) + { + value_range *vr = get_value_range (def); + /* Avoid writing to vr_const_varying get_value_range may return. */ + if (vr->type != VR_VARYING) + set_value_range_to_varying (vr); + } +} + +/* Update the value range and equivalence set for variable VAR to + NEW_VR. Return true if NEW_VR is different from VAR's previous + value. + + NOTE: This function assumes that NEW_VR is a temporary value range + 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 + this function. Do not call update_value_range when NEW_VR + is the range object associated with another SSA name. */ + +bool +vr_values::update_value_range (const_tree var, value_range *new_vr) +{ + value_range *old_vr; + bool is_new; + + /* If there is a value-range on the SSA name from earlier analysis + factor that in. */ + if (INTEGRAL_TYPE_P (TREE_TYPE (var))) + { + wide_int min, max; + value_range_type rtype = get_range_info (var, &min, &max); + if (rtype == VR_RANGE || rtype == VR_ANTI_RANGE) + { + tree nr_min, nr_max; + nr_min = wide_int_to_tree (TREE_TYPE (var), min); + nr_max = wide_int_to_tree (TREE_TYPE (var), max); + value_range nr = VR_INITIALIZER; + set_and_canonicalize_value_range (&nr, rtype, nr_min, nr_max, NULL); + vrp_intersect_ranges (new_vr, &nr); + } + } + + /* Update the value range, if necessary. */ + old_vr = get_value_range (var); + is_new = old_vr->type != new_vr->type + || !vrp_operand_equal_p (old_vr->min, new_vr->min) + || !vrp_operand_equal_p (old_vr->max, new_vr->max) + || !vrp_bitmap_equal_p (old_vr->equiv, new_vr->equiv); + + if (is_new) + { + /* Do not allow transitions up the lattice. The following + is slightly more awkward than just new_vr->type < old_vr->type + because VR_RANGE and VR_ANTI_RANGE need to be considered + the same. We may not have is_new when transitioning to + UNDEFINED. If old_vr->type is VARYING, we shouldn't be + called. */ + if (new_vr->type == VR_UNDEFINED) + { + BITMAP_FREE (new_vr->equiv); + set_value_range_to_varying (old_vr); + set_value_range_to_varying (new_vr); + return true; + } + else + set_value_range (old_vr, new_vr->type, new_vr->min, new_vr->max, + new_vr->equiv); + } + + BITMAP_FREE (new_vr->equiv); + + return is_new; +} + + +/* Add VAR and VAR's equivalence set to EQUIV. This is the central + point where equivalence processing can be turned on/off. */ + +void +vr_values::add_equivalence (bitmap *equiv, const_tree var) +{ + unsigned ver = SSA_NAME_VERSION (var); + value_range *vr = get_value_range (var); + + if (*equiv == NULL) + *equiv = BITMAP_ALLOC (&vrp_equiv_obstack); + bitmap_set_bit (*equiv, ver); + if (vr && vr->equiv) + bitmap_ior_into (*equiv, vr->equiv); +} + +/* Return true if value range VR involves exactly one symbol SYM. */ + +static bool +symbolic_range_based_on_p (value_range *vr, const_tree sym) +{ + bool neg, min_has_symbol, max_has_symbol; + tree inv; + + if (is_gimple_min_invariant (vr->min)) + min_has_symbol = false; + else if (get_single_symbol (vr->min, &neg, &inv) == sym) + min_has_symbol = true; + else + return false; + + if (is_gimple_min_invariant (vr->max)) + max_has_symbol = false; + else if (get_single_symbol (vr->max, &neg, &inv) == sym) + max_has_symbol = true; + else + return false; + + return (min_has_symbol || max_has_symbol); +} + +/* Return true if the result of assignment STMT is know to be non-zero. */ + +static bool +gimple_assign_nonzero_p (gimple *stmt) +{ + enum tree_code code = gimple_assign_rhs_code (stmt); + bool strict_overflow_p; + switch (get_gimple_rhs_class (code)) + { + case GIMPLE_UNARY_RHS: + return tree_unary_nonzero_warnv_p (gimple_assign_rhs_code (stmt), + gimple_expr_type (stmt), + gimple_assign_rhs1 (stmt), + &strict_overflow_p); + case GIMPLE_BINARY_RHS: + return tree_binary_nonzero_warnv_p (gimple_assign_rhs_code (stmt), + gimple_expr_type (stmt), + gimple_assign_rhs1 (stmt), + gimple_assign_rhs2 (stmt), + &strict_overflow_p); + case GIMPLE_TERNARY_RHS: + return false; + case GIMPLE_SINGLE_RHS: + return tree_single_nonzero_warnv_p (gimple_assign_rhs1 (stmt), + &strict_overflow_p); + case GIMPLE_INVALID_RHS: + gcc_unreachable (); + default: + gcc_unreachable (); + } +} + +/* Return true if STMT is known to compute a non-zero value. */ + +static bool +gimple_stmt_nonzero_p (gimple *stmt) +{ + switch (gimple_code (stmt)) + { + case GIMPLE_ASSIGN: + return gimple_assign_nonzero_p (stmt); + case GIMPLE_CALL: + { + tree fndecl = gimple_call_fndecl (stmt); + if (!fndecl) return false; + if (flag_delete_null_pointer_checks && !flag_check_new + && DECL_IS_OPERATOR_NEW (fndecl) + && !TREE_NOTHROW (fndecl)) + return true; + /* References are always non-NULL. */ + if (flag_delete_null_pointer_checks + && TREE_CODE (TREE_TYPE (fndecl)) == REFERENCE_TYPE) + return true; + if (flag_delete_null_pointer_checks && + lookup_attribute ("returns_nonnull", + TYPE_ATTRIBUTES (gimple_call_fntype (stmt)))) + return true; + + gcall *call_stmt = as_a (stmt); + unsigned rf = gimple_call_return_flags (call_stmt); + if (rf & ERF_RETURNS_ARG) + { + unsigned argnum = rf & ERF_RETURN_ARG_MASK; + if (argnum < gimple_call_num_args (call_stmt)) + { + tree arg = gimple_call_arg (call_stmt, argnum); + if (SSA_VAR_P (arg) + && infer_nonnull_range_by_attribute (stmt, arg)) + return true; + } + } + return gimple_alloca_call_p (stmt); + } + default: + gcc_unreachable (); + } +} +/* Like tree_expr_nonzero_p, but this function uses value ranges + obtained so far. */ + +bool +vr_values::vrp_stmt_computes_nonzero (gimple *stmt) +{ + if (gimple_stmt_nonzero_p (stmt)) + return true; + + /* If we have an expression of the form &X->a, then the expression + is nonnull if X is nonnull. */ + if (is_gimple_assign (stmt) + && gimple_assign_rhs_code (stmt) == ADDR_EXPR) + { + tree expr = gimple_assign_rhs1 (stmt); + tree base = get_base_address (TREE_OPERAND (expr, 0)); + + if (base != NULL_TREE + && TREE_CODE (base) == MEM_REF + && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME) + { + value_range *vr = get_value_range (TREE_OPERAND (base, 0)); + if (range_is_nonnull (vr)) + return true; + } + } + + return false; +} + +/* Returns true if EXPR is a valid value (as expected by compare_values) -- + a gimple invariant, or SSA_NAME +- CST. */ + +static bool +valid_value_p (tree expr) +{ + if (TREE_CODE (expr) == SSA_NAME) + return true; + + if (TREE_CODE (expr) == PLUS_EXPR + || TREE_CODE (expr) == MINUS_EXPR) + return (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME + && TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST); + + return is_gimple_min_invariant (expr); +} + +/* If OP has a value range with a single constant value return that, + otherwise return NULL_TREE. This returns OP itself if OP is a + constant. */ + +tree +vr_values::op_with_constant_singleton_value_range (tree op) +{ + if (is_gimple_min_invariant (op)) + return op; + + if (TREE_CODE (op) != SSA_NAME) + return NULL_TREE; + + return value_range_constant_singleton (get_value_range (op)); +} + +/* Return true if op is in a boolean [0, 1] value-range. */ + +bool +vr_values::op_with_boolean_value_range_p (tree op) +{ + value_range *vr; + + if (TYPE_PRECISION (TREE_TYPE (op)) == 1) + return true; + + if (integer_zerop (op) + || integer_onep (op)) + return true; + + if (TREE_CODE (op) != SSA_NAME) + return false; + + vr = get_value_range (op); + return (vr->type == VR_RANGE + && integer_zerop (vr->min) + && integer_onep (vr->max)); +} + +/* Extract value range information for VAR when (OP COND_CODE LIMIT) is + true and store it in *VR_P. */ + +void +vr_values::extract_range_for_var_from_comparison_expr (tree var, + enum tree_code cond_code, + tree op, tree limit, + value_range *vr_p) +{ + tree min, max, type; + value_range *limit_vr; + type = TREE_TYPE (var); + gcc_assert (limit != var); + + /* For pointer arithmetic, we only keep track of pointer equality + and inequality. */ + if (POINTER_TYPE_P (type) && cond_code != NE_EXPR && cond_code != EQ_EXPR) + { + set_value_range_to_varying (vr_p); + return; + } + + /* 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 + unnecessarily. */ + limit_vr = (TREE_CODE (limit) == SSA_NAME) ? get_value_range (limit) : NULL; + + /* LIMIT's range is only interesting if it has any useful information. */ + if (! limit_vr + || limit_vr->type == VR_UNDEFINED + || limit_vr->type == VR_VARYING + || (symbolic_range_p (limit_vr) + && ! (limit_vr->type == VR_RANGE + && (limit_vr->min == limit_vr->max + || operand_equal_p (limit_vr->min, limit_vr->max, 0))))) + limit_vr = NULL; + + /* Initially, the new range has the same set of equivalences of + VAR's range. This will be revised before returning the final + value. Since assertions may be chained via mutually exclusive + predicates, we will need to trim the set of equivalences before + we are done. */ + gcc_assert (vr_p->equiv == NULL); + add_equivalence (&vr_p->equiv, var); + + /* 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 + will only use it for equality comparisons (EQ_EXPR). For any + other kind of assertion, we cannot derive a range from LIMIT's + anti-range that can be used to describe the new range. For + instance, ASSERT_EXPR . If b_4 is ~[2, 10], + 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 + as well build the range [b_4, +INF] for it. + One special case we handle is extracting a range from a + range test encoded as (unsigned)var + CST <= limit. */ + if (TREE_CODE (op) == NOP_EXPR + || TREE_CODE (op) == PLUS_EXPR) + { + if (TREE_CODE (op) == PLUS_EXPR) + { + min = fold_build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (op, 1)), + TREE_OPERAND (op, 1)); + max = int_const_binop (PLUS_EXPR, limit, min); + op = TREE_OPERAND (op, 0); + } + else + { + min = build_int_cst (TREE_TYPE (var), 0); + max = limit; + } + + /* Make sure to not set TREE_OVERFLOW on the final type + conversion. We are willingly interpreting large positive + unsigned values as negative signed values here. */ + min = force_fit_type (TREE_TYPE (var), wi::to_widest (min), 0, false); + max = force_fit_type (TREE_TYPE (var), wi::to_widest (max), 0, false); + + /* We can transform a max, min range to an anti-range or + vice-versa. Use set_and_canonicalize_value_range which does + this for us. */ + if (cond_code == LE_EXPR) + set_and_canonicalize_value_range (vr_p, VR_RANGE, + min, max, vr_p->equiv); + else if (cond_code == GT_EXPR) + set_and_canonicalize_value_range (vr_p, VR_ANTI_RANGE, + min, max, vr_p->equiv); + else + gcc_unreachable (); + } + else if (cond_code == EQ_EXPR) + { + enum value_range_type range_type; + + if (limit_vr) + { + range_type = limit_vr->type; + min = limit_vr->min; + max = limit_vr->max; + } + else + { + range_type = VR_RANGE; + min = limit; + max = limit; + } + + set_value_range (vr_p, range_type, min, max, vr_p->equiv); + + /* When asserting the equality VAR == LIMIT and LIMIT is another + SSA name, the new range will also inherit the equivalence set + from LIMIT. */ + if (TREE_CODE (limit) == SSA_NAME) + add_equivalence (&vr_p->equiv, limit); + } + else if (cond_code == NE_EXPR) + { + /* As described above, when LIMIT's range is an anti-range and + this assertion is an inequality (NE_EXPR), then we cannot + derive anything from the anti-range. For instance, if + 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 + anti-ranges, we just assert the inequality using LIMIT and + not its anti-range. + + 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 + instance, if LIMIT_VR is [0, 1], the predicate + 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] + and for value 1, VAR should be ~[1, 1]. We cannot + represent these ranges. + + The only situation in which we can build a valid + anti-range is when LIMIT_VR is a single-valued range + (i.e., LIMIT_VR->MIN == LIMIT_VR->MAX). In that case, + build the anti-range ~[LIMIT_VR->MIN, LIMIT_VR->MAX]. */ + if (limit_vr + && limit_vr->type == VR_RANGE + && compare_values (limit_vr->min, limit_vr->max) == 0) + { + min = limit_vr->min; + max = limit_vr->max; + } + else + { + /* In any other case, we cannot use LIMIT's range to build a + valid anti-range. */ + min = max = limit; + } + + /* If MIN and MAX cover the whole range for their type, then + just use the original LIMIT. */ + if (INTEGRAL_TYPE_P (type) + && vrp_val_is_min (min) + && vrp_val_is_max (max)) + min = max = limit; + + set_and_canonicalize_value_range (vr_p, VR_ANTI_RANGE, + min, max, vr_p->equiv); + } + else if (cond_code == LE_EXPR || cond_code == LT_EXPR) + { + min = TYPE_MIN_VALUE (type); + + if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE) + max = limit; + else + { + /* 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 + LT_EXPR. */ + max = limit_vr->max; + } + + /* 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 + all should be optimized away above us. */ + if (cond_code == LT_EXPR + && compare_values (max, min) == 0) + set_value_range_to_varying (vr_p); + else + { + /* For LT_EXPR, we create the range [MIN, MAX - 1]. */ + if (cond_code == LT_EXPR) + { + if (TYPE_PRECISION (TREE_TYPE (max)) == 1 + && !TYPE_UNSIGNED (TREE_TYPE (max))) + max = fold_build2 (PLUS_EXPR, TREE_TYPE (max), max, + build_int_cst (TREE_TYPE (max), -1)); + else + max = fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, + build_int_cst (TREE_TYPE (max), 1)); + /* Signal to compare_values_warnv this expr doesn't overflow. */ + if (EXPR_P (max)) + TREE_NO_WARNING (max) = 1; + } + + set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv); + } + } + else if (cond_code == GE_EXPR || cond_code == GT_EXPR) + { + max = TYPE_MAX_VALUE (type); + + if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE) + min = limit; + else + { + /* 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 + GT_EXPR. */ + min = limit_vr->min; + } + + /* 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 + all should be optimized away above us. */ + if (cond_code == GT_EXPR + && compare_values (min, max) == 0) + set_value_range_to_varying (vr_p); + else + { + /* For GT_EXPR, we create the range [MIN + 1, MAX]. */ + if (cond_code == GT_EXPR) + { + if (TYPE_PRECISION (TREE_TYPE (min)) == 1 + && !TYPE_UNSIGNED (TREE_TYPE (min))) + min = fold_build2 (MINUS_EXPR, TREE_TYPE (min), min, + build_int_cst (TREE_TYPE (min), -1)); + else + min = fold_build2 (PLUS_EXPR, TREE_TYPE (min), min, + build_int_cst (TREE_TYPE (min), 1)); + /* Signal to compare_values_warnv this expr doesn't overflow. */ + if (EXPR_P (min)) + TREE_NO_WARNING (min) = 1; + } + + set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv); + } + } + else + gcc_unreachable (); + + /* Finally intersect the new range with what we already know about var. */ + vrp_intersect_ranges (vr_p, get_value_range (var)); +} + +/* Extract value range information from an ASSERT_EXPR EXPR and store + it in *VR_P. */ + +void +vr_values::extract_range_from_assert (value_range *vr_p, tree expr) +{ + tree var = ASSERT_EXPR_VAR (expr); + tree cond = ASSERT_EXPR_COND (expr); + tree limit, op; + enum tree_code cond_code; + gcc_assert (COMPARISON_CLASS_P (cond)); + + /* Find VAR in the ASSERT_EXPR conditional. */ + if (var == TREE_OPERAND (cond, 0) + || TREE_CODE (TREE_OPERAND (cond, 0)) == PLUS_EXPR + || TREE_CODE (TREE_OPERAND (cond, 0)) == NOP_EXPR) + { + /* If the predicate is of the form VAR COMP LIMIT, then we just + take LIMIT from the RHS and use the same comparison code. */ + cond_code = TREE_CODE (cond); + limit = TREE_OPERAND (cond, 1); + op = TREE_OPERAND (cond, 0); + } + else + { + /* If the predicate is of the form LIMIT COMP VAR, then we need + to flip around the comparison code to create the proper range + for VAR. */ + cond_code = swap_tree_comparison (TREE_CODE (cond)); + limit = TREE_OPERAND (cond, 0); + op = TREE_OPERAND (cond, 1); + } + extract_range_for_var_from_comparison_expr (var, cond_code, op, + limit, vr_p); +} + +/* Extract range information from SSA name VAR and store it in VR. If + VAR has an interesting range, use it. Otherwise, create the + range [VAR, VAR] and return it. This is useful in situations where + we may have conditionals testing values of VARYING names. For + instance, + + 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 + always false. */ + +void +vr_values::extract_range_from_ssa_name (value_range *vr, tree var) +{ + value_range *var_vr = get_value_range (var); + + if (var_vr->type != VR_VARYING) + copy_value_range (vr, var_vr); + else + set_value_range (vr, VR_RANGE, var, var, NULL); + + add_equivalence (&vr->equiv, var); +} + +/* Extract range information from a binary expression OP0 CODE OP1 based on + the ranges of each of its operands with resulting type EXPR_TYPE. + The resulting range is stored in *VR. */ + +void +vr_values::extract_range_from_binary_expr (value_range *vr, + enum tree_code code, + tree expr_type, tree op0, tree op1) +{ + value_range vr0 = VR_INITIALIZER; + value_range vr1 = VR_INITIALIZER; + + /* Get value ranges for each operand. For constant operands, create + a new value range with the operand to simplify processing. */ + if (TREE_CODE (op0) == SSA_NAME) + vr0 = *(get_value_range (op0)); + else if (is_gimple_min_invariant (op0)) + set_value_range_to_value (&vr0, op0, NULL); + else + set_value_range_to_varying (&vr0); + + if (TREE_CODE (op1) == SSA_NAME) + vr1 = *(get_value_range (op1)); + else if (is_gimple_min_invariant (op1)) + set_value_range_to_value (&vr1, op1, NULL); + else + set_value_range_to_varying (&vr1); + + extract_range_from_binary_expr_1 (vr, code, expr_type, &vr0, &vr1); + + /* Try harder for PLUS and MINUS if the range of one operand is symbolic + and based on the other operand, for example if it was deduced from a + symbolic comparison. When a bound of the range of the first operand + is invariant, we set the corresponding bound of the new range to INF + in order to avoid recursing on the range of the second operand. */ + if (vr->type == VR_VARYING + && (code == PLUS_EXPR || code == MINUS_EXPR) + && TREE_CODE (op1) == SSA_NAME + && vr0.type == VR_RANGE + && symbolic_range_based_on_p (&vr0, op1)) + { + const bool minus_p = (code == MINUS_EXPR); + value_range n_vr1 = VR_INITIALIZER; + + /* Try with VR0 and [-INF, OP1]. */ + if (is_gimple_min_invariant (minus_p ? vr0.max : vr0.min)) + set_value_range (&n_vr1, VR_RANGE, vrp_val_min (expr_type), op1, NULL); + + /* Try with VR0 and [OP1, +INF]. */ + else if (is_gimple_min_invariant (minus_p ? vr0.min : vr0.max)) + set_value_range (&n_vr1, VR_RANGE, op1, vrp_val_max (expr_type), NULL); + + /* Try with VR0 and [OP1, OP1]. */ + else + set_value_range (&n_vr1, VR_RANGE, op1, op1, NULL); + + extract_range_from_binary_expr_1 (vr, code, expr_type, &vr0, &n_vr1); + } + + if (vr->type == VR_VARYING + && (code == PLUS_EXPR || code == MINUS_EXPR) + && TREE_CODE (op0) == SSA_NAME + && vr1.type == VR_RANGE + && symbolic_range_based_on_p (&vr1, op0)) + { + const bool minus_p = (code == MINUS_EXPR); + value_range n_vr0 = VR_INITIALIZER; + + /* Try with [-INF, OP0] and VR1. */ + if (is_gimple_min_invariant (minus_p ? vr1.max : vr1.min)) + set_value_range (&n_vr0, VR_RANGE, vrp_val_min (expr_type), op0, NULL); + + /* Try with [OP0, +INF] and VR1. */ + else if (is_gimple_min_invariant (minus_p ? vr1.min : vr1.max)) + set_value_range (&n_vr0, VR_RANGE, op0, vrp_val_max (expr_type), NULL); + + /* Try with [OP0, OP0] and VR1. */ + else + set_value_range (&n_vr0, VR_RANGE, op0, op0, NULL); + + extract_range_from_binary_expr_1 (vr, code, expr_type, &n_vr0, &vr1); + } + + /* If we didn't derive a range for MINUS_EXPR, and + op1's range is ~[op0,op0] or vice-versa, then we + can derive a non-null range. This happens often for + pointer subtraction. */ + if (vr->type == VR_VARYING + && code == MINUS_EXPR + && TREE_CODE (op0) == SSA_NAME + && ((vr0.type == VR_ANTI_RANGE + && vr0.min == op1 + && vr0.min == vr0.max) + || (vr1.type == VR_ANTI_RANGE + && vr1.min == op0 + && vr1.min == vr1.max))) + set_value_range_to_nonnull (vr, TREE_TYPE (op0)); +} + +/* Extract range information from a unary expression CODE OP0 based on + the range of its operand with resulting type TYPE. + The resulting range is stored in *VR. */ + +void +vr_values::extract_range_from_unary_expr (value_range *vr, enum tree_code code, + tree type, tree op0) +{ + value_range vr0 = VR_INITIALIZER; + + /* Get value ranges for the operand. For constant operands, create + a new value range with the operand to simplify processing. */ + if (TREE_CODE (op0) == SSA_NAME) + vr0 = *(get_value_range (op0)); + else if (is_gimple_min_invariant (op0)) + set_value_range_to_value (&vr0, op0, NULL); + else + set_value_range_to_varying (&vr0); + + ::extract_range_from_unary_expr (vr, code, type, &vr0, TREE_TYPE (op0)); +} + + +/* Extract range information from a conditional expression STMT based on + the ranges of each of its operands and the expression code. */ + +void +vr_values::extract_range_from_cond_expr (value_range *vr, gassign *stmt) +{ + tree op0, op1; + value_range vr0 = VR_INITIALIZER; + value_range vr1 = VR_INITIALIZER; + + /* Get value ranges for each operand. For constant operands, create + a new value range with the operand to simplify processing. */ + op0 = gimple_assign_rhs2 (stmt); + if (TREE_CODE (op0) == SSA_NAME) + vr0 = *(get_value_range (op0)); + else if (is_gimple_min_invariant (op0)) + set_value_range_to_value (&vr0, op0, NULL); + else + set_value_range_to_varying (&vr0); + + op1 = gimple_assign_rhs3 (stmt); + if (TREE_CODE (op1) == SSA_NAME) + vr1 = *(get_value_range (op1)); + else if (is_gimple_min_invariant (op1)) + set_value_range_to_value (&vr1, op1, NULL); + else + set_value_range_to_varying (&vr1); + + /* The resulting value range is the union of the operand ranges */ + copy_value_range (vr, &vr0); + vrp_meet (vr, &vr1); +} + + +/* Extract range information from a comparison expression EXPR based + on the range of its operand and the expression code. */ + +void +vr_values::extract_range_from_comparison (value_range *vr, enum tree_code code, + tree type, tree op0, tree op1) +{ + bool sop; + tree val; + + val = vrp_evaluate_conditional_warnv_with_ops (code, op0, op1, false, &sop, + NULL); + if (val) + { + /* Since this expression was found on the RHS of an assignment, + its type may be different from _Bool. Convert VAL to EXPR's + type. */ + val = fold_convert (type, val); + if (is_gimple_min_invariant (val)) + set_value_range_to_value (vr, val, vr->equiv); + else + set_value_range (vr, VR_RANGE, val, val, vr->equiv); + } + else + /* The result of a comparison is always true or false. */ + set_value_range_to_truthvalue (vr, type); +} + +/* Helper function for simplify_internal_call_using_ranges and + extract_range_basic. Return true if OP0 SUBCODE OP1 for + SUBCODE {PLUS,MINUS,MULT}_EXPR is known to never overflow or + always overflow. Set *OVF to true if it is known to always + overflow. */ + +bool +vr_values::check_for_binary_op_overflow (enum tree_code subcode, tree type, + tree op0, tree op1, bool *ovf) +{ + value_range vr0 = VR_INITIALIZER; + value_range vr1 = VR_INITIALIZER; + if (TREE_CODE (op0) == SSA_NAME) + vr0 = *get_value_range (op0); + else if (TREE_CODE (op0) == INTEGER_CST) + set_value_range_to_value (&vr0, op0, NULL); + else + set_value_range_to_varying (&vr0); + + if (TREE_CODE (op1) == SSA_NAME) + vr1 = *get_value_range (op1); + else if (TREE_CODE (op1) == INTEGER_CST) + set_value_range_to_value (&vr1, op1, NULL); + else + set_value_range_to_varying (&vr1); + + if (!range_int_cst_p (&vr0) + || TREE_OVERFLOW (vr0.min) + || TREE_OVERFLOW (vr0.max)) + { + vr0.min = vrp_val_min (TREE_TYPE (op0)); + vr0.max = vrp_val_max (TREE_TYPE (op0)); + } + if (!range_int_cst_p (&vr1) + || TREE_OVERFLOW (vr1.min) + || TREE_OVERFLOW (vr1.max)) + { + vr1.min = vrp_val_min (TREE_TYPE (op1)); + vr1.max = vrp_val_max (TREE_TYPE (op1)); + } + *ovf = arith_overflowed_p (subcode, type, vr0.min, + subcode == MINUS_EXPR ? vr1.max : vr1.min); + if (arith_overflowed_p (subcode, type, vr0.max, + subcode == MINUS_EXPR ? vr1.min : vr1.max) != *ovf) + return false; + if (subcode == MULT_EXPR) + { + if (arith_overflowed_p (subcode, type, vr0.min, vr1.max) != *ovf + || arith_overflowed_p (subcode, type, vr0.max, vr1.min) != *ovf) + return false; + } + if (*ovf) + { + /* So far we found that there is an overflow on the boundaries. + That doesn't prove that there is an overflow even for all values + in between the boundaries. For that compute widest_int range + of the result and see if it doesn't overlap the range of + type. */ + widest_int wmin, wmax; + widest_int w[4]; + int i; + w[0] = wi::to_widest (vr0.min); + w[1] = wi::to_widest (vr0.max); + w[2] = wi::to_widest (vr1.min); + w[3] = wi::to_widest (vr1.max); + for (i = 0; i < 4; i++) + { + widest_int wt; + switch (subcode) + { + case PLUS_EXPR: + wt = wi::add (w[i & 1], w[2 + (i & 2) / 2]); + break; + case MINUS_EXPR: + wt = wi::sub (w[i & 1], w[2 + (i & 2) / 2]); + break; + case MULT_EXPR: + wt = wi::mul (w[i & 1], w[2 + (i & 2) / 2]); + break; + default: + gcc_unreachable (); + } + if (i == 0) + { + wmin = wt; + wmax = wt; + } + else + { + wmin = wi::smin (wmin, wt); + wmax = wi::smax (wmax, wt); + } + } + /* The result of op0 CODE op1 is known to be in range + [wmin, wmax]. */ + widest_int wtmin = wi::to_widest (vrp_val_min (type)); + widest_int wtmax = wi::to_widest (vrp_val_max (type)); + /* If all values in [wmin, wmax] are smaller than + [wtmin, wtmax] or all are larger than [wtmin, wtmax], + the arithmetic operation will always overflow. */ + if (wmax < wtmin || wmin > wtmax) + return true; + return false; + } + return true; +} + +/* Try to derive a nonnegative or nonzero range out of STMT relying + primarily on generic routines in fold in conjunction with range data. + Store the result in *VR */ + +void +vr_values::extract_range_basic (value_range *vr, gimple *stmt) +{ + bool sop; + tree type = gimple_expr_type (stmt); + + if (is_gimple_call (stmt)) + { + tree arg; + int mini, maxi, zerov = 0, prec; + enum tree_code subcode = ERROR_MARK; + combined_fn cfn = gimple_call_combined_fn (stmt); + scalar_int_mode mode; + + switch (cfn) + { + case CFN_BUILT_IN_CONSTANT_P: + /* If the call is __builtin_constant_p and the argument is a + function parameter resolve it to false. This avoids bogus + array bound warnings. + ??? We could do this as early as inlining is finished. */ + arg = gimple_call_arg (stmt, 0); + if (TREE_CODE (arg) == SSA_NAME + && SSA_NAME_IS_DEFAULT_DEF (arg) + && TREE_CODE (SSA_NAME_VAR (arg)) == PARM_DECL + && cfun->after_inlining) + { + set_value_range_to_null (vr, type); + return; + } + break; + /* Both __builtin_ffs* and __builtin_popcount return + [0, prec]. */ + CASE_CFN_FFS: + CASE_CFN_POPCOUNT: + arg = gimple_call_arg (stmt, 0); + prec = TYPE_PRECISION (TREE_TYPE (arg)); + mini = 0; + maxi = prec; + if (TREE_CODE (arg) == SSA_NAME) + { + value_range *vr0 = get_value_range (arg); + /* If arg is non-zero, then ffs or popcount + are non-zero. */ + if ((vr0->type == VR_RANGE + && range_includes_zero_p (vr0->min, vr0->max) == 0) + || (vr0->type == VR_ANTI_RANGE + && range_includes_zero_p (vr0->min, vr0->max) == 1)) + mini = 1; + /* If some high bits are known to be zero, + we can decrease the maximum. */ + if (vr0->type == VR_RANGE + && TREE_CODE (vr0->max) == INTEGER_CST + && !operand_less_p (vr0->min, + build_zero_cst (TREE_TYPE (vr0->min)))) + maxi = tree_floor_log2 (vr0->max) + 1; + } + goto bitop_builtin; + /* __builtin_parity* returns [0, 1]. */ + CASE_CFN_PARITY: + mini = 0; + maxi = 1; + goto bitop_builtin; + /* __builtin_c[lt]z* return [0, prec-1], except for + when the argument is 0, but that is undefined behavior. + On many targets where the CLZ RTL or optab value is defined + for 0 the value is prec, so include that in the range + by default. */ + CASE_CFN_CLZ: + arg = gimple_call_arg (stmt, 0); + prec = TYPE_PRECISION (TREE_TYPE (arg)); + mini = 0; + maxi = prec; + mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg)); + if (optab_handler (clz_optab, mode) != CODE_FOR_nothing + && CLZ_DEFINED_VALUE_AT_ZERO (mode, zerov) + /* Handle only the single common value. */ + && zerov != prec) + /* Magic value to give up, unless vr0 proves + arg is non-zero. */ + mini = -2; + if (TREE_CODE (arg) == SSA_NAME) + { + value_range *vr0 = get_value_range (arg); + /* From clz of VR_RANGE minimum we can compute + result maximum. */ + if (vr0->type == VR_RANGE + && TREE_CODE (vr0->min) == INTEGER_CST) + { + maxi = prec - 1 - tree_floor_log2 (vr0->min); + if (maxi != prec) + mini = 0; + } + else if (vr0->type == VR_ANTI_RANGE + && integer_zerop (vr0->min)) + { + maxi = prec - 1; + mini = 0; + } + if (mini == -2) + break; + /* From clz of VR_RANGE maximum we can compute + result minimum. */ + if (vr0->type == VR_RANGE + && TREE_CODE (vr0->max) == INTEGER_CST) + { + mini = prec - 1 - tree_floor_log2 (vr0->max); + if (mini == prec) + break; + } + } + if (mini == -2) + break; + goto bitop_builtin; + /* __builtin_ctz* return [0, prec-1], except for + when the argument is 0, but that is undefined behavior. + If there is a ctz optab for this mode and + CTZ_DEFINED_VALUE_AT_ZERO, include that in the range, + otherwise just assume 0 won't be seen. */ + CASE_CFN_CTZ: + arg = gimple_call_arg (stmt, 0); + prec = TYPE_PRECISION (TREE_TYPE (arg)); + mini = 0; + maxi = prec - 1; + mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg)); + if (optab_handler (ctz_optab, mode) != CODE_FOR_nothing + && CTZ_DEFINED_VALUE_AT_ZERO (mode, zerov)) + { + /* Handle only the two common values. */ + if (zerov == -1) + mini = -1; + else if (zerov == prec) + maxi = prec; + else + /* Magic value to give up, unless vr0 proves + arg is non-zero. */ + mini = -2; + } + if (TREE_CODE (arg) == SSA_NAME) + { + value_range *vr0 = get_value_range (arg); + /* If arg is non-zero, then use [0, prec - 1]. */ + if ((vr0->type == VR_RANGE + && integer_nonzerop (vr0->min)) + || (vr0->type == VR_ANTI_RANGE + && integer_zerop (vr0->min))) + { + mini = 0; + maxi = prec - 1; + } + /* If some high bits are known to be zero, + we can decrease the result maximum. */ + if (vr0->type == VR_RANGE + && TREE_CODE (vr0->max) == INTEGER_CST) + { + maxi = tree_floor_log2 (vr0->max); + /* For vr0 [0, 0] give up. */ + if (maxi == -1) + break; + } + } + if (mini == -2) + break; + goto bitop_builtin; + /* __builtin_clrsb* returns [0, prec-1]. */ + CASE_CFN_CLRSB: + arg = gimple_call_arg (stmt, 0); + prec = TYPE_PRECISION (TREE_TYPE (arg)); + mini = 0; + maxi = prec - 1; + goto bitop_builtin; + bitop_builtin: + set_value_range (vr, VR_RANGE, build_int_cst (type, mini), + build_int_cst (type, maxi), NULL); + return; + case CFN_UBSAN_CHECK_ADD: + subcode = PLUS_EXPR; + break; + case CFN_UBSAN_CHECK_SUB: + subcode = MINUS_EXPR; + break; + case CFN_UBSAN_CHECK_MUL: + subcode = MULT_EXPR; + break; + case CFN_GOACC_DIM_SIZE: + case CFN_GOACC_DIM_POS: + /* Optimizing these two internal functions helps the loop + optimizer eliminate outer comparisons. Size is [1,N] + and pos is [0,N-1]. */ + { + bool is_pos = cfn == CFN_GOACC_DIM_POS; + int axis = oacc_get_ifn_dim_arg (stmt); + int size = oacc_get_fn_dim_size (current_function_decl, axis); + + if (!size) + /* If it's dynamic, the backend might know a hardware + limitation. */ + size = targetm.goacc.dim_limit (axis); + + tree type = TREE_TYPE (gimple_call_lhs (stmt)); + set_value_range (vr, VR_RANGE, + build_int_cst (type, is_pos ? 0 : 1), + size ? build_int_cst (type, size - is_pos) + : vrp_val_max (type), NULL); + } + return; + case CFN_BUILT_IN_STRLEN: + if (tree lhs = gimple_call_lhs (stmt)) + if (ptrdiff_type_node + && (TYPE_PRECISION (ptrdiff_type_node) + == TYPE_PRECISION (TREE_TYPE (lhs)))) + { + tree type = TREE_TYPE (lhs); + tree max = vrp_val_max (ptrdiff_type_node); + wide_int wmax = wi::to_wide (max, TYPE_PRECISION (TREE_TYPE (max))); + tree range_min = build_zero_cst (type); + tree range_max = wide_int_to_tree (type, wmax - 1); + set_value_range (vr, VR_RANGE, range_min, range_max, NULL); + return; + } + break; + default: + break; + } + if (subcode != ERROR_MARK) + { + bool saved_flag_wrapv = flag_wrapv; + /* Pretend the arithmetics is wrapping. If there is + any overflow, we'll complain, but will actually do + wrapping operation. */ + flag_wrapv = 1; + extract_range_from_binary_expr (vr, subcode, type, + gimple_call_arg (stmt, 0), + gimple_call_arg (stmt, 1)); + flag_wrapv = saved_flag_wrapv; + + /* If for both arguments vrp_valueize returned non-NULL, + this should have been already folded and if not, it + wasn't folded because of overflow. Avoid removing the + UBSAN_CHECK_* calls in that case. */ + if (vr->type == VR_RANGE + && (vr->min == vr->max + || operand_equal_p (vr->min, vr->max, 0))) + set_value_range_to_varying (vr); + return; + } + } + /* Handle extraction of the two results (result of arithmetics and + a flag whether arithmetics overflowed) from {ADD,SUB,MUL}_OVERFLOW + internal function. Similarly from ATOMIC_COMPARE_EXCHANGE. */ + else if (is_gimple_assign (stmt) + && (gimple_assign_rhs_code (stmt) == REALPART_EXPR + || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR) + && INTEGRAL_TYPE_P (type)) + { + enum tree_code code = gimple_assign_rhs_code (stmt); + tree op = gimple_assign_rhs1 (stmt); + if (TREE_CODE (op) == code && TREE_CODE (TREE_OPERAND (op, 0)) == SSA_NAME) + { + gimple *g = SSA_NAME_DEF_STMT (TREE_OPERAND (op, 0)); + if (is_gimple_call (g) && gimple_call_internal_p (g)) + { + enum tree_code subcode = ERROR_MARK; + switch (gimple_call_internal_fn (g)) + { + case IFN_ADD_OVERFLOW: + subcode = PLUS_EXPR; + break; + case IFN_SUB_OVERFLOW: + subcode = MINUS_EXPR; + break; + case IFN_MUL_OVERFLOW: + subcode = MULT_EXPR; + break; + case IFN_ATOMIC_COMPARE_EXCHANGE: + if (code == IMAGPART_EXPR) + { + /* This is the boolean return value whether compare and + exchange changed anything or not. */ + set_value_range (vr, VR_RANGE, build_int_cst (type, 0), + build_int_cst (type, 1), NULL); + return; + } + break; + default: + break; + } + if (subcode != ERROR_MARK) + { + tree op0 = gimple_call_arg (g, 0); + tree op1 = gimple_call_arg (g, 1); + if (code == IMAGPART_EXPR) + { + bool ovf = false; + if (check_for_binary_op_overflow (subcode, type, + op0, op1, &ovf)) + set_value_range_to_value (vr, + build_int_cst (type, ovf), + NULL); + else if (TYPE_PRECISION (type) == 1 + && !TYPE_UNSIGNED (type)) + set_value_range_to_varying (vr); + else + set_value_range (vr, VR_RANGE, build_int_cst (type, 0), + build_int_cst (type, 1), NULL); + } + else if (types_compatible_p (type, TREE_TYPE (op0)) + && types_compatible_p (type, TREE_TYPE (op1))) + { + bool saved_flag_wrapv = flag_wrapv; + /* Pretend the arithmetics is wrapping. If there is + any overflow, IMAGPART_EXPR will be set. */ + flag_wrapv = 1; + extract_range_from_binary_expr (vr, subcode, type, + op0, op1); + flag_wrapv = saved_flag_wrapv; + } + else + { + value_range vr0 = VR_INITIALIZER; + value_range vr1 = VR_INITIALIZER; + bool saved_flag_wrapv = flag_wrapv; + /* Pretend the arithmetics is wrapping. If there is + any overflow, IMAGPART_EXPR will be set. */ + flag_wrapv = 1; + extract_range_from_unary_expr (&vr0, NOP_EXPR, + type, op0); + extract_range_from_unary_expr (&vr1, NOP_EXPR, + type, op1); + extract_range_from_binary_expr_1 (vr, subcode, type, + &vr0, &vr1); + flag_wrapv = saved_flag_wrapv; + } + return; + } + } + } + } + if (INTEGRAL_TYPE_P (type) + && gimple_stmt_nonnegative_warnv_p (stmt, &sop)) + set_value_range_to_nonnegative (vr, type); + else if (vrp_stmt_computes_nonzero (stmt)) + set_value_range_to_nonnull (vr, type); + else + set_value_range_to_varying (vr); +} + + +/* Try to compute a useful range out of assignment STMT and store it + in *VR. */ + +void +vr_values::extract_range_from_assignment (value_range *vr, gassign *stmt) +{ + enum tree_code code = gimple_assign_rhs_code (stmt); + + if (code == ASSERT_EXPR) + extract_range_from_assert (vr, gimple_assign_rhs1 (stmt)); + else if (code == SSA_NAME) + extract_range_from_ssa_name (vr, gimple_assign_rhs1 (stmt)); + else if (TREE_CODE_CLASS (code) == tcc_binary) + extract_range_from_binary_expr (vr, gimple_assign_rhs_code (stmt), + gimple_expr_type (stmt), + gimple_assign_rhs1 (stmt), + gimple_assign_rhs2 (stmt)); + else if (TREE_CODE_CLASS (code) == tcc_unary) + extract_range_from_unary_expr (vr, gimple_assign_rhs_code (stmt), + gimple_expr_type (stmt), + gimple_assign_rhs1 (stmt)); + else if (code == COND_EXPR) + extract_range_from_cond_expr (vr, stmt); + else if (TREE_CODE_CLASS (code) == tcc_comparison) + extract_range_from_comparison (vr, gimple_assign_rhs_code (stmt), + gimple_expr_type (stmt), + gimple_assign_rhs1 (stmt), + gimple_assign_rhs2 (stmt)); + else if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS + && is_gimple_min_invariant (gimple_assign_rhs1 (stmt))) + set_value_range_to_value (vr, gimple_assign_rhs1 (stmt), NULL); + else + set_value_range_to_varying (vr); + + if (vr->type == VR_VARYING) + extract_range_basic (vr, stmt); +} + +/* Given two numeric value ranges VR0, VR1 and a comparison code COMP: + + - Return BOOLEAN_TRUE_NODE if VR0 COMP VR1 always returns true for + all the values in the ranges. + + - Return BOOLEAN_FALSE_NODE if the comparison always returns false. + + - Return NULL_TREE if it is not always possible to determine the + value of the comparison. + + Also set *STRICT_OVERFLOW_P to indicate whether comparision evaluation + assumed signed overflow is undefined. */ + + +static tree +compare_ranges (enum tree_code comp, value_range *vr0, value_range *vr1, + bool *strict_overflow_p) +{ + /* VARYING or UNDEFINED ranges cannot be compared. */ + if (vr0->type == VR_VARYING + || vr0->type == VR_UNDEFINED + || vr1->type == VR_VARYING + || vr1->type == VR_UNDEFINED) + return NULL_TREE; + + /* Anti-ranges need to be handled separately. */ + if (vr0->type == VR_ANTI_RANGE || vr1->type == VR_ANTI_RANGE) + { + /* If both are anti-ranges, then we cannot compute any + comparison. */ + if (vr0->type == VR_ANTI_RANGE && vr1->type == VR_ANTI_RANGE) + return NULL_TREE; + + /* These comparisons are never statically computable. */ + if (comp == GT_EXPR + || comp == GE_EXPR + || comp == LT_EXPR + || comp == LE_EXPR) + return NULL_TREE; + + /* Equality can be computed only between a range and an + anti-range. ~[VAL1, VAL2] == [VAL1, VAL2] is always false. */ + if (vr0->type == VR_RANGE) + { + /* To simplify processing, make VR0 the anti-range. */ + value_range *tmp = vr0; + vr0 = vr1; + vr1 = tmp; + } + + gcc_assert (comp == NE_EXPR || comp == EQ_EXPR); + + if (compare_values_warnv (vr0->min, vr1->min, 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 NULL_TREE; + } + + /* Simplify processing. If COMP is GT_EXPR or GE_EXPR, switch the + operands around and change the comparison code. */ + if (comp == GT_EXPR || comp == GE_EXPR) + { + comp = (comp == GT_EXPR) ? LT_EXPR : LE_EXPR; + std::swap (vr0, vr1); + } + + if (comp == EQ_EXPR) + { + /* Equality may only be computed if both ranges represent + exactly one value. */ + if (compare_values_warnv (vr0->min, vr0->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, + strict_overflow_p); + int cmp_max = compare_values_warnv (vr0->max, vr1->max, + strict_overflow_p); + if (cmp_min == 0 && cmp_max == 0) + return boolean_true_node; + else if (cmp_min != -2 && cmp_max != -2) + return boolean_false_node; + } + /* If [V0_MIN, V1_MAX] < [V1_MIN, V1_MAX] then V0 != V1. */ + else if (compare_values_warnv (vr0->min, vr1->max, + strict_overflow_p) == 1 + || compare_values_warnv (vr1->min, vr0->max, + strict_overflow_p) == 1) + return boolean_false_node; + + return NULL_TREE; + } + else if (comp == NE_EXPR) + { + int cmp1, cmp2; + + /* If VR0 is completely to the left or completely to the right + of VR1, they are always different. Notice that we need to + make sure that both comparisons yield similar results to + avoid comparing values that cannot be compared at + compile-time. */ + cmp1 = compare_values_warnv (vr0->max, vr1->min, strict_overflow_p); + cmp2 = compare_values_warnv (vr0->min, vr1->max, strict_overflow_p); + if ((cmp1 == -1 && cmp2 == -1) || (cmp1 == 1 && cmp2 == 1)) + return boolean_true_node; + + /* If VR0 and VR1 represent a single value and are identical, + return false. */ + else 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 (vr0->min, vr1->min, + strict_overflow_p) == 0 + && compare_values_warnv (vr0->max, vr1->max, + strict_overflow_p) == 0) + return boolean_false_node; + + /* Otherwise, they may or may not be different. */ + else + return NULL_TREE; + } + else if (comp == LT_EXPR || comp == LE_EXPR) + { + int tst; + + /* If VR0 is to the left of VR1, return true. */ + tst = compare_values_warnv (vr0->max, vr1->min, strict_overflow_p); + if ((comp == LT_EXPR && tst == -1) + || (comp == LE_EXPR && (tst == -1 || tst == 0))) + return boolean_true_node; + + /* If VR0 is to the right of VR1, return false. */ + tst = compare_values_warnv (vr0->min, vr1->max, strict_overflow_p); + if ((comp == LT_EXPR && (tst == 0 || tst == 1)) + || (comp == LE_EXPR && tst == 1)) + return boolean_false_node; + + /* Otherwise, we don't know. */ + return NULL_TREE; + } + + gcc_unreachable (); +} + +/* 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 + values in VR. Return BOOLEAN_FALSE_NODE if the comparison + always returns false. Return NULL_TREE if it is not always + possible to determine the value of the comparison. Also set + *STRICT_OVERFLOW_P to indicate whether comparision evaluation + assumed signed overflow is undefined. */ + +static tree +compare_range_with_value (enum tree_code comp, value_range *vr, tree val, + bool *strict_overflow_p) +{ + if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED) + return NULL_TREE; + + /* Anti-ranges need to be handled separately. */ + if (vr->type == VR_ANTI_RANGE) + { + /* For anti-ranges, the only predicates that we can compute at + compile time are equality and inequality. */ + if (comp == GT_EXPR + || comp == GE_EXPR + || comp == LT_EXPR + || comp == LE_EXPR) + return NULL_TREE; + + /* ~[VAL_1, VAL_2] OP VAL is known if VAL_1 <= VAL <= VAL_2. */ + if (value_inside_range (val, vr->min, vr->max) == 1) + return (comp == NE_EXPR) ? boolean_true_node : boolean_false_node; + + return NULL_TREE; + } + + if (comp == EQ_EXPR) + { + /* EQ_EXPR may only be computed if VR represents exactly + one value. */ + if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0) + { + int cmp = compare_values_warnv (vr->min, val, strict_overflow_p); + if (cmp == 0) + return boolean_true_node; + else if (cmp == -1 || cmp == 1 || cmp == 2) + return boolean_false_node; + } + else if (compare_values_warnv (val, vr->min, strict_overflow_p) == -1 + || compare_values_warnv (vr->max, val, strict_overflow_p) == -1) + return boolean_false_node; + + return NULL_TREE; + } + else if (comp == NE_EXPR) + { + /* If VAL is not inside VR, then they are always different. */ + if (compare_values_warnv (vr->max, val, strict_overflow_p) == -1 + || compare_values_warnv (vr->min, val, strict_overflow_p) == 1) + return boolean_true_node; + + /* If VR represents exactly one value equal to VAL, then return + false. */ + if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0 + && compare_values_warnv (vr->min, val, strict_overflow_p) == 0) + return boolean_false_node; + + /* Otherwise, they may or may not be different. */ + return NULL_TREE; + } + else if (comp == LT_EXPR || comp == LE_EXPR) + { + int tst; + + /* If VR is to the left of VAL, return true. */ + tst = compare_values_warnv (vr->max, val, strict_overflow_p); + if ((comp == LT_EXPR && tst == -1) + || (comp == LE_EXPR && (tst == -1 || tst == 0))) + return boolean_true_node; + + /* If VR is to the right of VAL, return false. */ + tst = compare_values_warnv (vr->min, val, strict_overflow_p); + if ((comp == LT_EXPR && (tst == 0 || tst == 1)) + || (comp == LE_EXPR && tst == 1)) + return boolean_false_node; + + /* Otherwise, we don't know. */ + return NULL_TREE; + } + else if (comp == GT_EXPR || comp == GE_EXPR) + { + int tst; + + /* If VR is to the right of VAL, return true. */ + tst = compare_values_warnv (vr->min, val, strict_overflow_p); + if ((comp == GT_EXPR && tst == 1) + || (comp == GE_EXPR && (tst == 0 || tst == 1))) + return boolean_true_node; + + /* If VR is to the left of VAL, return false. */ + tst = compare_values_warnv (vr->max, val, strict_overflow_p); + if ((comp == GT_EXPR && (tst == -1 || tst == 0)) + || (comp == GE_EXPR && tst == -1)) + return boolean_false_node; + + /* Otherwise, we don't know. */ + return NULL_TREE; + } + + gcc_unreachable (); +} +/* Given a range VR, a LOOP and a variable VAR, determine whether it + would be profitable to adjust VR using scalar evolution information + for VAR. If so, update VR with the new limits. */ + +void +vr_values::adjust_range_with_scev (value_range *vr, struct loop *loop, + gimple *stmt, tree var) +{ + tree init, step, chrec, tmin, tmax, min, max, type, tem; + enum ev_direction dir; + + /* TODO. Don't adjust anti-ranges. An anti-range may provide + better opportunities than a regular range, but I'm not sure. */ + if (vr->type == VR_ANTI_RANGE) + return; + + chrec = instantiate_parameters (loop, analyze_scalar_evolution (loop, var)); + + /* Like in PR19590, scev can return a constant function. */ + if (is_gimple_min_invariant (chrec)) + { + set_value_range_to_value (vr, chrec, vr->equiv); + return; + } + + if (TREE_CODE (chrec) != POLYNOMIAL_CHREC) + return; + + init = initial_condition_in_loop_num (chrec, loop->num); + tem = op_with_constant_singleton_value_range (init); + if (tem) + init = tem; + step = evolution_part_in_loop_num (chrec, loop->num); + tem = op_with_constant_singleton_value_range (step); + if (tem) + step = tem; + + /* If STEP is symbolic, we can't know whether INIT will be the + minimum or maximum value in the range. Also, unless INIT is + a simple expression, compare_values and possibly other functions + in tree-vrp won't be able to handle it. */ + if (step == NULL_TREE + || !is_gimple_min_invariant (step) + || !valid_value_p (init)) + return; + + dir = scev_direction (chrec); + if (/* Do not adjust ranges if we do not know whether the iv increases + or decreases, ... */ + dir == EV_DIR_UNKNOWN + /* ... or if it may wrap. */ + || scev_probably_wraps_p (NULL_TREE, init, step, stmt, + get_chrec_loop (chrec), true)) + return; + + type = TREE_TYPE (var); + if (POINTER_TYPE_P (type) || !TYPE_MIN_VALUE (type)) + tmin = lower_bound_in_type (type, type); + else + tmin = TYPE_MIN_VALUE (type); + if (POINTER_TYPE_P (type) || !TYPE_MAX_VALUE (type)) + tmax = upper_bound_in_type (type, type); + else + tmax = TYPE_MAX_VALUE (type); + + /* Try to use estimated number of iterations for the loop to constrain the + final value in the evolution. */ + if (TREE_CODE (step) == INTEGER_CST + && is_gimple_val (init) + && (TREE_CODE (init) != SSA_NAME + || get_value_range (init)->type == VR_RANGE)) + { + widest_int nit; + + /* We are only entering here for loop header PHI nodes, so using + the number of latch executions is the correct thing to use. */ + if (max_loop_iterations (loop, &nit)) + { + value_range maxvr = VR_INITIALIZER; + signop sgn = TYPE_SIGN (TREE_TYPE (step)); + bool overflow; + + widest_int wtmp = wi::mul (wi::to_widest (step), nit, sgn, + &overflow); + /* If the multiplication overflowed we can't do a meaningful + adjustment. Likewise if the result doesn't fit in the type + of the induction variable. For a signed type we have to + check whether the result has the expected signedness which + is that of the step as number of iterations is unsigned. */ + if (!overflow + && wi::fits_to_tree_p (wtmp, TREE_TYPE (init)) + && (sgn == UNSIGNED + || wi::gts_p (wtmp, 0) == wi::gts_p (wi::to_wide (step), 0))) + { + tem = wide_int_to_tree (TREE_TYPE (init), wtmp); + extract_range_from_binary_expr (&maxvr, PLUS_EXPR, + TREE_TYPE (init), init, tem); + /* Likewise if the addition did. */ + if (maxvr.type == VR_RANGE) + { + value_range initvr = VR_INITIALIZER; + + if (TREE_CODE (init) == SSA_NAME) + initvr = *(get_value_range (init)); + else if (is_gimple_min_invariant (init)) + set_value_range_to_value (&initvr, init, NULL); + else + return; + + /* Check if init + nit * step overflows. Though we checked + scev {init, step}_loop doesn't wrap, it is not enough + because the loop may exit immediately. Overflow could + happen in the plus expression in this case. */ + if ((dir == EV_DIR_DECREASES + && compare_values (maxvr.min, initvr.min) != -1) + || (dir == EV_DIR_GROWS + && compare_values (maxvr.max, initvr.max) != 1)) + return; + + tmin = maxvr.min; + tmax = maxvr.max; + } + } + } + } + + if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED) + { + min = tmin; + max = tmax; + + /* For VARYING or UNDEFINED ranges, just about anything we get + from scalar evolutions should be better. */ + + if (dir == EV_DIR_DECREASES) + max = init; + else + min = init; + } + else if (vr->type == VR_RANGE) + { + min = vr->min; + max = vr->max; + + if (dir == EV_DIR_DECREASES) + { + /* INIT is the maximum value. If INIT is lower than VR->MAX + but no smaller than VR->MIN, set VR->MAX to INIT. */ + if (compare_values (init, max) == -1) + max = init; + + /* According to the loop information, the variable does not + overflow. */ + if (compare_values (min, tmin) == -1) + min = tmin; + + } + else + { + /* If INIT is bigger than VR->MIN, set VR->MIN to INIT. */ + if (compare_values (init, min) == 1) + min = init; + + if (compare_values (tmax, max) == -1) + max = tmax; + } + } + else + return; + + /* If we just created an invalid range with the minimum + greater than the maximum, we fail conservatively. + This should happen only in unreachable + parts of code, or for invalid programs. */ + if (compare_values (min, max) == 1) + return; + + /* Even for valid range info, sometimes overflow flag will leak in. + As GIMPLE IL should have no constants with TREE_OVERFLOW set, we + drop them. */ + if (TREE_OVERFLOW_P (min)) + min = drop_tree_overflow (min); + if (TREE_OVERFLOW_P (max)) + max = drop_tree_overflow (max); + + set_value_range (vr, VR_RANGE, min, max, vr->equiv); +} + +/* Dump value ranges of all SSA_NAMEs to FILE. */ + +void +vr_values::dump_all_value_ranges (FILE *file) +{ + size_t i; + + for (i = 0; i < num_vr_values; i++) + { + if (vr_value[i]) + { + print_generic_expr (file, ssa_name (i)); + fprintf (file, ": "); + dump_value_range (file, vr_value[i]); + fprintf (file, "\n"); + } + } + + fprintf (file, "\n"); +} + +/* Initialize VRP lattice. */ + +vr_values::vr_values () : vrp_value_range_pool ("Tree VRP value ranges") +{ + values_propagated = false; + num_vr_values = num_ssa_names; + vr_value = XCNEWVEC (value_range *, num_vr_values); + vr_phi_edge_counts = XCNEWVEC (int, num_ssa_names); + bitmap_obstack_initialize (&vrp_equiv_obstack); +} + +/* Free VRP lattice. */ + +vr_values::~vr_values () +{ + /* Free allocated memory. */ + free (vr_value); + free (vr_phi_edge_counts); + bitmap_obstack_release (&vrp_equiv_obstack); + vrp_value_range_pool.release (); + + /* So that we can distinguish between VRP data being available + and not available. */ + vr_value = NULL; + vr_phi_edge_counts = NULL; +} + + +/* A hack. */ +static class vr_values *x_vr_values; + +/* Return the singleton value-range for NAME or NAME. */ + +static inline tree +vrp_valueize (tree name) +{ + if (TREE_CODE (name) == SSA_NAME) + { + value_range *vr = x_vr_values->get_value_range (name); + if (vr->type == VR_RANGE + && (TREE_CODE (vr->min) == SSA_NAME + || is_gimple_min_invariant (vr->min)) + && vrp_operand_equal_p (vr->min, vr->max)) + return vr->min; + } + return name; +} + +/* Return the singleton value-range for NAME if that is a constant + but signal to not follow SSA edges. */ + +static inline tree +vrp_valueize_1 (tree name) +{ + if (TREE_CODE (name) == SSA_NAME) + { + /* If the definition may be simulated again we cannot follow + this SSA edge as the SSA propagator does not necessarily + re-visit the use. */ + gimple *def_stmt = SSA_NAME_DEF_STMT (name); + if (!gimple_nop_p (def_stmt) + && prop_simulate_again_p (def_stmt)) + return NULL_TREE; + value_range *vr = x_vr_values->get_value_range (name); + if (range_int_cst_singleton_p (vr)) + return vr->min; + } + return name; +} +/* Visit assignment STMT. If it produces an interesting range, record + the range in VR and set LHS to OUTPUT_P. */ + +void +vr_values::vrp_visit_assignment_or_call (gimple *stmt, tree *output_p, + value_range *vr) +{ + tree lhs; + enum gimple_code code = gimple_code (stmt); + lhs = gimple_get_lhs (stmt); + *output_p = NULL_TREE; + + /* We only keep track of ranges in integral and pointer types. */ + if (TREE_CODE (lhs) == SSA_NAME + && ((INTEGRAL_TYPE_P (TREE_TYPE (lhs)) + /* It is valid to have NULL MIN/MAX values on a type. See + build_range_type. */ + && TYPE_MIN_VALUE (TREE_TYPE (lhs)) + && TYPE_MAX_VALUE (TREE_TYPE (lhs))) + || POINTER_TYPE_P (TREE_TYPE (lhs)))) + { + *output_p = lhs; + + /* Try folding the statement to a constant first. */ + x_vr_values = this; + tree tem = gimple_fold_stmt_to_constant_1 (stmt, vrp_valueize, + vrp_valueize_1); + x_vr_values = NULL; + if (tem) + { + if (TREE_CODE (tem) == SSA_NAME + && (SSA_NAME_IS_DEFAULT_DEF (tem) + || ! prop_simulate_again_p (SSA_NAME_DEF_STMT (tem)))) + { + extract_range_from_ssa_name (vr, tem); + return; + } + else if (is_gimple_min_invariant (tem)) + { + set_value_range_to_value (vr, tem, NULL); + return; + } + } + /* Then dispatch to value-range extracting functions. */ + if (code == GIMPLE_CALL) + extract_range_basic (vr, stmt); + else + extract_range_from_assignment (vr, as_a (stmt)); + } +} + +/* Helper that gets the value range of the SSA_NAME with version I + or a symbolic range containing the SSA_NAME only if the value range + is varying or undefined. */ + +value_range +vr_values::get_vr_for_comparison (int i) +{ + value_range vr = *get_value_range (ssa_name (i)); + + /* 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 + have N_i in their ranges. */ + if (vr.type == VR_VARYING || vr.type == VR_UNDEFINED) + { + vr.type = VR_RANGE; + vr.min = ssa_name (i); + vr.max = ssa_name (i); + } + + return vr; +} + +/* Compare all the value ranges for names equivalent to VAR with VAL + using comparison code COMP. Return the same value returned by + compare_range_with_value, including the setting of + *STRICT_OVERFLOW_P. */ + +tree +vr_values::compare_name_with_value (enum tree_code comp, tree var, tree val, + bool *strict_overflow_p, bool use_equiv_p) +{ + bitmap_iterator bi; + unsigned i; + bitmap e; + tree retval, t; + int used_strict_overflow; + bool sop; + value_range equiv_vr; + + /* Get the set of equivalences for VAR. */ + e = get_value_range (var)->equiv; + + /* Start at -1. Set it to 0 if we do a comparison without relying + on overflow, or 1 if all comparisons rely on overflow. */ + used_strict_overflow = -1; + + /* Compare vars' value range with val. */ + equiv_vr = get_vr_for_comparison (SSA_NAME_VERSION (var)); + sop = false; + retval = compare_range_with_value (comp, &equiv_vr, val, &sop); + if (retval) + used_strict_overflow = sop ? 1 : 0; + + /* If the equiv set is empty we have done all work we need to do. */ + if (e == NULL) + { + if (retval + && used_strict_overflow > 0) + *strict_overflow_p = true; + return retval; + } + + EXECUTE_IF_SET_IN_BITMAP (e, 0, i, bi) + { + tree name = ssa_name (i); + if (! name) + continue; + + if (! use_equiv_p + && ! SSA_NAME_IS_DEFAULT_DEF (name) + && prop_simulate_again_p (SSA_NAME_DEF_STMT (name))) + continue; + + equiv_vr = get_vr_for_comparison (i); + sop = false; + t = compare_range_with_value (comp, &equiv_vr, val, &sop); + if (t) + { + /* If we get different answers from different members + of the equivalence set this check must be in a dead + code region. Folding it to a trap representation + would be correct here. For now just return don't-know. */ + if (retval != NULL + && t != retval) + { + retval = NULL_TREE; + break; + } + retval = t; + + if (!sop) + used_strict_overflow = 0; + else if (used_strict_overflow < 0) + used_strict_overflow = 1; + } + } + + if (retval + && used_strict_overflow > 0) + *strict_overflow_p = true; + + return retval; +} + + +/* Given a comparison code COMP and names N1 and N2, compare all the + ranges equivalent to N1 against all the ranges equivalent to N2 + to determine the value of N1 COMP N2. Return the same value + returned by compare_ranges. Set *STRICT_OVERFLOW_P to indicate + whether we relied on undefined signed overflow in the comparison. */ + + +tree +vr_values::compare_names (enum tree_code comp, tree n1, tree n2, + bool *strict_overflow_p) +{ + tree t, retval; + bitmap e1, e2; + bitmap_iterator bi1, bi2; + unsigned i1, i2; + int used_strict_overflow; + static bitmap_obstack *s_obstack = NULL; + static bitmap s_e1 = NULL, s_e2 = NULL; + + /* Compare the ranges of every name equivalent to N1 against the + ranges of every name equivalent to N2. */ + e1 = get_value_range (n1)->equiv; + e2 = get_value_range (n2)->equiv; + + /* Use the fake bitmaps if e1 or e2 are not available. */ + if (s_obstack == NULL) + { + s_obstack = XNEW (bitmap_obstack); + bitmap_obstack_initialize (s_obstack); + s_e1 = BITMAP_ALLOC (s_obstack); + s_e2 = BITMAP_ALLOC (s_obstack); + } + if (e1 == NULL) + e1 = s_e1; + if (e2 == NULL) + e2 = s_e2; + + /* Add N1 and N2 to their own set of equivalences to avoid + duplicating the body of the loop just to check N1 and N2 + ranges. */ + bitmap_set_bit (e1, SSA_NAME_VERSION (n1)); + bitmap_set_bit (e2, SSA_NAME_VERSION (n2)); + + /* If the equivalence sets have a common intersection, then the two + names can be compared without checking their ranges. */ + if (bitmap_intersect_p (e1, e2)) + { + bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); + bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); + + return (comp == EQ_EXPR || comp == GE_EXPR || comp == LE_EXPR) + ? boolean_true_node + : boolean_false_node; + } + + /* Start at -1. Set it to 0 if we do a comparison without relying + on overflow, or 1 if all comparisons rely on overflow. */ + used_strict_overflow = -1; + + /* Otherwise, compare all the equivalent ranges. First, add N1 and + N2 to their own set of equivalences to avoid duplicating the body + of the loop just to check N1 and N2 ranges. */ + EXECUTE_IF_SET_IN_BITMAP (e1, 0, i1, bi1) + { + if (! ssa_name (i1)) + continue; + + value_range vr1 = get_vr_for_comparison (i1); + + t = retval = NULL_TREE; + EXECUTE_IF_SET_IN_BITMAP (e2, 0, i2, bi2) + { + if (! ssa_name (i2)) + continue; + + bool sop = false; + + value_range vr2 = get_vr_for_comparison (i2); + + t = compare_ranges (comp, &vr1, &vr2, &sop); + if (t) + { + /* If we get different answers from different members + of the equivalence set this check must be in a dead + code region. Folding it to a trap representation + would be correct here. For now just return don't-know. */ + if (retval != NULL + && t != retval) + { + bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); + bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); + return NULL_TREE; + } + retval = t; + + if (!sop) + used_strict_overflow = 0; + else if (used_strict_overflow < 0) + used_strict_overflow = 1; + } + } + + if (retval) + { + bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); + bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); + if (used_strict_overflow > 0) + *strict_overflow_p = true; + return retval; + } + } + + /* None of the equivalent ranges are useful in computing this + comparison. */ + bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); + bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); + return NULL_TREE; +} + +/* Helper function for vrp_evaluate_conditional_warnv & other + optimizers. */ + +tree +vr_values::vrp_evaluate_conditional_warnv_with_ops_using_ranges + (enum tree_code code, tree op0, tree op1, bool * strict_overflow_p) +{ + value_range *vr0, *vr1; + + vr0 = (TREE_CODE (op0) == SSA_NAME) ? get_value_range (op0) : NULL; + vr1 = (TREE_CODE (op1) == SSA_NAME) ? get_value_range (op1) : NULL; + + tree res = NULL_TREE; + if (vr0 && vr1) + res = compare_ranges (code, vr0, vr1, strict_overflow_p); + if (!res && vr0) + res = compare_range_with_value (code, vr0, op1, strict_overflow_p); + if (!res && vr1) + res = (compare_range_with_value + (swap_tree_comparison (code), vr1, op0, strict_overflow_p)); + return res; +} + +/* Helper function for vrp_evaluate_conditional_warnv. */ + +tree +vr_values::vrp_evaluate_conditional_warnv_with_ops (enum tree_code code, + tree op0, tree op1, + bool use_equiv_p, + bool *strict_overflow_p, + bool *only_ranges) +{ + tree ret; + if (only_ranges) + *only_ranges = true; + + /* We only deal with integral and pointer types. */ + if (!INTEGRAL_TYPE_P (TREE_TYPE (op0)) + && !POINTER_TYPE_P (TREE_TYPE (op0))) + return NULL_TREE; + + /* If OP0 CODE OP1 is an overflow comparison, if it can be expressed + as a simple equality test, then prefer that over its current form + for evaluation. + + An overflow test which collapses to an equality test can always be + expressed as a comparison of one argument against zero. Overflow + occurs when the chosen argument is zero and does not occur if the + chosen argument is not zero. */ + tree x; + if (overflow_comparison_p (code, op0, op1, use_equiv_p, &x)) + { + wide_int max = wi::max_value (TYPE_PRECISION (TREE_TYPE (op0)), UNSIGNED); + /* B = A - 1; if (A < B) -> B = A - 1; if (A == 0) + B = A - 1; if (A > B) -> B = A - 1; if (A != 0) + B = A + 1; if (B < A) -> B = A + 1; if (B == 0) + B = A + 1; if (B > A) -> B = A + 1; if (B != 0) */ + if (integer_zerop (x)) + { + op1 = x; + code = (code == LT_EXPR || code == LE_EXPR) ? EQ_EXPR : NE_EXPR; + } + /* B = A + 1; if (A > B) -> B = A + 1; if (B == 0) + B = A + 1; if (A < B) -> B = A + 1; if (B != 0) + B = A - 1; if (B > A) -> B = A - 1; if (A == 0) + B = A - 1; if (B < A) -> B = A - 1; if (A != 0) */ + else if (wi::to_wide (x) == max - 1) + { + op0 = op1; + op1 = wide_int_to_tree (TREE_TYPE (op0), 0); + code = (code == GT_EXPR || code == GE_EXPR) ? EQ_EXPR : NE_EXPR; + } + } + + if ((ret = vrp_evaluate_conditional_warnv_with_ops_using_ranges + (code, op0, op1, strict_overflow_p))) + return ret; + if (only_ranges) + *only_ranges = false; + /* Do not use compare_names during propagation, it's quadratic. */ + if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME + && use_equiv_p) + return compare_names (code, op0, op1, strict_overflow_p); + else if (TREE_CODE (op0) == SSA_NAME) + return compare_name_with_value (code, op0, op1, + strict_overflow_p, use_equiv_p); + else if (TREE_CODE (op1) == SSA_NAME) + return compare_name_with_value (swap_tree_comparison (code), op1, op0, + strict_overflow_p, use_equiv_p); + return NULL_TREE; +} + +/* Given (CODE OP0 OP1) within STMT, try to simplify it based on value range + information. Return NULL if the conditional can not be evaluated. + 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 + based on undefined signed overflow, issue a warning if + appropriate. */ + +tree +vr_values::vrp_evaluate_conditional (tree_code code, tree op0, + tree op1, gimple *stmt) +{ + bool sop; + tree ret; + bool only_ranges; + + /* Some passes and foldings leak constants with overflow flag set + into the IL. Avoid doing wrong things with these and bail out. */ + if ((TREE_CODE (op0) == INTEGER_CST + && TREE_OVERFLOW (op0)) + || (TREE_CODE (op1) == INTEGER_CST + && TREE_OVERFLOW (op1))) + return NULL_TREE; + + sop = false; + ret = vrp_evaluate_conditional_warnv_with_ops (code, op0, op1, true, &sop, + &only_ranges); + + if (ret && sop) + { + enum warn_strict_overflow_code wc; + const char* warnmsg; + + if (is_gimple_min_invariant (ret)) + { + wc = WARN_STRICT_OVERFLOW_CONDITIONAL; + warnmsg = G_("assuming signed overflow does not occur when " + "simplifying conditional to constant"); + } + else + { + wc = WARN_STRICT_OVERFLOW_COMPARISON; + warnmsg = G_("assuming signed overflow does not occur when " + "simplifying conditional"); + } + + if (issue_strict_overflow_warning (wc)) + { + location_t location; + + if (!gimple_has_location (stmt)) + location = input_location; + else + location = gimple_location (stmt); + warning_at (location, OPT_Wstrict_overflow, "%s", warnmsg); + } + } + + if (warn_type_limits + && ret && only_ranges + && TREE_CODE_CLASS (code) == tcc_comparison + && TREE_CODE (op0) == SSA_NAME) + { + /* If the comparison is being folded and the operand on the LHS + is being compared against a constant value that is outside of + the natural range of OP0's type, then the predicate will + always fold regardless of the value of OP0. If -Wtype-limits + was specified, emit a warning. */ + tree type = TREE_TYPE (op0); + value_range *vr0 = get_value_range (op0); + + if (vr0->type == VR_RANGE + && INTEGRAL_TYPE_P (type) + && vrp_val_is_min (vr0->min) + && vrp_val_is_max (vr0->max) + && is_gimple_min_invariant (op1)) + { + location_t location; + + if (!gimple_has_location (stmt)) + location = input_location; + else + location = gimple_location (stmt); + + warning_at (location, OPT_Wtype_limits, + integer_zerop (ret) + ? G_("comparison always false " + "due to limited range of data type") + : G_("comparison always true " + "due to limited range of data type")); + } + } + + return ret; +} + + +/* Visit conditional statement STMT. If we can determine which edge + will be taken out of STMT's basic block, record it in + *TAKEN_EDGE_P. Otherwise, set *TAKEN_EDGE_P to NULL. */ + +void +vr_values::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p) +{ + tree val; + + *taken_edge_p = NULL; + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + tree use; + ssa_op_iter i; + + fprintf (dump_file, "\nVisiting conditional with predicate: "); + print_gimple_stmt (dump_file, stmt, 0); + fprintf (dump_file, "\nWith known ranges\n"); + + FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE) + { + fprintf (dump_file, "\t"); + print_generic_expr (dump_file, use); + fprintf (dump_file, ": "); + dump_value_range (dump_file, vr_value[SSA_NAME_VERSION (use)]); + } + + fprintf (dump_file, "\n"); + } + + /* Compute the value of the predicate COND by checking the known + ranges of each of its operands. + + Note that we cannot evaluate all the equivalent ranges here + because those ranges may not yet be final and with the current + propagation strategy, we cannot determine when the value ranges + of the names in the equivalence set have changed. + + For instance, given the following code fragment + + i_5 = PHI <8, i_13> + ... + i_14 = ASSERT_EXPR + if (i_14 == 1) + ... + + 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 + 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 + the first time, since i_14 is equivalent to the range [8, 8], we + determine that the predicate is always false. + + On the next round of propagation, i_13 is determined to be + 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 + 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 + registered, so vrp_visit_assignment thinks that the range for + i_14 has not changed. Therefore, the predicate 'if (i_14 == 1)' + is not visited again, which stops propagation from visiting + statements in the THEN clause of that if(). + + 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 + discovered that from one visit to the other i_5 changed from + range [8, 8] to VR_VARYING. + + However, fixing this apparent limitation may not be worth the + additional checking. Testing on several code bases (GCC, DLV, + MICO, TRAMP3D and SPEC2000) showed that doing this results in + 4 more predicates folded in SPEC. */ + + bool sop; + val = vrp_evaluate_conditional_warnv_with_ops (gimple_cond_code (stmt), + gimple_cond_lhs (stmt), + gimple_cond_rhs (stmt), + false, &sop, NULL); + if (val) + *taken_edge_p = find_taken_edge (gimple_bb (stmt), val); + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "\nPredicate evaluates to: "); + if (val == NULL_TREE) + fprintf (dump_file, "DON'T KNOW\n"); + else + print_generic_stmt (dump_file, val); + } +} + +/* Searches the case label vector VEC for the ranges of CASE_LABELs that are + used in range VR. The indices are placed in MIN_IDX1, MAX_IDX, MIN_IDX2 and + MAX_IDX2. If the ranges of CASE_LABELs are empty then MAX_IDX1 < MIN_IDX1. + Returns true if the default label is not needed. */ + +static bool +find_case_label_ranges (gswitch *stmt, value_range *vr, size_t *min_idx1, + size_t *max_idx1, size_t *min_idx2, + size_t *max_idx2) +{ + size_t i, j, k, l; + unsigned int n = gimple_switch_num_labels (stmt); + bool take_default; + tree case_low, case_high; + tree min = vr->min, max = vr->max; + + gcc_checking_assert (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE); + + take_default = !find_case_label_range (stmt, min, max, &i, &j); + + /* Set second range to emtpy. */ + *min_idx2 = 1; + *max_idx2 = 0; + + if (vr->type == VR_RANGE) + { + *min_idx1 = i; + *max_idx1 = j; + return !take_default; + } + + /* Set first range to all case labels. */ + *min_idx1 = 1; + *max_idx1 = n - 1; + + if (i > j) + return false; + + /* Make sure all the values of case labels [i , j] are contained in + range [MIN, MAX]. */ + case_low = CASE_LOW (gimple_switch_label (stmt, i)); + case_high = CASE_HIGH (gimple_switch_label (stmt, j)); + if (tree_int_cst_compare (case_low, min) < 0) + i += 1; + if (case_high != NULL_TREE + && tree_int_cst_compare (max, case_high) < 0) + j -= 1; + + if (i > j) + return false; + + /* If the range spans case labels [i, j], the corresponding anti-range spans + the labels [1, i - 1] and [j + 1, n - 1]. */ + k = j + 1; + l = n - 1; + if (k > l) + { + k = 1; + l = 0; + } + + j = i - 1; + i = 1; + if (i > j) + { + i = k; + j = l; + k = 1; + l = 0; + } + + *min_idx1 = i; + *max_idx1 = j; + *min_idx2 = k; + *max_idx2 = l; + return false; +} + +/* Visit switch statement STMT. If we can determine which edge + will be taken out of STMT's basic block, record it in + *TAKEN_EDGE_P. Otherwise, *TAKEN_EDGE_P set to NULL. */ + +void +vr_values::vrp_visit_switch_stmt (gswitch *stmt, edge *taken_edge_p) +{ + tree op, val; + value_range *vr; + size_t i = 0, j = 0, k, l; + bool take_default; + + *taken_edge_p = NULL; + op = gimple_switch_index (stmt); + if (TREE_CODE (op) != SSA_NAME) + return; + + vr = get_value_range (op); + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "\nVisiting switch expression with operand "); + print_generic_expr (dump_file, op); + fprintf (dump_file, " with known range "); + dump_value_range (dump_file, vr); + fprintf (dump_file, "\n"); + } + + if ((vr->type != VR_RANGE + && vr->type != VR_ANTI_RANGE) + || symbolic_range_p (vr)) + return; + + /* Find the single edge that is taken from the switch expression. */ + take_default = !find_case_label_ranges (stmt, vr, &i, &j, &k, &l); + + /* Check if the range spans no CASE_LABEL. If so, we only reach the default + label */ + if (j < i) + { + gcc_assert (take_default); + val = gimple_switch_default_label (stmt); + } + else + { + /* Check if labels with index i to j and maybe the default label + are all reaching the same label. */ + + val = gimple_switch_label (stmt, i); + if (take_default + && CASE_LABEL (gimple_switch_default_label (stmt)) + != CASE_LABEL (val)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, " not a single destination for this " + "range\n"); + return; + } + for (++i; i <= j; ++i) + { + if (CASE_LABEL (gimple_switch_label (stmt, i)) != CASE_LABEL (val)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, " not a single destination for this " + "range\n"); + return; + } + } + for (; k <= l; ++k) + { + if (CASE_LABEL (gimple_switch_label (stmt, k)) != CASE_LABEL (val)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, " not a single destination for this " + "range\n"); + return; + } + } + } + + *taken_edge_p = find_edge (gimple_bb (stmt), + label_to_block (CASE_LABEL (val))); + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, " will take edge to "); + print_generic_stmt (dump_file, CASE_LABEL (val)); + } +} + + +/* Evaluate statement STMT. If the statement produces a useful range, + set VR and corepsponding OUTPUT_P. + + If STMT is a conditional branch and we can determine its truth + value, the taken edge is recorded in *TAKEN_EDGE_P. */ + +void +vr_values::extract_range_from_stmt (gimple *stmt, edge *taken_edge_p, + tree *output_p, value_range *vr) +{ + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "\nVisiting statement:\n"); + print_gimple_stmt (dump_file, stmt, 0, dump_flags); + } + + if (!stmt_interesting_for_vrp (stmt)) + gcc_assert (stmt_ends_bb_p (stmt)); + else if (is_gimple_assign (stmt) || is_gimple_call (stmt)) + vrp_visit_assignment_or_call (stmt, output_p, vr); + else if (gimple_code (stmt) == GIMPLE_COND) + vrp_visit_cond_stmt (as_a (stmt), taken_edge_p); + else if (gimple_code (stmt) == GIMPLE_SWITCH) + vrp_visit_switch_stmt (as_a (stmt), taken_edge_p); +} + +/* Visit all arguments for PHI node PHI that flow through executable + edges. If a valid value range can be derived from all the incoming + value ranges, set a new range in VR_RESULT. */ + +void +vr_values::extract_range_from_phi_node (gphi *phi, value_range *vr_result) +{ + size_t i; + tree lhs = PHI_RESULT (phi); + value_range *lhs_vr = get_value_range (lhs); + bool first = true; + int edges, old_edges; + struct loop *l; + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "\nVisiting PHI node: "); + print_gimple_stmt (dump_file, phi, 0, dump_flags); + } + + bool may_simulate_backedge_again = false; + edges = 0; + for (i = 0; i < gimple_phi_num_args (phi); i++) + { + edge e = gimple_phi_arg_edge (phi, i); + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, + " Argument #%d (%d -> %d %sexecutable)\n", + (int) i, e->src->index, e->dest->index, + (e->flags & EDGE_EXECUTABLE) ? "" : "not "); + } + + if (e->flags & EDGE_EXECUTABLE) + { + tree arg = PHI_ARG_DEF (phi, i); + value_range vr_arg; + + ++edges; + + if (TREE_CODE (arg) == SSA_NAME) + { + /* See if we are eventually going to change one of the args. */ + gimple *def_stmt = SSA_NAME_DEF_STMT (arg); + if (! gimple_nop_p (def_stmt) + && prop_simulate_again_p (def_stmt) + && e->flags & EDGE_DFS_BACK) + may_simulate_backedge_again = true; + + vr_arg = *(get_value_range (arg)); + /* Do not allow equivalences or symbolic ranges to leak in from + backedges. That creates invalid equivalencies. + See PR53465 and PR54767. */ + if (e->flags & EDGE_DFS_BACK) + { + if (vr_arg.type == VR_RANGE + || vr_arg.type == VR_ANTI_RANGE) + { + vr_arg.equiv = NULL; + if (symbolic_range_p (&vr_arg)) + { + vr_arg.type = VR_VARYING; + vr_arg.min = NULL_TREE; + vr_arg.max = NULL_TREE; + } + } + } + else + { + /* If the non-backedge arguments range is VR_VARYING then + we can still try recording a simple equivalence. */ + if (vr_arg.type == VR_VARYING) + { + vr_arg.type = VR_RANGE; + vr_arg.min = arg; + vr_arg.max = arg; + vr_arg.equiv = NULL; + } + } + } + else + { + if (TREE_OVERFLOW_P (arg)) + arg = drop_tree_overflow (arg); + + vr_arg.type = VR_RANGE; + vr_arg.min = arg; + vr_arg.max = arg; + vr_arg.equiv = NULL; + } + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "\t"); + print_generic_expr (dump_file, arg, dump_flags); + fprintf (dump_file, ": "); + dump_value_range (dump_file, &vr_arg); + fprintf (dump_file, "\n"); + } + + if (first) + copy_value_range (vr_result, &vr_arg); + else + vrp_meet (vr_result, &vr_arg); + first = false; + + if (vr_result->type == VR_VARYING) + break; + } + } + + if (vr_result->type == VR_VARYING) + goto varying; + else if (vr_result->type == VR_UNDEFINED) + goto update_range; + + old_edges = vr_phi_edge_counts[SSA_NAME_VERSION (lhs)]; + vr_phi_edge_counts[SSA_NAME_VERSION (lhs)] = edges; + + /* To prevent infinite iterations in the algorithm, derive ranges + when the new value is slightly bigger or smaller than the + previous one. We don't do this if we have seen a new executable + edge; this helps us avoid an infinity for conditionals + which are not in a loop. If the old value-range was VR_UNDEFINED + use the updated range and iterate one more time. If we will not + simulate this PHI again via the backedge allow us to iterate. */ + if (edges > 0 + && gimple_phi_num_args (phi) > 1 + && edges == old_edges + && lhs_vr->type != VR_UNDEFINED + && may_simulate_backedge_again) + { + /* Compare old and new ranges, fall back to varying if the + values are not comparable. */ + int cmp_min = compare_values (lhs_vr->min, vr_result->min); + if (cmp_min == -2) + goto varying; + int cmp_max = compare_values (lhs_vr->max, vr_result->max); + if (cmp_max == -2) + goto varying; + + /* For non VR_RANGE or for pointers fall back to varying if + the range changed. */ + if ((lhs_vr->type != VR_RANGE || vr_result->type != VR_RANGE + || POINTER_TYPE_P (TREE_TYPE (lhs))) + && (cmp_min != 0 || cmp_max != 0)) + goto varying; + + /* If the new minimum is larger than the previous one + retain the old value. If the new minimum value is smaller + than the previous one and not -INF go all the way to -INF + 1. + In the first case, to avoid infinite bouncing between different + minimums, and in the other case to avoid iterating millions of + times to reach -INF. Going to -INF + 1 also lets the following + iteration compute whether there will be any overflow, at the + expense of one additional iteration. */ + if (cmp_min < 0) + vr_result->min = lhs_vr->min; + else if (cmp_min > 0 + && !vrp_val_is_min (vr_result->min)) + vr_result->min + = int_const_binop (PLUS_EXPR, + vrp_val_min (TREE_TYPE (vr_result->min)), + build_int_cst (TREE_TYPE (vr_result->min), 1)); + + /* Similarly for the maximum value. */ + if (cmp_max > 0) + vr_result->max = lhs_vr->max; + else if (cmp_max < 0 + && !vrp_val_is_max (vr_result->max)) + vr_result->max + = int_const_binop (MINUS_EXPR, + vrp_val_max (TREE_TYPE (vr_result->min)), + build_int_cst (TREE_TYPE (vr_result->min), 1)); + + /* If we dropped either bound to +-INF then if this is a loop + PHI node SCEV may known more about its value-range. */ + if (cmp_min > 0 || cmp_min < 0 + || cmp_max < 0 || cmp_max > 0) + goto scev_check; + + goto infinite_check; + } + + goto update_range; + +varying: + set_value_range_to_varying (vr_result); + +scev_check: + /* If this is a loop PHI node SCEV may known more about its value-range. + scev_check can be reached from two paths, one is a fall through from above + "varying" label, the other is direct goto from code block which tries to + avoid infinite simulation. */ + if ((l = loop_containing_stmt (phi)) + && l->header == gimple_bb (phi)) + adjust_range_with_scev (vr_result, l, phi, lhs); + +infinite_check: + /* If we will end up with a (-INF, +INF) range, set it to + VARYING. Same if the previous max value was invalid for + the type and we end up with vr_result.min > vr_result.max. */ + if ((vr_result->type == VR_RANGE || vr_result->type == VR_ANTI_RANGE) + && !((vrp_val_is_max (vr_result->max) && vrp_val_is_min (vr_result->min)) + || compare_values (vr_result->min, vr_result->max) > 0)) + ; + else + set_value_range_to_varying (vr_result); + + /* If the new range is different than the previous value, keep + iterating. */ +update_range: + return; +} + +/* Simplify boolean operations if the source is known + to be already a boolean. */ +bool +vr_values::simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, + gimple *stmt) +{ + enum tree_code rhs_code = gimple_assign_rhs_code (stmt); + tree lhs, op0, op1; + bool need_conversion; + + /* We handle only !=/== case here. */ + gcc_assert (rhs_code == EQ_EXPR || rhs_code == NE_EXPR); + + op0 = gimple_assign_rhs1 (stmt); + if (!op_with_boolean_value_range_p (op0)) + return false; + + op1 = gimple_assign_rhs2 (stmt); + if (!op_with_boolean_value_range_p (op1)) + return false; + + /* Reduce number of cases to handle to NE_EXPR. As there is no + BIT_XNOR_EXPR we cannot replace A == B with a single statement. */ + if (rhs_code == EQ_EXPR) + { + if (TREE_CODE (op1) == INTEGER_CST) + op1 = int_const_binop (BIT_XOR_EXPR, op1, + build_int_cst (TREE_TYPE (op1), 1)); + else + return false; + } + + lhs = gimple_assign_lhs (stmt); + need_conversion + = !useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (op0)); + + /* Make sure to not sign-extend a 1-bit 1 when converting the result. */ + if (need_conversion + && !TYPE_UNSIGNED (TREE_TYPE (op0)) + && TYPE_PRECISION (TREE_TYPE (op0)) == 1 + && TYPE_PRECISION (TREE_TYPE (lhs)) > 1) + return false; + + /* For A != 0 we can substitute A itself. */ + if (integer_zerop (op1)) + gimple_assign_set_rhs_with_ops (gsi, + need_conversion + ? NOP_EXPR : TREE_CODE (op0), op0); + /* For A != B we substitute A ^ B. Either with conversion. */ + else if (need_conversion) + { + tree tem = make_ssa_name (TREE_TYPE (op0)); + gassign *newop + = gimple_build_assign (tem, BIT_XOR_EXPR, op0, op1); + gsi_insert_before (gsi, newop, GSI_SAME_STMT); + if (INTEGRAL_TYPE_P (TREE_TYPE (tem)) + && TYPE_PRECISION (TREE_TYPE (tem)) > 1) + set_range_info (tem, VR_RANGE, + wi::zero (TYPE_PRECISION (TREE_TYPE (tem))), + wi::one (TYPE_PRECISION (TREE_TYPE (tem)))); + gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, tem); + } + /* Or without. */ + else + gimple_assign_set_rhs_with_ops (gsi, BIT_XOR_EXPR, op0, op1); + update_stmt (gsi_stmt (*gsi)); + fold_stmt (gsi, follow_single_use_edges); + + return true; +} + +/* Simplify a division or modulo operator to a right shift or bitwise and + if the first operand is unsigned or is greater than zero and the second + operand is an exact power of two. For TRUNC_MOD_EXPR op0 % op1 with + constant op1 (op1min = op1) or with op1 in [op1min, op1max] range, + optimize it into just op0 if op0's range is known to be a subset of + [-op1min + 1, op1min - 1] for signed and [0, op1min - 1] for unsigned + modulo. */ + +bool +vr_values::simplify_div_or_mod_using_ranges (gimple_stmt_iterator *gsi, + gimple *stmt) +{ + enum tree_code rhs_code = gimple_assign_rhs_code (stmt); + tree val = NULL; + tree op0 = gimple_assign_rhs1 (stmt); + tree op1 = gimple_assign_rhs2 (stmt); + tree op0min = NULL_TREE, op0max = NULL_TREE; + tree op1min = op1; + value_range *vr = NULL; + + if (TREE_CODE (op0) == INTEGER_CST) + { + op0min = op0; + op0max = op0; + } + else + { + vr = get_value_range (op0); + if (range_int_cst_p (vr)) + { + op0min = vr->min; + op0max = vr->max; + } + } + + if (rhs_code == TRUNC_MOD_EXPR + && TREE_CODE (op1) == SSA_NAME) + { + value_range *vr1 = get_value_range (op1); + if (range_int_cst_p (vr1)) + op1min = vr1->min; + } + if (rhs_code == TRUNC_MOD_EXPR + && TREE_CODE (op1min) == INTEGER_CST + && tree_int_cst_sgn (op1min) == 1 + && op0max + && tree_int_cst_lt (op0max, op1min)) + { + if (TYPE_UNSIGNED (TREE_TYPE (op0)) + || tree_int_cst_sgn (op0min) >= 0 + || tree_int_cst_lt (fold_unary (NEGATE_EXPR, TREE_TYPE (op1min), op1min), + op0min)) + { + /* If op0 already has the range op0 % op1 has, + then TRUNC_MOD_EXPR won't change anything. */ + gimple_assign_set_rhs_from_tree (gsi, op0); + return true; + } + } + + if (TREE_CODE (op0) != SSA_NAME) + return false; + + if (!integer_pow2p (op1)) + { + /* X % -Y can be only optimized into X % Y either if + X is not INT_MIN, or Y is not -1. Fold it now, as after + remove_range_assertions the range info might be not available + anymore. */ + if (rhs_code == TRUNC_MOD_EXPR + && fold_stmt (gsi, follow_single_use_edges)) + return true; + return false; + } + + if (TYPE_UNSIGNED (TREE_TYPE (op0))) + val = integer_one_node; + else + { + bool sop = false; + + val = compare_range_with_value (GE_EXPR, vr, integer_zero_node, &sop); + + if (val + && sop + && integer_onep (val) + && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)) + { + location_t location; + + if (!gimple_has_location (stmt)) + location = input_location; + else + location = gimple_location (stmt); + warning_at (location, OPT_Wstrict_overflow, + "assuming signed overflow does not occur when " + "simplifying % or %<%%%> to %<>>%> or %<&%>"); + } + } + + if (val && integer_onep (val)) + { + tree t; + + if (rhs_code == TRUNC_DIV_EXPR) + { + t = build_int_cst (integer_type_node, tree_log2 (op1)); + gimple_assign_set_rhs_code (stmt, RSHIFT_EXPR); + gimple_assign_set_rhs1 (stmt, op0); + gimple_assign_set_rhs2 (stmt, t); + } + else + { + t = build_int_cst (TREE_TYPE (op1), 1); + t = int_const_binop (MINUS_EXPR, op1, t); + t = fold_convert (TREE_TYPE (op0), t); + + gimple_assign_set_rhs_code (stmt, BIT_AND_EXPR); + gimple_assign_set_rhs1 (stmt, op0); + gimple_assign_set_rhs2 (stmt, t); + } + + update_stmt (stmt); + fold_stmt (gsi, follow_single_use_edges); + return true; + } + + return false; +} + +/* Simplify a min or max if the ranges of the two operands are + disjoint. Return true if we do simplify. */ + +bool +vr_values::simplify_min_or_max_using_ranges (gimple_stmt_iterator *gsi, + gimple *stmt) +{ + tree op0 = gimple_assign_rhs1 (stmt); + tree op1 = gimple_assign_rhs2 (stmt); + bool sop = false; + tree val; + + val = (vrp_evaluate_conditional_warnv_with_ops_using_ranges + (LE_EXPR, op0, op1, &sop)); + if (!val) + { + sop = false; + val = (vrp_evaluate_conditional_warnv_with_ops_using_ranges + (LT_EXPR, op0, op1, &sop)); + } + + if (val) + { + if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)) + { + location_t location; + + if (!gimple_has_location (stmt)) + location = input_location; + else + location = gimple_location (stmt); + warning_at (location, OPT_Wstrict_overflow, + "assuming signed overflow does not occur when " + "simplifying % to % or %"); + } + + /* VAL == TRUE -> OP0 < or <= op1 + VAL == FALSE -> OP0 > or >= op1. */ + tree res = ((gimple_assign_rhs_code (stmt) == MAX_EXPR) + == integer_zerop (val)) ? op0 : op1; + gimple_assign_set_rhs_from_tree (gsi, res); + return true; + } + + return false; +} + +/* If the operand to an ABS_EXPR is >= 0, then eliminate the + ABS_EXPR. If the operand is <= 0, then simplify the + ABS_EXPR into a NEGATE_EXPR. */ + +bool +vr_values::simplify_abs_using_ranges (gimple_stmt_iterator *gsi, gimple *stmt) +{ + tree op = gimple_assign_rhs1 (stmt); + value_range *vr = get_value_range (op); + + if (vr) + { + tree val = NULL; + bool sop = false; + + val = compare_range_with_value (LE_EXPR, vr, integer_zero_node, &sop); + if (!val) + { + /* The range is neither <= 0 nor > 0. Now see if it is + either < 0 or >= 0. */ + sop = false; + val = compare_range_with_value (LT_EXPR, vr, integer_zero_node, + &sop); + } + + if (val) + { + if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)) + { + location_t location; + + if (!gimple_has_location (stmt)) + location = input_location; + else + location = gimple_location (stmt); + warning_at (location, OPT_Wstrict_overflow, + "assuming signed overflow does not occur when " + "simplifying % to % or %<-X%>"); + } + + gimple_assign_set_rhs1 (stmt, op); + if (integer_zerop (val)) + gimple_assign_set_rhs_code (stmt, SSA_NAME); + else + gimple_assign_set_rhs_code (stmt, NEGATE_EXPR); + update_stmt (stmt); + fold_stmt (gsi, follow_single_use_edges); + return true; + } + } + + return false; +} + +/* Optimize away redundant BIT_AND_EXPR and BIT_IOR_EXPR. + If all the bits that are being cleared by & are already + known to be zero from VR, or all the bits that are being + set by | are already known to be one from VR, the bit + operation is redundant. */ + +bool +vr_values::simplify_bit_ops_using_ranges (gimple_stmt_iterator *gsi, + gimple *stmt) +{ + tree op0 = gimple_assign_rhs1 (stmt); + tree op1 = gimple_assign_rhs2 (stmt); + tree op = NULL_TREE; + value_range vr0 = VR_INITIALIZER; + value_range vr1 = VR_INITIALIZER; + wide_int may_be_nonzero0, may_be_nonzero1; + wide_int must_be_nonzero0, must_be_nonzero1; + wide_int mask; + + if (TREE_CODE (op0) == SSA_NAME) + vr0 = *(get_value_range (op0)); + else if (is_gimple_min_invariant (op0)) + set_value_range_to_value (&vr0, op0, NULL); + else + return false; + + if (TREE_CODE (op1) == SSA_NAME) + vr1 = *(get_value_range (op1)); + else if (is_gimple_min_invariant (op1)) + set_value_range_to_value (&vr1, op1, NULL); + else + return false; + + if (!zero_nonzero_bits_from_vr (TREE_TYPE (op0), &vr0, &may_be_nonzero0, + &must_be_nonzero0)) + return false; + if (!zero_nonzero_bits_from_vr (TREE_TYPE (op1), &vr1, &may_be_nonzero1, + &must_be_nonzero1)) + return false; + + switch (gimple_assign_rhs_code (stmt)) + { + case BIT_AND_EXPR: + mask = wi::bit_and_not (may_be_nonzero0, must_be_nonzero1); + if (mask == 0) + { + op = op0; + break; + } + mask = wi::bit_and_not (may_be_nonzero1, must_be_nonzero0); + if (mask == 0) + { + op = op1; + break; + } + break; + case BIT_IOR_EXPR: + mask = wi::bit_and_not (may_be_nonzero0, must_be_nonzero1); + if (mask == 0) + { + op = op1; + break; + } + mask = wi::bit_and_not (may_be_nonzero1, must_be_nonzero0); + if (mask == 0) + { + op = op0; + break; + } + break; + default: + gcc_unreachable (); + } + + if (op == NULL_TREE) + return false; + + gimple_assign_set_rhs_with_ops (gsi, TREE_CODE (op), op); + update_stmt (gsi_stmt (*gsi)); + return true; +} + +/* We are comparing trees OP0 and OP1 using COND_CODE. OP0 has + a known value range VR. + + If there is one and only one value which will satisfy the + conditional, then return that value. Else return NULL. + + If signed overflow must be undefined for the value to satisfy + the conditional, then set *STRICT_OVERFLOW_P to true. */ + +static tree +test_for_singularity (enum tree_code cond_code, tree op0, + tree op1, value_range *vr) +{ + tree min = NULL; + tree max = NULL; + + /* Extract minimum/maximum values which satisfy the conditional as it was + written. */ + if (cond_code == LE_EXPR || cond_code == LT_EXPR) + { + min = TYPE_MIN_VALUE (TREE_TYPE (op0)); + + max = op1; + if (cond_code == LT_EXPR) + { + tree one = build_int_cst (TREE_TYPE (op0), 1); + max = fold_build2 (MINUS_EXPR, TREE_TYPE (op0), max, one); + /* Signal to compare_values_warnv this expr doesn't overflow. */ + if (EXPR_P (max)) + TREE_NO_WARNING (max) = 1; + } + } + else if (cond_code == GE_EXPR || cond_code == GT_EXPR) + { + max = TYPE_MAX_VALUE (TREE_TYPE (op0)); + + min = op1; + if (cond_code == GT_EXPR) + { + tree one = build_int_cst (TREE_TYPE (op0), 1); + min = fold_build2 (PLUS_EXPR, TREE_TYPE (op0), min, one); + /* Signal to compare_values_warnv this expr doesn't overflow. */ + if (EXPR_P (min)) + TREE_NO_WARNING (min) = 1; + } + } + + /* Now refine the minimum and maximum values using any + value range information we have for op0. */ + if (min && max) + { + if (compare_values (vr->min, min) == 1) + min = vr->min; + if (compare_values (vr->max, max) == -1) + max = vr->max; + + /* If the new min/max values have converged to a single value, + then there is only one value which can satisfy the condition, + return that value. */ + if (operand_equal_p (min, max, 0) && is_gimple_min_invariant (min)) + return min; + } + return NULL; +} + +/* Return whether the value range *VR fits in an integer type specified + by PRECISION and UNSIGNED_P. */ + +static bool +range_fits_type_p (value_range *vr, unsigned dest_precision, signop dest_sgn) +{ + tree src_type; + unsigned src_precision; + widest_int tem; + signop src_sgn; + + /* We can only handle integral and pointer types. */ + src_type = TREE_TYPE (vr->min); + if (!INTEGRAL_TYPE_P (src_type) + && !POINTER_TYPE_P (src_type)) + return false; + + /* An extension is fine unless VR is SIGNED and dest_sgn is UNSIGNED, + and so is an identity transform. */ + src_precision = TYPE_PRECISION (TREE_TYPE (vr->min)); + src_sgn = TYPE_SIGN (src_type); + if ((src_precision < dest_precision + && !(dest_sgn == UNSIGNED && src_sgn == SIGNED)) + || (src_precision == dest_precision && src_sgn == dest_sgn)) + return true; + + /* Now we can only handle ranges with constant bounds. */ + if (vr->type != VR_RANGE + || TREE_CODE (vr->min) != INTEGER_CST + || TREE_CODE (vr->max) != INTEGER_CST) + return false; + + /* For sign changes, the MSB of the wide_int has to be clear. + An unsigned value with its MSB set cannot be represented by + a signed wide_int, while a negative value cannot be represented + by an unsigned wide_int. */ + if (src_sgn != dest_sgn + && (wi::lts_p (wi::to_wide (vr->min), 0) + || wi::lts_p (wi::to_wide (vr->max), 0))) + return false; + + /* Then we can perform the conversion on both ends and compare + the result for equality. */ + tem = wi::ext (wi::to_widest (vr->min), dest_precision, dest_sgn); + if (tem != wi::to_widest (vr->min)) + return false; + tem = wi::ext (wi::to_widest (vr->max), dest_precision, dest_sgn); + if (tem != wi::to_widest (vr->max)) + return false; + + return true; +} + +/* Simplify a conditional using a relational operator to an equality + test if the range information indicates only one value can satisfy + the original conditional. */ + +bool +vr_values::simplify_cond_using_ranges_1 (gcond *stmt) +{ + tree op0 = gimple_cond_lhs (stmt); + tree op1 = gimple_cond_rhs (stmt); + enum tree_code cond_code = gimple_cond_code (stmt); + + if (cond_code != NE_EXPR + && cond_code != EQ_EXPR + && TREE_CODE (op0) == SSA_NAME + && INTEGRAL_TYPE_P (TREE_TYPE (op0)) + && is_gimple_min_invariant (op1)) + { + value_range *vr = get_value_range (op0); + + /* If we have range information for OP0, then we might be + able to simplify this conditional. */ + if (vr->type == VR_RANGE) + { + tree new_tree = test_for_singularity (cond_code, op0, op1, vr); + if (new_tree) + { + if (dump_file) + { + fprintf (dump_file, "Simplified relational "); + print_gimple_stmt (dump_file, stmt, 0); + fprintf (dump_file, " into "); + } + + gimple_cond_set_code (stmt, EQ_EXPR); + gimple_cond_set_lhs (stmt, op0); + gimple_cond_set_rhs (stmt, new_tree); + + update_stmt (stmt); + + if (dump_file) + { + print_gimple_stmt (dump_file, stmt, 0); + fprintf (dump_file, "\n"); + } + + return true; + } + + /* Try again after inverting the condition. We only deal + with integral types here, so no need to worry about + issues with inverting FP comparisons. */ + new_tree = test_for_singularity + (invert_tree_comparison (cond_code, false), + op0, op1, vr); + if (new_tree) + { + if (dump_file) + { + fprintf (dump_file, "Simplified relational "); + print_gimple_stmt (dump_file, stmt, 0); + fprintf (dump_file, " into "); + } + + gimple_cond_set_code (stmt, NE_EXPR); + gimple_cond_set_lhs (stmt, op0); + gimple_cond_set_rhs (stmt, new_tree); + + update_stmt (stmt); + + if (dump_file) + { + print_gimple_stmt (dump_file, stmt, 0); + fprintf (dump_file, "\n"); + } + + return true; + } + } + } + return false; +} + +/* STMT is a conditional at the end of a basic block. + + If the conditional is of the form SSA_NAME op constant and the SSA_NAME + was set via a type conversion, try to replace the SSA_NAME with the RHS + of the type conversion. Doing so makes the conversion dead which helps + subsequent passes. */ + +void +vr_values::simplify_cond_using_ranges_2 (gcond *stmt) +{ + tree op0 = gimple_cond_lhs (stmt); + tree op1 = gimple_cond_rhs (stmt); + + /* If we have a comparison of an SSA_NAME (OP0) against a constant, + see if OP0 was set by a type conversion where the source of + the conversion is another SSA_NAME with a range that fits + into the range of OP0's type. + + If so, the conversion is redundant as the earlier SSA_NAME can be + used for the comparison directly if we just massage the constant in the + comparison. */ + if (TREE_CODE (op0) == SSA_NAME + && TREE_CODE (op1) == INTEGER_CST) + { + gimple *def_stmt = SSA_NAME_DEF_STMT (op0); + tree innerop; + + if (!is_gimple_assign (def_stmt) + || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))) + return; + + innerop = gimple_assign_rhs1 (def_stmt); + + if (TREE_CODE (innerop) == SSA_NAME + && !POINTER_TYPE_P (TREE_TYPE (innerop)) + && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (innerop) + && desired_pro_or_demotion_p (TREE_TYPE (innerop), TREE_TYPE (op0))) + { + value_range *vr = get_value_range (innerop); + + if (range_int_cst_p (vr) + && range_fits_type_p (vr, + TYPE_PRECISION (TREE_TYPE (op0)), + TYPE_SIGN (TREE_TYPE (op0))) + && int_fits_type_p (op1, TREE_TYPE (innerop))) + { + tree newconst = fold_convert (TREE_TYPE (innerop), op1); + gimple_cond_set_lhs (stmt, innerop); + gimple_cond_set_rhs (stmt, newconst); + update_stmt (stmt); + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "Folded into: "); + print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); + fprintf (dump_file, "\n"); + } + } + } + } +} + +/* Simplify a switch statement using the value range of the switch + argument. */ + +bool +vr_values::simplify_switch_using_ranges (gswitch *stmt) +{ + tree op = gimple_switch_index (stmt); + value_range *vr = NULL; + bool take_default; + edge e; + edge_iterator ei; + size_t i = 0, j = 0, n, n2; + tree vec2; + switch_update su; + size_t k = 1, l = 0; + + if (TREE_CODE (op) == SSA_NAME) + { + vr = get_value_range (op); + + /* We can only handle integer ranges. */ + if ((vr->type != VR_RANGE + && vr->type != VR_ANTI_RANGE) + || symbolic_range_p (vr)) + return false; + + /* Find case label for min/max of the value range. */ + take_default = !find_case_label_ranges (stmt, vr, &i, &j, &k, &l); + } + else if (TREE_CODE (op) == INTEGER_CST) + { + take_default = !find_case_label_index (stmt, 1, op, &i); + if (take_default) + { + i = 1; + j = 0; + } + else + { + j = i; + } + } + else + return false; + + n = gimple_switch_num_labels (stmt); + + /* We can truncate the case label ranges that partially overlap with OP's + value range. */ + size_t min_idx = 1, max_idx = 0; + if (vr != NULL) + find_case_label_range (stmt, vr->min, vr->max, &min_idx, &max_idx); + if (min_idx <= max_idx) + { + tree min_label = gimple_switch_label (stmt, min_idx); + tree max_label = gimple_switch_label (stmt, max_idx); + + /* Avoid changing the type of the case labels when truncating. */ + tree case_label_type = TREE_TYPE (CASE_LOW (min_label)); + tree vr_min = fold_convert (case_label_type, vr->min); + tree vr_max = fold_convert (case_label_type, vr->max); + + if (vr->type == VR_RANGE) + { + /* If OP's value range is [2,8] and the low label range is + 0 ... 3, truncate the label's range to 2 .. 3. */ + if (tree_int_cst_compare (CASE_LOW (min_label), vr_min) < 0 + && CASE_HIGH (min_label) != NULL_TREE + && tree_int_cst_compare (CASE_HIGH (min_label), vr_min) >= 0) + CASE_LOW (min_label) = vr_min; + + /* If OP's value range is [2,8] and the high label range is + 7 ... 10, truncate the label's range to 7 .. 8. */ + if (tree_int_cst_compare (CASE_LOW (max_label), vr_max) <= 0 + && CASE_HIGH (max_label) != NULL_TREE + && tree_int_cst_compare (CASE_HIGH (max_label), vr_max) > 0) + CASE_HIGH (max_label) = vr_max; + } + else if (vr->type == VR_ANTI_RANGE) + { + tree one_cst = build_one_cst (case_label_type); + + if (min_label == max_label) + { + /* If OP's value range is ~[7,8] and the label's range is + 7 ... 10, truncate the label's range to 9 ... 10. */ + if (tree_int_cst_compare (CASE_LOW (min_label), vr_min) == 0 + && CASE_HIGH (min_label) != NULL_TREE + && tree_int_cst_compare (CASE_HIGH (min_label), vr_max) > 0) + CASE_LOW (min_label) + = int_const_binop (PLUS_EXPR, vr_max, one_cst); + + /* If OP's value range is ~[7,8] and the label's range is + 5 ... 8, truncate the label's range to 5 ... 6. */ + if (tree_int_cst_compare (CASE_LOW (min_label), vr_min) < 0 + && CASE_HIGH (min_label) != NULL_TREE + && tree_int_cst_compare (CASE_HIGH (min_label), vr_max) == 0) + CASE_HIGH (min_label) + = int_const_binop (MINUS_EXPR, vr_min, one_cst); + } + else + { + /* If OP's value range is ~[2,8] and the low label range is + 0 ... 3, truncate the label's range to 0 ... 1. */ + if (tree_int_cst_compare (CASE_LOW (min_label), vr_min) < 0 + && CASE_HIGH (min_label) != NULL_TREE + && tree_int_cst_compare (CASE_HIGH (min_label), vr_min) >= 0) + CASE_HIGH (min_label) + = int_const_binop (MINUS_EXPR, vr_min, one_cst); + + /* If OP's value range is ~[2,8] and the high label range is + 7 ... 10, truncate the label's range to 9 ... 10. */ + if (tree_int_cst_compare (CASE_LOW (max_label), vr_max) <= 0 + && CASE_HIGH (max_label) != NULL_TREE + && tree_int_cst_compare (CASE_HIGH (max_label), vr_max) > 0) + CASE_LOW (max_label) + = int_const_binop (PLUS_EXPR, vr_max, one_cst); + } + } + + /* Canonicalize singleton case ranges. */ + if (tree_int_cst_equal (CASE_LOW (min_label), CASE_HIGH (min_label))) + CASE_HIGH (min_label) = NULL_TREE; + if (tree_int_cst_equal (CASE_LOW (max_label), CASE_HIGH (max_label))) + CASE_HIGH (max_label) = NULL_TREE; + } + + /* We can also eliminate case labels that lie completely outside OP's value + range. */ + + /* Bail out if this is just all edges taken. */ + if (i == 1 + && j == n - 1 + && take_default) + return false; + + /* Build a new vector of taken case labels. */ + vec2 = make_tree_vec (j - i + 1 + l - k + 1 + (int)take_default); + n2 = 0; + + /* Add the default edge, if necessary. */ + if (take_default) + TREE_VEC_ELT (vec2, n2++) = gimple_switch_default_label (stmt); + + for (; i <= j; ++i, ++n2) + TREE_VEC_ELT (vec2, n2) = gimple_switch_label (stmt, i); + + for (; k <= l; ++k, ++n2) + TREE_VEC_ELT (vec2, n2) = gimple_switch_label (stmt, k); + + /* Mark needed edges. */ + for (i = 0; i < n2; ++i) + { + e = find_edge (gimple_bb (stmt), + label_to_block (CASE_LABEL (TREE_VEC_ELT (vec2, i)))); + e->aux = (void *)-1; + } + + /* Queue not needed edges for later removal. */ + FOR_EACH_EDGE (e, ei, gimple_bb (stmt)->succs) + { + if (e->aux == (void *)-1) + { + e->aux = NULL; + continue; + } + + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "removing unreachable case label\n"); + } + to_remove_edges.safe_push (e); + e->flags &= ~EDGE_EXECUTABLE; + } + + /* And queue an update for the stmt. */ + su.stmt = stmt; + su.vec = vec2; + to_update_switch_stmts.safe_push (su); + return false; +} + +/* Simplify an integral conversion from an SSA name in STMT. */ + +static bool +simplify_conversion_using_ranges (gimple_stmt_iterator *gsi, gimple *stmt) +{ + tree innerop, middleop, finaltype; + gimple *def_stmt; + signop inner_sgn, middle_sgn, final_sgn; + unsigned inner_prec, middle_prec, final_prec; + widest_int innermin, innermed, innermax, middlemin, middlemed, middlemax; + + finaltype = TREE_TYPE (gimple_assign_lhs (stmt)); + if (!INTEGRAL_TYPE_P (finaltype)) + return false; + middleop = gimple_assign_rhs1 (stmt); + def_stmt = SSA_NAME_DEF_STMT (middleop); + if (!is_gimple_assign (def_stmt) + || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))) + return false; + innerop = gimple_assign_rhs1 (def_stmt); + if (TREE_CODE (innerop) != SSA_NAME + || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (innerop)) + return false; + + /* Get the value-range of the inner operand. Use get_range_info in + case innerop was created during substitute-and-fold. */ + wide_int imin, imax; + if (!INTEGRAL_TYPE_P (TREE_TYPE (innerop)) + || get_range_info (innerop, &imin, &imax) != VR_RANGE) + return false; + innermin = widest_int::from (imin, TYPE_SIGN (TREE_TYPE (innerop))); + innermax = widest_int::from (imax, TYPE_SIGN (TREE_TYPE (innerop))); + + /* Simulate the conversion chain to check if the result is equal if + the middle conversion is removed. */ + inner_prec = TYPE_PRECISION (TREE_TYPE (innerop)); + middle_prec = TYPE_PRECISION (TREE_TYPE (middleop)); + final_prec = TYPE_PRECISION (finaltype); + + /* If the first conversion is not injective, the second must not + be widening. */ + if (wi::gtu_p (innermax - innermin, + wi::mask (middle_prec, false)) + && middle_prec < final_prec) + return false; + /* We also want a medium value so that we can track the effect that + narrowing conversions with sign change have. */ + inner_sgn = TYPE_SIGN (TREE_TYPE (innerop)); + if (inner_sgn == UNSIGNED) + innermed = wi::shifted_mask (1, inner_prec - 1, false); + else + innermed = 0; + if (wi::cmp (innermin, innermed, inner_sgn) >= 0 + || wi::cmp (innermed, innermax, inner_sgn) >= 0) + innermed = innermin; + + middle_sgn = TYPE_SIGN (TREE_TYPE (middleop)); + middlemin = wi::ext (innermin, middle_prec, middle_sgn); + middlemed = wi::ext (innermed, middle_prec, middle_sgn); + middlemax = wi::ext (innermax, middle_prec, middle_sgn); + + /* Require that the final conversion applied to both the original + and the intermediate range produces the same result. */ + final_sgn = TYPE_SIGN (finaltype); + if (wi::ext (middlemin, final_prec, final_sgn) + != wi::ext (innermin, final_prec, final_sgn) + || wi::ext (middlemed, final_prec, final_sgn) + != wi::ext (innermed, final_prec, final_sgn) + || wi::ext (middlemax, final_prec, final_sgn) + != wi::ext (innermax, final_prec, final_sgn)) + return false; + + gimple_assign_set_rhs1 (stmt, innerop); + fold_stmt (gsi, follow_single_use_edges); + return true; +} + +/* Simplify a conversion from integral SSA name to float in STMT. */ + +bool +vr_values::simplify_float_conversion_using_ranges (gimple_stmt_iterator *gsi, + gimple *stmt) +{ + tree rhs1 = gimple_assign_rhs1 (stmt); + value_range *vr = get_value_range (rhs1); + scalar_float_mode fltmode + = SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (gimple_assign_lhs (stmt))); + scalar_int_mode mode; + tree tem; + gassign *conv; + + /* We can only handle constant ranges. */ + if (vr->type != VR_RANGE + || TREE_CODE (vr->min) != INTEGER_CST + || TREE_CODE (vr->max) != INTEGER_CST) + return false; + + /* First check if we can use a signed type in place of an unsigned. */ + scalar_int_mode rhs_mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (rhs1)); + if (TYPE_UNSIGNED (TREE_TYPE (rhs1)) + && can_float_p (fltmode, rhs_mode, 0) != CODE_FOR_nothing + && range_fits_type_p (vr, TYPE_PRECISION (TREE_TYPE (rhs1)), SIGNED)) + mode = rhs_mode; + /* If we can do the conversion in the current input mode do nothing. */ + else if (can_float_p (fltmode, rhs_mode, + TYPE_UNSIGNED (TREE_TYPE (rhs1))) != CODE_FOR_nothing) + return false; + /* Otherwise search for a mode we can use, starting from the narrowest + integer mode available. */ + else + { + mode = NARROWEST_INT_MODE; + for (;;) + { + /* If we cannot do a signed conversion to float from mode + or if the value-range does not fit in the signed type + try with a wider mode. */ + if (can_float_p (fltmode, mode, 0) != CODE_FOR_nothing + && range_fits_type_p (vr, GET_MODE_PRECISION (mode), SIGNED)) + break; + + /* But do not widen the input. Instead leave that to the + optabs expansion code. */ + if (!GET_MODE_WIDER_MODE (mode).exists (&mode) + || GET_MODE_PRECISION (mode) > TYPE_PRECISION (TREE_TYPE (rhs1))) + return false; + } + } + + /* It works, insert a truncation or sign-change before the + float conversion. */ + tem = make_ssa_name (build_nonstandard_integer_type + (GET_MODE_PRECISION (mode), 0)); + conv = gimple_build_assign (tem, NOP_EXPR, rhs1); + gsi_insert_before (gsi, conv, GSI_SAME_STMT); + gimple_assign_set_rhs1 (stmt, tem); + fold_stmt (gsi, follow_single_use_edges); + + return true; +} + +/* Simplify an internal fn call using ranges if possible. */ + +bool +vr_values::simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, + gimple *stmt) +{ + enum tree_code subcode; + bool is_ubsan = false; + bool ovf = false; + switch (gimple_call_internal_fn (stmt)) + { + case IFN_UBSAN_CHECK_ADD: + subcode = PLUS_EXPR; + is_ubsan = true; + break; + case IFN_UBSAN_CHECK_SUB: + subcode = MINUS_EXPR; + is_ubsan = true; + break; + case IFN_UBSAN_CHECK_MUL: + subcode = MULT_EXPR; + is_ubsan = true; + break; + case IFN_ADD_OVERFLOW: + subcode = PLUS_EXPR; + break; + case IFN_SUB_OVERFLOW: + subcode = MINUS_EXPR; + break; + case IFN_MUL_OVERFLOW: + subcode = MULT_EXPR; + break; + default: + return false; + } + + tree op0 = gimple_call_arg (stmt, 0); + tree op1 = gimple_call_arg (stmt, 1); + tree type; + if (is_ubsan) + { + type = TREE_TYPE (op0); + if (VECTOR_TYPE_P (type)) + return false; + } + else if (gimple_call_lhs (stmt) == NULL_TREE) + return false; + else + type = TREE_TYPE (TREE_TYPE (gimple_call_lhs (stmt))); + if (!check_for_binary_op_overflow (subcode, type, op0, op1, &ovf) + || (is_ubsan && ovf)) + return false; + + gimple *g; + location_t loc = gimple_location (stmt); + if (is_ubsan) + g = gimple_build_assign (gimple_call_lhs (stmt), subcode, op0, op1); + else + { + int prec = TYPE_PRECISION (type); + tree utype = type; + if (ovf + || !useless_type_conversion_p (type, TREE_TYPE (op0)) + || !useless_type_conversion_p (type, TREE_TYPE (op1))) + utype = build_nonstandard_integer_type (prec, 1); + if (TREE_CODE (op0) == INTEGER_CST) + op0 = fold_convert (utype, op0); + else if (!useless_type_conversion_p (utype, TREE_TYPE (op0))) + { + g = gimple_build_assign (make_ssa_name (utype), NOP_EXPR, op0); + gimple_set_location (g, loc); + gsi_insert_before (gsi, g, GSI_SAME_STMT); + op0 = gimple_assign_lhs (g); + } + if (TREE_CODE (op1) == INTEGER_CST) + op1 = fold_convert (utype, op1); + else if (!useless_type_conversion_p (utype, TREE_TYPE (op1))) + { + g = gimple_build_assign (make_ssa_name (utype), NOP_EXPR, op1); + gimple_set_location (g, loc); + gsi_insert_before (gsi, g, GSI_SAME_STMT); + op1 = gimple_assign_lhs (g); + } + g = gimple_build_assign (make_ssa_name (utype), subcode, op0, op1); + gimple_set_location (g, loc); + gsi_insert_before (gsi, g, GSI_SAME_STMT); + if (utype != type) + { + g = gimple_build_assign (make_ssa_name (type), NOP_EXPR, + gimple_assign_lhs (g)); + gimple_set_location (g, loc); + gsi_insert_before (gsi, g, GSI_SAME_STMT); + } + g = gimple_build_assign (gimple_call_lhs (stmt), COMPLEX_EXPR, + gimple_assign_lhs (g), + build_int_cst (type, ovf)); + } + gimple_set_location (g, loc); + gsi_replace (gsi, g, false); + return true; +} + +/* Return true if VAR is a two-valued variable. Set a and b with the + two-values when it is true. Return false otherwise. */ + +bool +vr_values::two_valued_val_range_p (tree var, tree *a, tree *b) +{ + value_range *vr = get_value_range (var); + if ((vr->type != VR_RANGE + && vr->type != VR_ANTI_RANGE) + || TREE_CODE (vr->min) != INTEGER_CST + || TREE_CODE (vr->max) != INTEGER_CST) + return false; + + if (vr->type == VR_RANGE + && wi::to_wide (vr->max) - wi::to_wide (vr->min) == 1) + { + *a = vr->min; + *b = vr->max; + return true; + } + + /* ~[TYPE_MIN + 1, TYPE_MAX - 1] */ + if (vr->type == VR_ANTI_RANGE + && (wi::to_wide (vr->min) + - wi::to_wide (vrp_val_min (TREE_TYPE (var)))) == 1 + && (wi::to_wide (vrp_val_max (TREE_TYPE (var))) + - wi::to_wide (vr->max)) == 1) + { + *a = vrp_val_min (TREE_TYPE (var)); + *b = vrp_val_max (TREE_TYPE (var)); + return true; + } + + return false; +} + +/* Simplify STMT using ranges if possible. */ + +bool +vr_values::simplify_stmt_using_ranges (gimple_stmt_iterator *gsi) +{ + gimple *stmt = gsi_stmt (*gsi); + if (is_gimple_assign (stmt)) + { + enum tree_code rhs_code = gimple_assign_rhs_code (stmt); + tree rhs1 = gimple_assign_rhs1 (stmt); + tree rhs2 = gimple_assign_rhs2 (stmt); + tree lhs = gimple_assign_lhs (stmt); + tree val1 = NULL_TREE, val2 = NULL_TREE; + use_operand_p use_p; + gimple *use_stmt; + + /* Convert: + LHS = CST BINOP VAR + Where VAR is two-valued and LHS is used in GIMPLE_COND only + To: + LHS = VAR == VAL1 ? (CST BINOP VAL1) : (CST BINOP VAL2) + + Also handles: + LHS = VAR BINOP CST + Where VAR is two-valued and LHS is used in GIMPLE_COND only + To: + LHS = VAR == VAL1 ? (VAL1 BINOP CST) : (VAL2 BINOP CST) */ + + if (TREE_CODE_CLASS (rhs_code) == tcc_binary + && INTEGRAL_TYPE_P (TREE_TYPE (lhs)) + && ((TREE_CODE (rhs1) == INTEGER_CST + && TREE_CODE (rhs2) == SSA_NAME) + || (TREE_CODE (rhs2) == INTEGER_CST + && TREE_CODE (rhs1) == SSA_NAME)) + && single_imm_use (lhs, &use_p, &use_stmt) + && gimple_code (use_stmt) == GIMPLE_COND) + + { + tree new_rhs1 = NULL_TREE; + tree new_rhs2 = NULL_TREE; + tree cmp_var = NULL_TREE; + + if (TREE_CODE (rhs2) == SSA_NAME + && two_valued_val_range_p (rhs2, &val1, &val2)) + { + /* Optimize RHS1 OP [VAL1, VAL2]. */ + new_rhs1 = int_const_binop (rhs_code, rhs1, val1); + new_rhs2 = int_const_binop (rhs_code, rhs1, val2); + cmp_var = rhs2; + } + else if (TREE_CODE (rhs1) == SSA_NAME + && two_valued_val_range_p (rhs1, &val1, &val2)) + { + /* Optimize [VAL1, VAL2] OP RHS2. */ + new_rhs1 = int_const_binop (rhs_code, val1, rhs2); + new_rhs2 = int_const_binop (rhs_code, val2, rhs2); + cmp_var = rhs1; + } + + /* If we could not find two-vals or the optimzation is invalid as + in divide by zero, new_rhs1 / new_rhs will be NULL_TREE. */ + if (new_rhs1 && new_rhs2) + { + tree cond = build2 (EQ_EXPR, boolean_type_node, cmp_var, val1); + gimple_assign_set_rhs_with_ops (gsi, + COND_EXPR, cond, + new_rhs1, + new_rhs2); + update_stmt (gsi_stmt (*gsi)); + fold_stmt (gsi, follow_single_use_edges); + return true; + } + } + + switch (rhs_code) + { + case EQ_EXPR: + case NE_EXPR: + /* Transform EQ_EXPR, NE_EXPR into BIT_XOR_EXPR or identity + if the RHS is zero or one, and the LHS are known to be boolean + values. */ + if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) + return simplify_truth_ops_using_ranges (gsi, stmt); + break; + + /* Transform TRUNC_DIV_EXPR and TRUNC_MOD_EXPR into RSHIFT_EXPR + and BIT_AND_EXPR respectively if the first operand is greater + than zero and the second operand is an exact power of two. + Also optimize TRUNC_MOD_EXPR away if the second operand is + constant and the first operand already has the right value + range. */ + case TRUNC_DIV_EXPR: + case TRUNC_MOD_EXPR: + if ((TREE_CODE (rhs1) == SSA_NAME + || TREE_CODE (rhs1) == INTEGER_CST) + && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) + return simplify_div_or_mod_using_ranges (gsi, stmt); + break; + + /* Transform ABS (X) into X or -X as appropriate. */ + case ABS_EXPR: + if (TREE_CODE (rhs1) == SSA_NAME + && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) + return simplify_abs_using_ranges (gsi, stmt); + break; + + case BIT_AND_EXPR: + case BIT_IOR_EXPR: + /* Optimize away BIT_AND_EXPR and BIT_IOR_EXPR + if all the bits being cleared are already cleared or + all the bits being set are already set. */ + if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) + return simplify_bit_ops_using_ranges (gsi, stmt); + break; + + CASE_CONVERT: + if (TREE_CODE (rhs1) == SSA_NAME + && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) + return simplify_conversion_using_ranges (gsi, stmt); + break; + + case FLOAT_EXPR: + if (TREE_CODE (rhs1) == SSA_NAME + && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))) + return simplify_float_conversion_using_ranges (gsi, stmt); + break; + + case MIN_EXPR: + case MAX_EXPR: + return simplify_min_or_max_using_ranges (gsi, stmt); + + default: + break; + } + } + else if (gimple_code (stmt) == GIMPLE_COND) + return simplify_cond_using_ranges_1 (as_a (stmt)); + else if (gimple_code (stmt) == GIMPLE_SWITCH) + return simplify_switch_using_ranges (as_a (stmt)); + else if (is_gimple_call (stmt) + && gimple_call_internal_p (stmt)) + return simplify_internal_call_using_ranges (gsi, stmt); + + return false; +} + +void +vr_values::set_vr_value (tree var, value_range *vr) +{ + if (SSA_NAME_VERSION (var) >= num_vr_values) + return; + vr_value[SSA_NAME_VERSION (var)] = vr; +} + -- 2.30.2