1 /* Support routines for Value Range Propagation (VRP). 2 Copyright (C) 2016-2018 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3, or (at your option) 9 any later version. 10 11 GCC is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #ifndef GCC_VR_VALUES_H 21 #define GCC_VR_VALUES_H 22 23 /* The VR_VALUES class holds the current view of range information 24 for all the SSA_NAMEs in the IL. 25 26 It can be used to hold context sensitive range information during 27 a dominator walk or it may be used to hold range information in the 28 standard VRP pass as ranges are propagated through the lattice to a 29 steady state. 30 31 This information is independent of the range information that gets 32 attached to SSA_NAMEs. A pass such as VRP may choose to transfer 33 the global information it produces into global range information that 34 gets attached to an SSA_NAME. It's unclear how useful that global 35 information will be in a world where we can compute context sensitive 36 range information fast or perform on-demand queries. */ 37 class vr_values 38 { 39 public: 40 vr_values (void); 41 ~vr_values (void); 42 43 value_range *get_value_range (const_tree); 44 45 void set_vr_value (tree, value_range *); 46 void set_defs_to_varying (gimple *); 47 bool update_value_range (const_tree, value_range *); 48 tree op_with_constant_singleton_value_range (tree); 49 void adjust_range_with_scev (value_range *, struct loop *, gimple *, tree); 50 tree vrp_evaluate_conditional (tree_code, tree, tree, gimple *); 51 void dump_all_value_ranges (FILE *); 52 53 void extract_range_for_var_from_comparison_expr (tree, enum tree_code, 54 tree, tree, value_range *); 55 void extract_range_from_phi_node (gphi *, value_range *); 56 void extract_range_basic (value_range *, gimple *); 57 void extract_range_from_stmt (gimple *, edge *, tree *, value_range *); 58 59 void vrp_visit_cond_stmt (gcond *, edge *); 60 61 void simplify_cond_using_ranges_2 (gcond *); 62 bool simplify_stmt_using_ranges (gimple_stmt_iterator *); 63 64 /* Indicate that propagation through the lattice is complete. */ 65 void set_lattice_propagation_complete (void) { values_propagated = true; } 66 67 /* Allocate a new value_range object. */ 68 value_range *allocate_value_range (void) 69 { return vrp_value_range_pool.allocate (); } 70 71 private: 72 void add_equivalence (bitmap *, const_tree); 73 bool vrp_stmt_computes_nonzero (gimple *); 74 bool op_with_boolean_value_range_p (tree); 75 bool check_for_binary_op_overflow (enum tree_code, tree, tree, tree, bool *); 76 value_range get_vr_for_comparison (int); 77 tree compare_name_with_value (enum tree_code, tree, tree, bool *, bool); 78 tree compare_names (enum tree_code, tree, tree, bool *); 79 bool two_valued_val_range_p (tree, tree *, tree *); 80 tree vrp_evaluate_conditional_warnv_with_ops_using_ranges (enum tree_code, 81 tree, tree, 82 bool *); 83 tree vrp_evaluate_conditional_warnv_with_ops (enum tree_code, 84 tree, tree, bool, 85 bool *, bool *); 86 void extract_range_from_assignment (value_range *, gassign *); 87 void extract_range_from_assert (value_range *, tree); 88 void extract_range_from_ssa_name (value_range *, tree); 89 void extract_range_from_binary_expr (value_range *, enum tree_code, 90 tree, tree, tree); 91 void extract_range_from_unary_expr (value_range *, enum tree_code, 92 tree, tree); 93 void extract_range_from_cond_expr (value_range *, gassign *); 94 void extract_range_from_comparison (value_range *, enum tree_code, 95 tree, tree, tree); 96 void vrp_visit_assignment_or_call (gimple*, tree *, value_range *); 97 void vrp_visit_switch_stmt (gswitch *, edge *); 98 bool simplify_truth_ops_using_ranges (gimple_stmt_iterator *, gimple *); 99 bool simplify_div_or_mod_using_ranges (gimple_stmt_iterator *, gimple *); 100 bool simplify_abs_using_ranges (gimple_stmt_iterator *, gimple *); 101 bool simplify_bit_ops_using_ranges (gimple_stmt_iterator *, gimple *); 102 bool simplify_min_or_max_using_ranges (gimple_stmt_iterator *, gimple *); 103 bool simplify_cond_using_ranges_1 (gcond *); 104 bool simplify_switch_using_ranges (gswitch *); 105 bool simplify_float_conversion_using_ranges (gimple_stmt_iterator *, 106 gimple *); 107 bool simplify_internal_call_using_ranges (gimple_stmt_iterator *, gimple *); 108 109 /* Allocation pools for value_range objects. */ 110 object_allocator<value_range> vrp_value_range_pool; 111 112 /* This probably belongs in the lattice rather than in here. */ 113 bool values_propagated; 114 115 /* Allocations for equivalences all come from this obstack. */ 116 bitmap_obstack vrp_equiv_obstack; 117 118 /* Value range array. After propagation, VR_VALUE[I] holds the range 119 of values that SSA name N_I may take. */ 120 unsigned int num_vr_values; 121 value_range **vr_value; 122 123 /* For a PHI node which sets SSA name N_I, VR_COUNTS[I] holds the 124 number of executable edges we saw the last time we visited the 125 node. */ 126 int *vr_phi_edge_counts; 127 }; 128 129 #define VR_INITIALIZER { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL } 130 131 extern tree get_output_for_vrp (gimple *); 132 #endif /* GCC_VR_VALUES_H */ 133