Implement value/mask tracking for irange.

Integer ranges (irange) currently track known 0 bits.  We've wanted to
track known 1 bits for some time, and instead of tracking known 0 and
known 1's separately, it has been suggested we track a value/mask pair
similarly to what we do for CCP and RTL.  This patch implements such a
thing.

With this we now track a VALUE integer which are the known values, and
a MASK which tells us which bits contain meaningful information.  This
allows us to fix a handful of enhancement requests, such as PR107043
and PR107053.

There is a 4.48% performance penalty for VRP and 0.42% in overall
compilation for this entire patchset.  It is expected and in line
with the loss incurred when we started tracking known 0 bits.

This patch just provides the value/mask tracking support.  All the
nonzero users (range-op, IPA, CCP, etc), are still using the nonzero
nomenclature.  For that matter, this patch reimplements the nonzero
accessors with the value/mask functionality.  In follow-up patches I
will enhance these passes to use the value/mask information, and
fix the aforementioned PRs.

gcc/ChangeLog:

	* data-streamer-in.cc (streamer_read_value_range): Adjust for
	value/mask.
	* data-streamer-out.cc (streamer_write_vrange): Same.
	* range-op.cc (operator_cast::fold_range): Same.
	* value-range-pretty-print.cc
	(vrange_printer::print_irange_bitmasks): Same.
	* value-range-storage.cc (irange_storage::write_lengths_address):
	Same.
	(irange_storage::set_irange): Same.
	(irange_storage::get_irange): Same.
	(irange_storage::size): Same.
	(irange_storage::dump): Same.
	* value-range-storage.h: Same.
	* value-range.cc (debug): New.
	(irange_bitmask::dump): New.
	(add_vrange): Adjust for value/mask.
	(irange::operator=): Same.
	(irange::set): Same.
	(irange::verify_range): Same.
	(irange::operator==): Same.
	(irange::contains_p): Same.
	(irange::irange_single_pair_union): Same.
	(irange::union_): Same.
	(irange::intersect): Same.
	(irange::invert): Same.
	(irange::get_nonzero_bits_from_range): Rename to...
	(irange::get_bitmask_from_range): ...this.
	(irange::set_range_from_nonzero_bits): Rename to...
	(irange::set_range_from_bitmask): ...this.
	(irange::set_nonzero_bits): Rename to...
	(irange::update_bitmask): ...this.
	(irange::get_nonzero_bits): Rename to...
	(irange::get_bitmask): ...this.
	(irange::intersect_nonzero_bits): Rename to...
	(irange::intersect_bitmask): ...this.
	(irange::union_nonzero_bits): Rename to...
	(irange::union_bitmask): ...this.
	(irange_bitmask::verify_mask): New.
	* value-range.h (class irange_bitmask): New.
	(irange_bitmask::set_unknown): New.
	(irange_bitmask::unknown_p): New.
	(irange_bitmask::irange_bitmask): New.
	(irange_bitmask::get_precision): New.
	(irange_bitmask::get_nonzero_bits): New.
	(irange_bitmask::set_nonzero_bits): New.
	(irange_bitmask::operator==): New.
	(irange_bitmask::union_): New.
	(irange_bitmask::intersect): New.
	(class irange): Friend vrange_printer.
	(irange::varying_compatible_p): Adjust for bitmask.
	(irange::set_varying): Same.
	(irange::set_nonzero): Same.

gcc/testsuite/ChangeLog:

	* gcc.dg/tree-ssa/pr107009.c: Adjust irange dumping for
	value/mask changes.
	* gcc.dg/tree-ssa/vrp-unreachable.c: Same.
	* gcc.dg/tree-ssa/vrp122.c: Same.

Author: aldyh

gcc/data-streamer-in.cc

@@ -241,8 +241,10 @@ streamer_read_value_range (class lto_input_block *ib, data_in *data_in,
 	  int_range<2> tmp (type, lb, ub);
 	  r.union_ (tmp);
 	}
-      wide_int nz = streamer_read_wide_int (ib);
-      r.set_nonzero_bits (nz);
+      wide_int value = streamer_read_wide_int (ib);
+      wide_int mask = streamer_read_wide_int (ib);
+      irange_bitmask bm (value, mask);
+      r.update_bitmask (bm);
       return;
     }
   if (is_a <frange> (vr))

gcc/data-streamer-out.cc

@@ -423,7 +423,10 @@ streamer_write_vrange (struct output_block *ob, const vrange &v)
 	  streamer_write_wide_int (ob, r.lower_bound (i));
 	  streamer_write_wide_int (ob, r.upper_bound (i));
 	}
-      streamer_write_wide_int (ob, r.get_nonzero_bits ());
+      // TODO: We could avoid streaming out the value if the mask is -1.
+      irange_bitmask bm = r.get_bitmask ();
+      streamer_write_wide_int (ob, bm.value ());
+      streamer_write_wide_int (ob, bm.mask ());
       return;
     }
   if (is_a <frange> (v))

gcc/range-op.cc

@@ -2876,16 +2876,20 @@ operator_cast::fold_range (irange &r, tree type ATTRIBUTE_UNUSED,
 	return true;
     }
 
-  // Update the nonzero mask.  Truncating casts are problematic unless
+  // Update the bitmask.  Truncating casts are problematic unless
   // the conversion fits in the resulting outer type.
-  wide_int nz = inner.get_nonzero_bits ();
+  irange_bitmask bm = inner.get_bitmask ();
   if (truncating_cast_p (inner, outer)
-      && wi::rshift (nz, wi::uhwi (TYPE_PRECISION (outer.type ()),
-				   TYPE_PRECISION (inner.type ())),
+      && wi::rshift (bm.mask (),
+		     wi::uhwi (TYPE_PRECISION (outer.type ()),
+			       TYPE_PRECISION (inner.type ())),
 		     TYPE_SIGN (inner.type ())) != 0)
     return true;
-  nz = wide_int::from (nz, TYPE_PRECISION (type), TYPE_SIGN (inner.type ()));
-  r.set_nonzero_bits (nz);
+  unsigned prec = TYPE_PRECISION (type);
+  signop sign = TYPE_SIGN (inner.type ());
+  bm = irange_bitmask (wide_int::from (bm.value (), prec, sign),
+		       wide_int::from (bm.mask (), prec, sign));
+  r.update_bitmask (bm);
 
   return true;
 }

gcc/testsuite/gcc.dg/tree-ssa/pr107009.c

@@ -12,4 +12,4 @@ void saxpy(size_t n)
   foobar (n);
 }
 
-// { dg-final { scan-tree-dump "NONZERO.*fff8" "dom2" } }
+// { dg-final { scan-tree-dump "fff8 VALUE 0x0" "dom2" } }

gcc/testsuite/gcc.dg/tree-ssa/vrp-unreachable.c

@@ -39,4 +39,4 @@ void func (unsigned n, unsigned m)
 /* { dg-final { scan-tree-dump-not "dead" "vrp1" } } */
 /* { dg-final { scan-tree-dump-times "builtin_unreachable" 1 "vrp1" } } */
 /* { dg-final { scan-tree-dump-not "builtin_unreachable" "vrp2" } } */
-/* { dg-final { scan-tree-dump-times "fff8" 4 "vrp2" } } */
+/* { dg-final { scan-tree-dump-times "fff8 VALUE 0x0" 4 "vrp2" } } */

gcc/testsuite/gcc.dg/tree-ssa/vrp122.c

@@ -16,4 +16,4 @@ int f(unsigned t)
   return 0;
 }
 
-// { dg-final { scan-tree-dump "Global Exported: g_.* NONZERO 0x.*fff0" "evrp" } }
+// { dg-final { scan-tree-dump "Global Exported: g_.* MASK 0x1 VALUE 0x0" "evrp" } }

gcc/value-range-pretty-print.cc

@@ -94,13 +94,16 @@ vrange_printer::print_irange_bound (const wide_int &bound, tree type) const
 void
 vrange_printer::print_irange_bitmasks (const irange &r) const
 {
-  wide_int nz = r.get_nonzero_bits ();
-  if (nz == -1)
+  irange_bitmask bm = r.m_bitmask;
+  if (bm.unknown_p ())
     return;
 
-  pp_string (pp, " NONZERO ");
+  pp_string (pp, " MASK ");
   char buf[WIDE_INT_PRINT_BUFFER_SIZE];
-  print_hex (nz, buf);
+  print_hex (bm.mask (), buf);
+  pp_string (pp, buf);
+  pp_string (pp, " VALUE ");
+  print_hex (bm.value (), buf);
   pp_string (pp, buf);
 }
 

gcc/value-range-storage.cc

@@ -232,7 +232,7 @@ vrange_storage::equal_p (const vrange &r) const
 unsigned char *
 irange_storage::write_lengths_address ()
 {
-  return (unsigned char *)&m_val[(m_num_ranges * 2 + 1)
+  return (unsigned char *)&m_val[(m_num_ranges * 2 + 2)
 				 * WIDE_INT_MAX_HWIS (m_precision)];
 }
 
@@ -301,7 +301,11 @@ irange_storage::set_irange (const irange &r)
       write_wide_int (val, len, r.lower_bound (i));
       write_wide_int (val, len, r.upper_bound (i));
     }
-  write_wide_int (val, len, r.m_nonzero_mask);
+
+  // TODO: We could avoid streaming out the value if the mask is -1.
+  irange_bitmask bm = r.m_bitmask;
+  write_wide_int (val, len, bm.value ());
+  write_wide_int (val, len, bm.mask ());
 
   if (flag_checking)
     {
@@ -367,7 +371,12 @@ irange_storage::get_irange (irange &r, tree type) const
 	  r.union_ (tmp);
 	}
     }
-  read_wide_int (r.m_nonzero_mask, val, *len, m_precision);
+
+  wide_int bits_value, bits_mask;
+  read_wide_int (bits_value, val, *len, m_precision);
+  val += *len++;
+  read_wide_int (bits_mask, val, *len, m_precision);
+  r.m_bitmask = irange_bitmask (bits_value, bits_mask);
   if (r.m_kind == VR_VARYING)
     r.m_kind = VR_RANGE;
 
@@ -399,7 +408,7 @@ irange_storage::size (const irange &r)
     return sizeof (irange_storage);
 
   unsigned prec = TYPE_PRECISION (r.type ());
-  unsigned n = r.num_pairs () * 2 + 1;
+  unsigned n = r.num_pairs () * 2 + 2;
   unsigned hwi_size = ((n * WIDE_INT_MAX_HWIS (prec) - 1)
 		       * sizeof (HOST_WIDE_INT));
   unsigned len_size = n;
@@ -428,7 +437,7 @@ irange_storage::dump () const
   int i, j;
 
   fprintf (stderr, "  lengths = [ ");
-  for (i = 0; i < m_num_ranges * 2 + 1; ++i)
+  for (i = 0; i < m_num_ranges * 2 + 2; ++i)
     fprintf (stderr, "%d ", len[i]);
   fprintf (stderr, "]\n");
 
@@ -443,8 +452,13 @@ irange_storage::dump () const
 		 *val++);
       ++len;
     }
+
+  // Dump value/mask pair.
+  for (j = 0; j < *len; ++j)
+    fprintf (stderr, "  [VALUE] " HOST_WIDE_INT_PRINT_DEC "\n", *val++);
+  ++len;
   for (j = 0; j < *len; ++j)
-    fprintf (stderr, "  [NZ] " HOST_WIDE_INT_PRINT_DEC "\n", *val++);
+    fprintf (stderr, "  [MASK] " HOST_WIDE_INT_PRINT_DEC "\n", *val++);
 }
 
 DEBUG_FUNCTION void

gcc/value-range-storage.h

@@ -91,7 +91,7 @@ class irange_storage : public vrange_storage
 
   enum value_range_kind m_kind : 3;
 
-  // The length of this is m_num_ranges * 2 + 1 to accomodate the nonzero bits.
+  // The length of this is m_num_ranges * 2 + 2 to accomodate the bitmask.
   HOST_WIDE_INT m_val[1];
 
   // Another variable-length part of the structure following the HWIs.