Re: [COMMITTED] Convert nonzero mask in irange to wide_int.

[Richard Biener <richard.guenther@gmail.com>]

Am 04.10.2022 um 09:36 schrieb Aldy Hernandez via Gcc-patches <gcc-patches@gcc.gnu.org>:
> 
> The reason the nonzero mask was kept in a tree was basically inertia,
> as everything in irange is a tree.  However, there's no need to keep
> it in a tree, as the conversions to and from wide ints are very
> annoying.  That, plus special casing NULL masks to be -1 is prone
> to error.
> 
> I have not only rewritten all the uses to assume a wide int, but
> have corrected a few places where we weren't propagating the masks, or
> rather pessimizing them to -1.  This will become more important in
> upcoming patches where we make better use of the masks.
> 
> Performance testing shows a trivial improvement in VRP, as things like
> irange::contains_p() are tied to a tree.  Ughh, can't wait for trees in
> iranges to go away.

You want trailing wide int storage though.  A wide_int is quite large.

> gcc/ChangeLog:
> 
>    * value-range-storage.cc (irange_storage_slot::set_irange): Remove
>    special case.
>    * value-range.cc (irange::irange_set): Adjust for nonzero mask
>    being a wide int.
>    (irange::irange_set_anti_range): Same.
>    (irange::set): Same.
>    (irange::verify_range): Same.
>    (irange::legacy_equal_p): Same.
>    (irange::operator==): Same.
>    (irange::contains_p): Same.
>    (irange::legacy_intersect): Same.
>    (irange::legacy_union): Same.
>    (irange::irange_single_pair_union): Call union_nonzero_bits.
>    (irange::irange_union): Same.
>    (irange::irange_intersect): Call intersect_nonzero_bits.
>    (irange::intersect): Adjust for nonzero mask being a wide int.
>    (irange::invert): Same.
>    (irange::set_nonzero_bits): Same.
>    (irange::get_nonzero_bits_from_range): New.
>    (irange::set_range_from_nonzero_bits): New.
>    (irange::get_nonzero_bits): Adjust for nonzero mask being a wide
>    int.
>    (irange::intersect_nonzero_bits): Same.
>    (irange::union_nonzero_bits): Same.
>    (range_tests_nonzero_bits): Remove test.
>    * value-range.h (irange::varying_compatible_p): Adjust for nonzero
>    mask being a wide int.
>    (gt_ggc_mx): Same.
>    (gt_pch_nx): Same.
>    (irange::set_undefined): Same.
>    (irange::set_varying): Same.
>    (irange::normalize_kind): Same.
> ---
> gcc/value-range-storage.cc |   6 +-
> gcc/value-range.cc         | 270 ++++++++++++++++---------------------
> gcc/value-range.h          |  25 ++--
> 3 files changed, 130 insertions(+), 171 deletions(-)
> 
> diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc
> index de7575ed48d..6e054622830 100644
> --- a/gcc/value-range-storage.cc
> +++ b/gcc/value-range-storage.cc
> @@ -150,11 +150,7 @@ irange_storage_slot::set_irange (const irange &r)
> {
>   gcc_checking_assert (fits_p (r));
> 
> -  // Avoid calling unsupported get_nonzero_bits on legacy.
> -  if (r.legacy_mode_p ())
> -    m_ints[0] = -1;
> -  else
> -    m_ints[0] = r.get_nonzero_bits ();
> +  m_ints[0] = r.get_nonzero_bits ();
> 
>   unsigned pairs = r.num_pairs ();
>   for (unsigned i = 0; i < pairs; ++i)
> diff --git a/gcc/value-range.cc b/gcc/value-range.cc
> index 6e196574de9..afb26a40083 100644
> --- a/gcc/value-range.cc
> +++ b/gcc/value-range.cc
> @@ -940,7 +940,7 @@ irange::irange_set (tree min, tree max)
>   m_base[1] = max;
>   m_num_ranges = 1;
>   m_kind = VR_RANGE;
> -  m_nonzero_mask = NULL;
> +  m_nonzero_mask = wi::shwi (-1, TYPE_PRECISION (TREE_TYPE (min)));
>   normalize_kind ();
> 
>   if (flag_checking)
> @@ -1014,7 +1014,7 @@ irange::irange_set_anti_range (tree min, tree max)
>     }
> 
>   m_kind = VR_RANGE;
> -  m_nonzero_mask = NULL;
> +  m_nonzero_mask = wi::shwi (-1, TYPE_PRECISION (TREE_TYPE (min)));
>   normalize_kind ();
> 
>   if (flag_checking)
> @@ -1071,7 +1071,7 @@ irange::set (tree min, tree max, value_range_kind kind)
>       m_base[0] = min;
>       m_base[1] = max;
>       m_num_ranges = 1;
> -      m_nonzero_mask = NULL;
> +      m_nonzero_mask = wi::shwi (-1, TYPE_PRECISION (TREE_TYPE (min)));
>       return;
>     }
> 
> @@ -1121,7 +1121,7 @@ irange::set (tree min, tree max, value_range_kind kind)
>   m_base[0] = min;
>   m_base[1] = max;
>   m_num_ranges = 1;
> -  m_nonzero_mask = NULL;
> +  m_nonzero_mask = wi::shwi (-1, TYPE_PRECISION (TREE_TYPE (min)));
>   normalize_kind ();
>   if (flag_checking)
>     verify_range ();
> @@ -1136,14 +1136,11 @@ irange::verify_range ()
>   if (m_kind == VR_UNDEFINED)
>     {
>       gcc_checking_assert (m_num_ranges == 0);
> -      gcc_checking_assert (!m_nonzero_mask);
>       return;
>     }
> -  if (m_nonzero_mask)
> -    gcc_checking_assert (wi::to_wide (m_nonzero_mask) != -1);
>   if (m_kind == VR_VARYING)
>     {
> -      gcc_checking_assert (!m_nonzero_mask);
> +      gcc_checking_assert (m_nonzero_mask == -1);
>       gcc_checking_assert (m_num_ranges == 1);
>       gcc_checking_assert (varying_compatible_p ());
>       return;
> @@ -1238,7 +1235,7 @@ irange::legacy_equal_p (const irange &other) const
>                   other.tree_lower_bound (0))
>      && vrp_operand_equal_p (tree_upper_bound (0),
>                  other.tree_upper_bound (0))
> -      && vrp_operand_equal_p (m_nonzero_mask, other.m_nonzero_mask));
> +      && get_nonzero_bits () == other.get_nonzero_bits ());
> }
> 
> bool
> @@ -1273,7 +1270,7 @@ irange::operator== (const irange &other) const
>      || !operand_equal_p (ub, ub_other, 0))
>    return false;
>     }
> -  return vrp_operand_equal_p (m_nonzero_mask, other.m_nonzero_mask);
> +  return get_nonzero_bits () == other.get_nonzero_bits ();
> }
> 
> /* Return TRUE if this is a symbolic range.  */
> @@ -1416,10 +1413,11 @@ irange::contains_p (tree cst) const
> 
>   gcc_checking_assert (TREE_CODE (cst) == INTEGER_CST);
> 
> -  if (m_nonzero_mask)
> +  // See if we can exclude CST based on the nonzero bits.
> +  if (m_nonzero_mask != -1)
>     {
>       wide_int cstw = wi::to_wide (cst);
> -      if (cstw != 0 && wi::bit_and (wi::to_wide (m_nonzero_mask), cstw) == 0)
> +      if (cstw != 0 && wi::bit_and (m_nonzero_mask, cstw) == 0)
>    return false;
>     }
> 
> @@ -1878,9 +1876,6 @@ irange::legacy_intersect (irange *vr0, const irange *vr1)
>   intersect_ranges (&vr0kind, &vr0min, &vr0max,
>            vr1->kind (), vr1->min (), vr1->max ());
> 
> -  // Pessimize nonzero masks, as we don't support them.
> -  m_nonzero_mask = NULL;
> -
>   /* Make sure to canonicalize the result though as the inversion of a
>      VR_RANGE can still be a VR_RANGE.  */
>   if (vr0kind == VR_UNDEFINED)
> @@ -2202,9 +2197,6 @@ irange::legacy_union (irange *vr0, const irange *vr1)
>   union_ranges (&vr0kind, &vr0min, &vr0max,
>        vr1->kind (), vr1->min (), vr1->max ());
> 
> -  // Pessimize nonzero masks, as we don't support them.
> -  m_nonzero_mask = NULL;
> -
>   if (vr0kind == VR_UNDEFINED)
>     vr0->set_undefined ();
>   else if (vr0kind == VR_VARYING)
> @@ -2310,8 +2302,6 @@ irange::legacy_verbose_intersect (const irange *other)
> 
> // Perform an efficient union with R when both ranges have only a single pair.
> // Excluded are VARYING and UNDEFINED ranges.
> -//
> -// NOTE: It is the caller's responsibility to set the nonzero mask.
> 
> bool
> irange::irange_single_pair_union (const irange &r)
> @@ -2325,7 +2315,7 @@ irange::irange_single_pair_union (const irange &r)
>     {
>       // If current upper bound is new upper bound, we're done.
>       if (wi::le_p (wi::to_wide (r.m_base[1]), wi::to_wide (m_base[1]), sign))
> -    return false;
> +    return union_nonzero_bits (r);
>       // Otherwise R has the new upper bound.
>       // Check for overlap/touching ranges, or single target range.
>       if (m_max_ranges == 1
> @@ -2338,8 +2328,7 @@ irange::irange_single_pair_union (const irange &r)
>      m_base[3] = r.m_base[1];
>      m_num_ranges = 2;
>    }
> -      if (varying_compatible_p ())
> -    m_kind = VR_VARYING;
> +      union_nonzero_bits (r);
>       return true;
>     }
> 
> @@ -2353,11 +2342,7 @@ irange::irange_single_pair_union (const irange &r)
>   // Check for overlapping ranges, or target limited to a single range.
>   else if (m_max_ranges == 1
>       || wi::to_widest (r.m_base[1]) + 1 >= wi::to_widest (lb))
> -    {
> -      // This has the new upper bound, just check for varying.
> -      if (varying_compatible_p ())
> -      m_kind = VR_VARYING;
> -    }
> +    ;
>   else
>     {
>       // Left with 2 pairs.
> @@ -2366,8 +2351,7 @@ irange::irange_single_pair_union (const irange &r)
>       m_base[3] = m_base[1];
>       m_base[1] = r.m_base[1];
>     }
> -  if (varying_compatible_p ())
> -    m_kind = VR_VARYING;
> +  union_nonzero_bits (r);
>   return true;
> }
> 
> @@ -2398,27 +2382,13 @@ irange::irange_union (const irange &r)
>       return true;
>     }
> 
> -  // Save the nonzero mask in case the set operations below clobber it.
> -  bool ret_nz = union_nonzero_bits (r);
> -  tree saved_nz = m_nonzero_mask;
> -
> -  // The union_nonzero_bits may have turned things into a varying.
> -  if (varying_p ())
> -    return true;
> -
>   // Special case one range union one range.
>   if (m_num_ranges == 1 && r.m_num_ranges == 1)
> -    {
> -      bool ret = irange_single_pair_union (r);
> -      set_nonzero_bits (saved_nz);
> -      if (flag_checking)
> -    verify_range ();
> -      return ret || ret_nz;
> -    }
> +    return irange_single_pair_union (r);
> 
>   // If this ranges fully contains R, then we need do nothing.
>   if (irange_contains_p (r))
> -    return ret_nz;
> +    return union_nonzero_bits (r);
> 
>   // Do not worry about merging and such by reserving twice as many
>   // pairs as needed, and then simply sort the 2 ranges into this
> @@ -2506,11 +2476,7 @@ irange::irange_union (const irange &r)
>   m_num_ranges = i / 2;
> 
>   m_kind = VR_RANGE;
> -  m_nonzero_mask = saved_nz;
> -  normalize_kind ();
> -
> -  if (flag_checking)
> -    verify_range ();
> +  union_nonzero_bits (r);
>   return true;
> }
> 
> @@ -2576,21 +2542,11 @@ irange::irange_intersect (const irange &r)
>       set_undefined ();
>       return true;
>     }
> -
> -  // Save the nonzero mask in case the set operations below clobber it.
> -  bool ret_nz = intersect_nonzero_bits (r);
> -  tree saved_nz = m_nonzero_mask;
> -
>   if (r.varying_p ())
> -    return ret_nz;
> -
> +    return false;
>   if (varying_p ())
>     {
>       operator= (r);
> -      if (saved_nz)
> -    set_nonzero_bits (saved_nz);
> -      if (flag_checking)
> -    verify_range ();
>       return true;
>     }
> 
> @@ -2600,13 +2556,13 @@ irange::irange_intersect (const irange &r)
>       if (undefined_p ())
>    return true;
> 
> -      set_nonzero_bits (saved_nz);
> -      return res || saved_nz;
> +      res |= intersect_nonzero_bits (r);
> +      return res;
>     }
> 
>   // If R fully contains this, then intersection will change nothing.
>   if (r.irange_contains_p (*this))
> -    return ret_nz;
> +    return intersect_nonzero_bits (r);
> 
>   signop sign = TYPE_SIGN (TREE_TYPE(m_base[0]));
>   unsigned bld_pair = 0;
> @@ -2675,15 +2631,14 @@ irange::irange_intersect (const irange &r)
>   // At the exit of this loop, it is one of 2 things:
>   // ran out of r1, or r2, but either means we are done.
>   m_num_ranges = bld_pair;
> +  if (m_num_ranges == 0)
> +    {
> +      set_undefined ();
> +      return true;
> +    }
> 
>   m_kind = VR_RANGE;
> -  if (!undefined_p ())
> -    m_nonzero_mask = saved_nz;
> -  normalize_kind ();
> -
> -  if (flag_checking)
> -    verify_range ();
> -
> +  intersect_nonzero_bits (r);
>   return true;
> }
> 
> @@ -2749,10 +2704,15 @@ irange::intersect (const wide_int& lb, const wide_int& ub)
>     }
> 
>   m_num_ranges = bld_index;
> +  if (m_num_ranges == 0)
> +    {
> +      set_undefined ();
> +      return true;
> +    }
> 
>   m_kind = VR_RANGE;
> -  normalize_kind ();
> -
> +  // No need to call normalize_kind(), as the caller will do this
> +  // while intersecting the nonzero mask.
>   if (flag_checking)
>     verify_range ();
>   return true;
> @@ -2801,7 +2761,6 @@ irange::invert ()
>     }
> 
>   gcc_checking_assert (!undefined_p () && !varying_p ());
> -  m_nonzero_mask = NULL;
> 
>   // We always need one more set of bounds to represent an inverse, so
>   // if we're at the limit, we can't properly represent things.
> @@ -2822,6 +2781,7 @@ irange::invert ()
>   signop sign = TYPE_SIGN (ttype);
>   wide_int type_min = wi::min_value (prec, sign);
>   wide_int type_max = wi::max_value (prec, sign);
> +  m_nonzero_mask = wi::shwi (-1, prec);
>   if (m_num_ranges == m_max_ranges
>       && lower_bound () != type_min
>       && upper_bound () != type_max)
> @@ -2896,127 +2856,140 @@ irange::invert ()
>     verify_range ();
> }
> 
> -void
> -irange::set_nonzero_bits (tree mask)
> +// Return the nonzero bits inherent in the range.
> +
> +wide_int
> +irange::get_nonzero_bits_from_range () const
> {
> -  gcc_checking_assert (!undefined_p ());
> +  // For legacy symbolics.
> +  if (!constant_p ())
> +    return wi::shwi (-1, TYPE_PRECISION (type ()));
> 
> -  if (!mask)
> +  wide_int min = lower_bound ();
> +  wide_int max = upper_bound ();
> +  wide_int xorv = min ^ max;
> +  if (xorv != 0)
>     {
> -      if (m_nonzero_mask)
> -    {
> -      m_nonzero_mask = NULL;
> -      // Clearing the mask may have turned a range into VARYING.
> -      normalize_kind ();
> -    }
> -      return;
> +      unsigned prec = TYPE_PRECISION (type ());
> +      xorv = wi::mask (prec - wi::clz (xorv), false, prec);
>     }
> -  m_nonzero_mask = mask;
> -  // Setting the mask may have turned a VARYING into a range.
> -  if (m_kind == VR_VARYING)
> -    m_kind = VR_RANGE;
> -
> -  if (flag_checking)
> -    verify_range ();
> +  return min | xorv;
> }
> 
> -void
> -irange::set_nonzero_bits (const wide_int_ref &bits)
> +// If the the nonzero mask can be trivially converted to a range, do
> +// so and return TRUE.
> +
> +bool
> +irange::set_range_from_nonzero_bits ()
> {
>   gcc_checking_assert (!undefined_p ());
> +  unsigned popcount = wi::popcount (m_nonzero_mask);
> 
> -  if (bits == -1)
> -    {
> -      set_nonzero_bits (NULL);
> -      return;
> -    }
>   // If we have only one bit set in the mask, we can figure out the
>   // range immediately.
> -  if (wi::popcount (bits) == 1)
> +  if (popcount == 1)
>     {
>       // Make sure we don't pessimize the range.
> -      tree tbits = wide_int_to_tree (type (), bits);
> -      if (!contains_p (tbits))
> -    {
> -      set_nonzero_bits (tbits);
> -      return;
> -    }
> +      if (!contains_p (wide_int_to_tree (type (), m_nonzero_mask)))
> +    return false;
> 
>       bool has_zero = contains_p (build_zero_cst (type ()));
> +      wide_int bits = m_nonzero_mask;
>       set (type (), bits, bits);
> +      m_nonzero_mask = bits;
>       if (has_zero)
>    {
>      int_range<2> zero;
>      zero.set_zero (type ());
>      union_ (zero);
>    }
> +      return true;
>     }
> -  set_nonzero_bits (wide_int_to_tree (type (), bits));
> +  return false;
> }
> 
> -wide_int
> -irange::get_nonzero_bits () const
> +void
> +irange::set_nonzero_bits (const wide_int_ref &bits)
> {
>   gcc_checking_assert (!undefined_p ());
> +  unsigned prec = TYPE_PRECISION (type ());
> +  gcc_checking_assert (prec == bits.get_precision ());
> 
> -  // In case anyone in the legacy world queries us.
> -  if (!constant_p ())
> -    {
> -      if (m_nonzero_mask)
> -    return wi::to_wide (m_nonzero_mask);
> -      return wi::shwi (-1, TYPE_PRECISION (type ()));
> -    }
> +  // Drop VARYINGs with a nonzero mask to a plain range.
> +  if (m_kind == VR_VARYING && bits != -1)
> +    m_kind = VR_RANGE;
> 
> -  // Calculate the nonzero bits inherent in the range.
> -  wide_int min = lower_bound ();
> -  wide_int max = upper_bound ();
> -  wide_int xorv = min ^ max;
> -  if (xorv != 0)
> -    {
> -      unsigned prec = TYPE_PRECISION (type ());
> -      xorv = wi::mask (prec - wi::clz (xorv), false, prec);
> -    }
> -  wide_int mask = min | xorv;
> +  m_nonzero_mask = wide_int::from (bits, prec, TYPE_SIGN (type ()));
> +  if (set_range_from_nonzero_bits ())
> +    return;
> 
> -  // Return the nonzero bits augmented by the range.
> -  if (m_nonzero_mask)
> -    return mask & wi::to_wide (m_nonzero_mask);
> +  normalize_kind ();
> +  if (flag_checking)
> +    verify_range ();
> +}
> 
> -  return mask;
> +// Return the nonzero bitmask.  This will return the nonzero bits plus
> +// the nonzero bits inherent in the range.
> +
> +wide_int
> +irange::get_nonzero_bits () const
> +{
> +  gcc_checking_assert (!undefined_p ());
> +  // The nonzero mask inherent in the range is calculated on-demand.
> +  // For example, [0,255] does not have a 0xff nonzero mask by default
> +  // (unless manually set).  This saves us considerable time, because
> +  // setting it at creation incurs a large penalty for irange::set.
> +  // At the time of writing there was a 5% slowdown in VRP if we kept
> +  // the mask precisely up to date at all times.  Instead, we default
> +  // to -1 and set it when explicitly requested.  However, this
> +  // function will always return the correct mask.
> +  return m_nonzero_mask & get_nonzero_bits_from_range ();
> }
> 
> -// Intersect the nonzero bits in R into THIS.
> +// Intersect the nonzero bits in R into THIS and normalize the range.
> +// Return TRUE if the intersection changed anything.
> 
> bool
> irange::intersect_nonzero_bits (const irange &r)
> {
>   gcc_checking_assert (!undefined_p () && !r.undefined_p ());
> 
> -  if (m_nonzero_mask || r.m_nonzero_mask)
> +  bool changed = false;
> +  if (m_nonzero_mask != r.m_nonzero_mask)
>     {
> -      wide_int nz = wi::bit_and (get_nonzero_bits (),
> -                 r.get_nonzero_bits ());
> -      set_nonzero_bits (nz);
> -      return true;
> +      m_nonzero_mask = get_nonzero_bits () & r.get_nonzero_bits ();
> +      if (set_range_from_nonzero_bits ())
> +    return true;
> +      changed = true;
>     }
> -  return false;
> +  normalize_kind ();
> +  if (flag_checking)
> +    verify_range ();
> +  return changed;
> }
> 
> -// Union the nonzero bits in R into THIS.
> +// Union the nonzero bits in R into THIS and normalize the range.
> +// Return TRUE if the union changed anything.
> 
> bool
> irange::union_nonzero_bits (const irange &r)
> {
>   gcc_checking_assert (!undefined_p () && !r.undefined_p ());
> 
> -  if (m_nonzero_mask || r.m_nonzero_mask)
> +  bool changed = false;
> +  if (m_nonzero_mask != r.m_nonzero_mask)
>     {
> -      wide_int nz = wi::bit_or (get_nonzero_bits (),
> -                r.get_nonzero_bits ());
> -      set_nonzero_bits (nz);
> -      return true;
> +      m_nonzero_mask = get_nonzero_bits () | r.get_nonzero_bits ();
> +      // No need to call set_range_from_nonzero_bits, because we'll
> +      // never narrow the range.  Besides, it would cause endless
> +      // recursion because of the union_ in
> +      // set_range_from_nonzero_bits.
> +      changed = true;
>     }
> -  return false;
> +  normalize_kind ();
> +  if (flag_checking)
> +    verify_range ();
> +  return changed;
> }
> 
> void
> @@ -3605,13 +3578,6 @@ range_tests_nonzero_bits ()
>   r0.union_ (r1);
>   ASSERT_TRUE (r0.get_nonzero_bits () == 0xff);
> 
> -  // Union where the mask of nonzero bits is implicit from the range.
> -  r0.set_varying (integer_type_node);
> -  r0.set_nonzero_bits (0xf00);
> -  r1.set_zero (integer_type_node); // nonzero mask is implicitly 0
> -  r0.union_ (r1);
> -  ASSERT_TRUE (r0.get_nonzero_bits () == 0xf00);
> -
>   // Intersect of nonzero bits.
>   r0.set (INT (0), INT (255));
>   r0.set_nonzero_bits (0xfe);
> diff --git a/gcc/value-range.h b/gcc/value-range.h
> index 556e31aece1..d1663620444 100644
> --- a/gcc/value-range.h
> +++ b/gcc/value-range.h
> @@ -207,14 +207,15 @@ private:
> 
>   void irange_set_1bit_anti_range (tree, tree);
>   bool varying_compatible_p () const;
> -  void set_nonzero_bits (tree mask);
>   bool intersect_nonzero_bits (const irange &r);
>   bool union_nonzero_bits (const irange &r);
> +  wide_int get_nonzero_bits_from_range () const;
> +  bool set_range_from_nonzero_bits ();
> 
>   bool intersect (const wide_int& lb, const wide_int& ub);
>   unsigned char m_num_ranges;
>   unsigned char m_max_ranges;
> -  tree m_nonzero_mask;
> +  wide_int m_nonzero_mask;
>   tree *m_base;
> };
> 
> @@ -682,10 +683,11 @@ irange::varying_compatible_p () const
>   if (INTEGRAL_TYPE_P (t))
>     return (wi::to_wide (l) == wi::min_value (prec, sign)
>        && wi::to_wide (u) == wi::max_value (prec, sign)
> -        && !m_nonzero_mask);
> +        && m_nonzero_mask == -1);
>   if (POINTER_TYPE_P (t))
>     return (wi::to_wide (l) == 0
> -        && wi::to_wide (u) == wi::max_value (prec, sign));
> +        && wi::to_wide (u) == wi::max_value (prec, sign)
> +        && m_nonzero_mask == -1);
>   return true;
> }
> 
> @@ -752,8 +754,6 @@ gt_ggc_mx (irange *x)
>       gt_ggc_mx (x->m_base[i * 2]);
>       gt_ggc_mx (x->m_base[i * 2 + 1]);
>     }
> -  if (x->m_nonzero_mask)
> -    gt_ggc_mx (x->m_nonzero_mask);
> }
> 
> inline void
> @@ -764,8 +764,6 @@ gt_pch_nx (irange *x)
>       gt_pch_nx (x->m_base[i * 2]);
>       gt_pch_nx (x->m_base[i * 2 + 1]);
>     }
> -  if (x->m_nonzero_mask)
> -    gt_pch_nx (x->m_nonzero_mask);
> }
> 
> inline void
> @@ -776,8 +774,6 @@ gt_pch_nx (irange *x, gt_pointer_operator op, void *cookie)
>       op (&x->m_base[i * 2], NULL, cookie);
>       op (&x->m_base[i * 2 + 1], NULL, cookie);
>     }
> -  if (x->m_nonzero_mask)
> -    op (&x->m_nonzero_mask, NULL, cookie);
> }
> 
> template<unsigned N>
> @@ -872,7 +868,6 @@ irange::set_undefined ()
> {
>   m_kind = VR_UNDEFINED;
>   m_num_ranges = 0;
> -  m_nonzero_mask = NULL;
> }
> 
> inline void
> @@ -880,7 +875,11 @@ irange::set_varying (tree type)
> {
>   m_kind = VR_VARYING;
>   m_num_ranges = 1;
> -  m_nonzero_mask = NULL;
> +
> +  if (type == error_mark_node)
> +    m_nonzero_mask = wi::shwi (-1, 1);
> +  else
> +    m_nonzero_mask = wi::shwi (-1, TYPE_PRECISION (type));
> 
>   if (INTEGRAL_TYPE_P (type))
>     {
> @@ -1002,8 +1001,6 @@ irange::normalize_kind ()
>    m_kind = VR_VARYING;
>       else if (m_kind == VR_ANTI_RANGE)
>    set_undefined ();
> -      else
> -    gcc_unreachable ();
>     }
> }
> 
> -- 
> 2.37.1
>