gcc/wide-int-range.h

   1 /* Support routines for range operations on wide ints.
   2    Copyright (C) 2018-2019 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_WIDE_INT_RANGE_H
  21 #define GCC_WIDE_INT_RANGE_H
  22
  23 extern bool wide_int_range_cross_product (wide_int &res_lb, wide_int &res_ub,
  24                                           enum tree_code code, signop sign,
  25                                           const wide_int &, const wide_int &,
  26                                           const wide_int &, const wide_int &,
  27                                           bool overflow_undefined);
  28 extern bool wide_int_range_mult_wrapping (wide_int &res_lb,
  29                                           wide_int &res_ub,
  30                                           signop sign,
  31                                           unsigned prec,
  32                                           const wide_int &min0_,
  33                                           const wide_int &max0_,
  34                                           const wide_int &min1_,
  35                                           const wide_int &max1_);
  36 extern bool wide_int_range_multiplicative_op (wide_int &res_lb,
  37                                               wide_int &res_ub,
  38                                               enum tree_code code,
  39                                               signop sign,
  40                                               unsigned prec,
  41                                               const wide_int &vr0_lb,
  42                                               const wide_int &vr0_ub,
  43                                               const wide_int &vr1_lb,
  44                                               const wide_int &vr1_ub,
  45                                               bool overflow_undefined);
  46 extern bool wide_int_range_lshift (wide_int &res_lb, wide_int &res_ub,
  47                                    signop sign, unsigned prec,
  48                                    const wide_int &, const wide_int &,
  49                                    const wide_int &, const wide_int &,
  50                                    bool overflow_undefined);
  51 extern void wide_int_range_set_zero_nonzero_bits (signop,
  52                                                   const wide_int &lb,
  53                                                   const wide_int &ub,
  54                                                   wide_int &may_be_nonzero,
  55                                                   wide_int &must_be_nonzero);
  56 extern bool wide_int_range_optimize_bit_op (wide_int &res_lb, wide_int &res_ub,
  57                                             enum tree_code code,
  58                                             signop sign,
  59                                             const wide_int &vr0_lb,
  60                                             const wide_int &vr0_ub,
  61                                             const wide_int &vr1_lb,
  62                                             const wide_int &vr1_ub);
  63 extern bool wide_int_range_get_mask_and_bounds (wide_int &mask,
  64                                                 wide_int &lower_bound,
  65                                                 wide_int &upper_bound,
  66                                                 const wide_int &vr0_min,
  67                                                 const wide_int &vr0_max,
  68                                                 const wide_int &vr1_min,
  69                                                 const wide_int &vr1_max);
  70 extern bool wide_int_range_bit_xor (wide_int &wmin, wide_int &wmax,
  71                                     signop sign,
  72                                     unsigned prec,
  73                                     const wide_int &must_be_nonzero0,
  74                                     const wide_int &may_be_nonzero0,
  75                                     const wide_int &must_be_nonzero1,
  76                                     const wide_int &may_be_nonzero1);
  77 extern bool wide_int_range_bit_ior (wide_int &wmin, wide_int &wmax,
  78                                     signop sign,
  79                                     const wide_int &vr0_min,
  80                                     const wide_int &vr0_max,
  81                                     const wide_int &vr1_min,
  82                                     const wide_int &vr1_max,
  83                                     const wide_int &must_be_nonzero0,
  84                                     const wide_int &may_be_nonzero0,
  85                                     const wide_int &must_be_nonzero1,
  86                                     const wide_int &may_be_nonzero1);
  87 extern bool wide_int_range_bit_and (wide_int &wmin, wide_int &wmax,
  88                                     signop sign,
  89                                     unsigned prec,
  90                                     const wide_int &vr0_min,
  91                                     const wide_int &vr0_max,
  92                                     const wide_int &vr1_min,
  93                                     const wide_int &vr1_max,
  94                                     const wide_int &must_be_nonzero0,
  95                                     const wide_int &may_be_nonzero0,
  96                                     const wide_int &must_be_nonzero1,
  97                                     const wide_int &may_be_nonzero1);
  98 extern void wide_int_range_trunc_mod (wide_int &wmin, wide_int &wmax,
  99                                       signop sign,
 100                                       unsigned prec,
 101                                       const wide_int &vr0_min,
 102                                       const wide_int &vr0_max,
 103                                       const wide_int &vr1_min,
 104                                       const wide_int &vr1_max);
 105 extern bool wide_int_range_abs (wide_int &min, wide_int &max,
 106                                 signop sign, unsigned prec,
 107                                 const wide_int &vr0_min,
 108                                 const wide_int &vr0_max,
 109                                 bool overflow_undefined);
 110 extern void wide_int_range_absu (wide_int &min, wide_int &max,
 111                                  unsigned prec,
 112                                  const wide_int &vr0_min,
 113                                  const wide_int &vr0_max);
 114 extern bool wide_int_range_convert (wide_int &min, wide_int &max,
 115                                     signop inner_sign,
 116                                     unsigned inner_prec,
 117                                     signop outer_sign,
 118                                     unsigned outer_prec,
 119                                     const wide_int &vr0_min,
 120                                     const wide_int &vr0_max);
 121 extern bool wide_int_range_div (wide_int &wmin, wide_int &wmax,
 122                                 enum tree_code code,
 123                                 signop sign, unsigned prec,
 124                                 const wide_int &dividend_min,
 125                                 const wide_int &dividend_max,
 126                                 const wide_int &divisor_min,
 127                                 const wide_int &divisor_max,
 128                                 bool overflow_undefined,
 129                                 bool &extra_range_p,
 130                                 wide_int &extra_min, wide_int &extra_max);
 131
 132 /* Return TRUE if shifting by range [MIN, MAX] is undefined behavior,
 133    interpreting MIN and MAX according to SIGN.  */
 134
 135 inline bool
 136 wide_int_range_shift_undefined_p (signop sign, unsigned prec,
 137                                   const wide_int &min, const wide_int &max)
 138 {
 139   /* ?? Note: The original comment said this only applied to
 140      RSHIFT_EXPR, but it was being applied to both left and right
 141      shifts.  */
 142
 143   /* Shifting by any values outside [0..prec-1], gets undefined
 144      behavior from the shift operation.  We cannot even trust
 145      SHIFT_COUNT_TRUNCATED at this stage, because that applies to rtl
 146      shifts, and the operation at the tree level may be widened.  */
 147   return wi::lt_p (min, 0, sign) || wi::ge_p (max, prec, sign);
 148 }
 149
 150 /* Calculate MIN/MAX_EXPR of two ranges and store the result in [MIN, MAX].  */
 151
 152 inline bool
 153 wide_int_range_min_max (wide_int &min, wide_int &max,
 154                         tree_code code,
 155                         signop sign, unsigned prec,
 156                         const wide_int &vr0_min, const wide_int &vr0_max,
 157                         const wide_int &vr1_min, const wide_int &vr1_max)
 158 {
 159   wi::overflow_type overflow;
 160   wide_int_binop (min, code, vr0_min, vr1_min, sign, &overflow);
 161   wide_int_binop (max, code, vr0_max, vr1_max, sign, &overflow);
 162   /* If the new range covers the entire domain, that's really no range
 163      at all.  */
 164   if (min == wi::min_value (prec, sign)
 165       && max == wi::max_value (prec, sign))
 166     return false;
 167   return true;
 168 }
 169
 170 /* Return TRUE if 0 is within [WMIN, WMAX].  */
 171
 172 inline bool
 173 wide_int_range_includes_zero_p (const wide_int &wmin, const wide_int &wmax,
 174                                 signop sign)
 175 {
 176   return wi::le_p (wmin, 0, sign) && wi::ge_p (wmax, 0, sign);
 177 }
 178
 179 /* Return TRUE if [WMIN, WMAX] is the singleton 0.  */
 180
 181 inline bool
 182 wide_int_range_zero_p (const wide_int &wmin, const wide_int &wmax,
 183                        unsigned prec)
 184 {
 185   return wmin == wmax && wi::eq_p (wmin, wi::zero (prec));
 186 }
 187
 188 #endif /* GCC_WIDE_INT_RANGE_H */