gcc/value-range.h

   1 /* Support routines for value ranges.
   2    Copyright (C) 2019-2020 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_VALUE_RANGE_H
  21 #define GCC_VALUE_RANGE_H
  22
  23 /* Types of value ranges.  */
  24 enum value_range_kind
  25 {
  26   /* Empty range.  */
  27   VR_UNDEFINED,
  28   /* Range spans the entire domain.  */
  29   VR_VARYING,
  30   /* Range is [MIN, MAX].  */
  31   VR_RANGE,
  32   /* Range is ~[MIN, MAX].  */
  33   VR_ANTI_RANGE,
  34   /* Range is a nice guy.  */
  35   VR_LAST
  36 };
  37
  38 // Range of values that can be associated with an SSA_NAME.
  39
  40 class GTY((for_user)) value_range
  41 {
  42 public:
  43   value_range ();
  44   value_range (tree, tree, value_range_kind = VR_RANGE);
  45   value_range (tree type, const wide_int &, const wide_int &,
  46                value_range_kind = VR_RANGE);
  47   value_range (tree type);
  48
  49   void set (tree, tree, value_range_kind = VR_RANGE);
  50   void set (tree);
  51   void set_nonzero (tree);
  52   void set_zero (tree);
  53
  54   enum value_range_kind kind () const;
  55   tree min () const;
  56   tree max () const;
  57
  58   /* Types of value ranges.  */
  59   bool symbolic_p () const;
  60   bool constant_p () const;
  61   bool undefined_p () const;
  62   bool varying_p () const;
  63   void set_varying (tree type);
  64   void set_undefined ();
  65
  66   void union_ (const value_range *);
  67   void intersect (const value_range *);
  68   void union_ (const value_range &);
  69   void intersect (const value_range &);
  70
  71   bool operator== (const value_range &) const;
  72   bool operator!= (const value_range &) const /* = delete */;
  73   bool equal_p (const value_range &) const;
  74
  75   /* Misc methods.  */
  76   tree type () const;
  77   bool may_contain_p (tree) const;
  78   bool zero_p () const;
  79   bool nonzero_p () const;
  80   bool singleton_p (tree *result = NULL) const;
  81   void dump (FILE *) const;
  82   void dump () const;
  83
  84   static bool supports_type_p (tree);
  85   void normalize_symbolics ();
  86   void normalize_addresses ();
  87
  88   static const unsigned int m_max_pairs = 2;
  89   bool contains_p (tree) const;
  90   unsigned num_pairs () const;
  91   wide_int lower_bound (unsigned = 0) const;
  92   wide_int upper_bound (unsigned) const;
  93   wide_int upper_bound () const;
  94   void invert ();
  95
  96 protected:
  97   void check ();
  98   static value_range union_helper (const value_range *, const value_range *);
  99   static value_range intersect_helper (const value_range *,
 100                                        const value_range *);
 101
 102   friend void gt_ggc_mx_value_range (void *);
 103   friend void gt_pch_p_11value_range (void *, void *,
 104                                       gt_pointer_operator, void *);
 105   friend void gt_pch_nx_value_range (void *);
 106   friend void gt_ggc_mx (value_range &);
 107   friend void gt_ggc_mx (value_range *&);
 108   friend void gt_pch_nx (value_range &);
 109   friend void gt_pch_nx (value_range *, gt_pointer_operator, void *);
 110
 111   enum value_range_kind m_kind;
 112   tree m_min;
 113   tree m_max;
 114
 115 private:
 116   int value_inside_range (tree) const;
 117 };
 118
 119 extern bool range_has_numeric_bounds_p (const value_range *);
 120 extern bool ranges_from_anti_range (const value_range *,
 121                                     value_range *, value_range *);
 122 extern void dump_value_range (FILE *, const value_range *);
 123 extern bool vrp_val_is_min (const_tree);
 124 extern bool vrp_val_is_max (const_tree);
 125 extern tree vrp_val_min (const_tree);
 126 extern tree vrp_val_max (const_tree);
 127 extern bool vrp_operand_equal_p (const_tree, const_tree);
 128
 129 inline
 130 value_range::value_range ()
 131 {
 132   m_kind = VR_UNDEFINED;
 133   m_min = m_max = NULL;
 134 }
 135
 136 inline value_range_kind
 137 value_range::kind () const
 138 {
 139   return m_kind;
 140 }
 141
 142 inline tree
 143 value_range::type () const
 144 {
 145   return TREE_TYPE (min ());
 146 }
 147
 148 inline tree
 149 value_range::min () const
 150 {
 151   return m_min;
 152 }
 153
 154 inline tree
 155 value_range::max () const
 156 {
 157   return m_max;
 158 }
 159
 160 inline bool
 161 value_range::varying_p () const
 162 {
 163   return m_kind == VR_VARYING;
 164 }
 165
 166 inline bool
 167 value_range::undefined_p () const
 168 {
 169   return m_kind == VR_UNDEFINED;
 170 }
 171
 172 inline bool
 173 value_range::zero_p () const
 174 {
 175   return (m_kind == VR_RANGE
 176           && integer_zerop (m_min)
 177           && integer_zerop (m_max));
 178 }
 179
 180 inline bool
 181 value_range::nonzero_p () const
 182 {
 183   if (m_kind == VR_ANTI_RANGE
 184       && !TYPE_UNSIGNED (type ())
 185       && integer_zerop (m_min)
 186       && integer_zerop (m_max))
 187     return true;
 188
 189   return (m_kind == VR_RANGE
 190           && TYPE_UNSIGNED (type ())
 191           && integer_onep (m_min)
 192           && vrp_val_is_max (m_max));
 193 }
 194
 195 inline bool
 196 value_range::supports_type_p (tree type)
 197 {
 198   if (type && (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type)))
 199     return type;
 200   return false;
 201 }
 202
 203 inline bool
 204 range_includes_zero_p (const value_range *vr)
 205 {
 206   if (vr->undefined_p ())
 207     return false;
 208
 209   if (vr->varying_p ())
 210     return true;
 211
 212   return vr->may_contain_p (build_zero_cst (vr->type ()));
 213 }
 214
 215 #endif // GCC_VALUE_RANGE_H