ipa-cp: Fix up ipcp_print_widest_int

On Mon, Mar 31, 2025 at 03:34:07PM +0200, Martin Jambor wrote:
> This patch just introduces a form of dumping of widest ints that only
> have zeros in the lowest 128 bits so that instead of printing
> thousands of f's the output looks like:
>
>        Bits: value = 0xffff, mask = all ones folled by 0xffffffffffffffffffffffffffff0000
>
> and then makes sure we use the function not only to print bits but
> also to print masks where values like these can also occur.

Shouldn't that be followed by instead?
And the widest_int checks seems to be quite expensive (especially for
large widest_ints), I think for the first one we can just == -1
and for the second one wi::arshift (value, 128) == -1 and the zero extension
by using wi::zext.

Anyway, I wonder if it wouldn't be better to use something shorter,
the variant patch uses 0xf..f prefix before the 128-bit hexadecimal
number (maybe we could also special case the even more common bits 64+
are all ones case).  Or it could be 0xf*f prefix.  Or printing such
numbers as -0x prefixed negative, though that is not a good idea for masks.

This version doesn't print e.g.
0xf..fffffffffffffffffffffffffffff0000
but just
0xf..f0000
(of course, for say mask of
0xf..f0000000000000000000000000000ffff
it prints it like that, doesn't try to shorten the 0 digits.
But if the most significant bits aren't set, it will be just
0xffff.

2025-04-15  Jakub Jelinek  <jakub@redhat.com>

	* ipa-cp.cc (ipcp_print_widest_int): Print values with all ones in
	bits 128+ with "0xf..f" prefix instead of "all ones folled by ".
	Simplify wide_int check for -1 or all ones above least significant
	128 bits.

diff --git a/gcc/ipa-cp.cc b/gcc/ipa-cp.cc
index 26b1496f29bb9d530ea60bbed11d1f02a8d240e9..379fbc5dd63793701334d6e628358e4e7a4e6a24 100644 (file)
--- a/gcc/ipa-cp.cc
+++ b/gcc/ipa-cp.cc
@@ -313,14 +313,24 @@ ipcp_lattice<valtype>::print (FILE * f, bool dump_sources, bool dump_benefits)
 static void
 ipcp_print_widest_int (FILE *f, const widest_int &value)
 {
-  if (wi::eq_p (wi::bit_not (value), 0))
+  if (value == -1)
     fprintf (f, "-1");
-  else if (wi::eq_p (wi::bit_not (wi::bit_or (value,
-                                             wi::sub (wi::lshift (1, 128),
-                                                      1))), 0))
-    {
-      fprintf (f, "all ones folled by ");
-      print_hex (wi::bit_and (value, wi::sub (wi::lshift (1, 128), 1)), f);
+  else if (wi::arshift (value, 128) == -1)
+    {
+      char buf[35], *p = buf + 2;
+      widest_int v = wi::zext (value, 128);
+      size_t len;
+      print_hex (v, buf);
+      len = strlen (p);
+      if (len == 32)
+       {
+         fprintf (f, "0xf..f");
+         while (*p == 'f')
+           ++p;
+       }
+      else
+       fprintf (f, "0xf..f%0*d", (int) (32 - len), 0);
+      fputs (p, f);
     }
   else
     print_hex (value, f);