bitintlower: Padding bit fixes, part 2 [PR123635]

So, I've tried the (extremely slow) cfarm95 RISCV box and found that my
earlier PR123635 patch actually broke stuff.
First thing I found is that __riscv__ macro I was using in bitintext.h
doesn't exist and fixed that.
I wrote two new tests (88/89, one for a problem I'll talk about later and
one to cover shifts) and fixed one nit in 86/87.  All the testing
has been done on this modified tests and using
make -j8 -k check-gcc RUNTESTFLAGS="dg.exp='*bitint* pr112673.c builtin-stdc-bit-*.c pr112566-2.c pr112511.c pr116588.c pr116003.c pr113693.c pr113602.c flex-array-counted-by-7.c' dg-torture.exp='*bitint* pr116480-2.c pr114312.c pr114121.c' dfp.exp=*bitint* vect.exp='vect-early-break_99-pr113287.c' tree-ssa.exp=pr113735.c"
On pre-r16-8678 source, the FAILs were
FAIL: gcc.dg/torture/bitint-82.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-82.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-83.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-83.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-86.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-86.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-87.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-87.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-88.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-88.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-89.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-89.c   -O2  execution test
i.e. all the bitintext.h tests for padding bits (except bitint-84.c),
plus gcc.dg/bitint-39.c gcc.dg/torture/bitint-37.c tests timing out
(but those timed out due to extremely slow CPU all the time, and are
really large and not padding related, so let's ignore that).
Now, with r16-8678 (i.e. vanilla trunk), the FAILs are
FAIL: gcc.dg/torture/bitint-42.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-42.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-62.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-62.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-66.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-68.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-68.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-79.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-80.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-81.c   -O0  execution test
FAIL: gcc.dg/torture/bitint-81.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-83.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-87.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-88.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-89.c   -O2  execution test
So, I broke some tests (42, 62, 66, 68, 79, 80, 81) and
fixed a few too (82, 86 and at -O0 only 83, 87, 88, 89).

I've debugged the regressions I've caused and the problem is on large/huge
_BitInt bit-field stores, we can't clear any padding bits in those cases,
bit-fields never have paddings (C FE rejects oversized bit-fields and the
padding is used for further fields or is merely structure padding rather
than padding of the bit-field).
The following patch fixes more than that.  There is another problem
(bitint-88.c tries to test that), when we merge some operation (e.g.
addition) of some narrower large/huge _BitInt with sign extension from
it into a wider unsigned _BitInt (e.g. signed _BitInt(513) addition
sign extended into unsigned _BitInt(1025)), the earlier solution for
the extra padding limb doesn't work properly, we do want to sign
extend the bit 512 into bits 513-1024, but the padding bits above
that need to be cleared.  For the limb containing bit 1024 we do it
right, it is sign extension but outside of loop, so should cast the
all zeros or all ones value to unsigned long : 1 and back, but
the limb containing bit 1088 needs to be just zeroed.
And the patch also adds the bitint_ext_full handling to RSHIFT_EXPR
and LSHIFT_EXPR code.
With this, the FAILs on riscv64-linux are
FAIL: gcc.dg/torture/bitint-87.c   -O2  execution test
FAIL: gcc.dg/torture/bitint-89.c   -O2  execution test
which means I need to debug further the multiplication/division/modulo/
casts from float and there is some remaining problem with the shifts.
Plus something not covered yet, the overflow builtins/ubsan (all of +-*).

In any case, because this patch doesn't regress on riscv64-linux any
actual non-padding tests and even these two aren't regressions, I'd
like to commit this patch separately and fix stuff incrementally,
to unbreak the bit-field stores.

2026-04-20  Jakub Jelinek  <jakub@redhat.com>

	PR middle-end/123635
	* gimple-lower-bitint.cc (bitint_precision_kind): Assert the current
	assumptions, that bitint_ext_full for abi_limb_prec > limb_prec is
	supported only when abi_limb_prec is limb_Prec * 2 and it is not
	big endian in that case.
	(bitint_large_huge::lower_mergeable_stmt): Don't set separate_ext
	fir bitint_ext_full for bit-field stores.  Guard the condition
	on an extra limb of padding bits to be extended rather than including
	earlier extensions in that too.  If already sign extending before
	and type is unsigned, set zero_ms_limb instead and later handle it.
	(bitint_large_huge::lower_shift_stmt): Handle bitint_ext_full.

	* gcc.dg/bitintext.h: Use __riscv macro instead of __riscv__.
	* gcc.dg/torture/bitint-86.c: Remove bogus sync_char_short
	effective target.
	* gcc.dg/torture/bitint-87.c: Likewise.
	* gcc.dg/torture/bitint-88.c: New test.
	* gcc.dg/torture/bitint-89.c: New test.

Reviewed-by: Jeffrey Law <jeffrey.law@oss.qualcomm.com>

diff --git a/gcc/gimple-lower-bitint.cc b/gcc/gimple-lower-bitint.cc
index 9bc9adc9720afc7133e901786850782be1f4d1fb..e211faf800195deb9fafb4cc6cc3e8b494ec531a 100644 (file)
--- a/gcc/gimple-lower-bitint.cc
+++ b/gcc/gimple-lower-bitint.cc
@@ -115,6 +115,12 @@ bitint_precision_kind (int prec)
   if (!abi_limb_prec)
     abi_limb_prec
       = GET_MODE_PRECISION (as_a <scalar_int_mode> (info.abi_limb_mode));
+  /* For bitint_ext_full with different limb_mode from abi_limb_mode we
+     currently only support only abi_limb_mode twice the precision of
+     limb_mode, and don't support big endian in that case either.  */
+  gcc_assert (bitint_extended != bitint_ext_full
+             || (abi_limb_prec == 2 * limb_prec
+                 && !bitint_big_endian));
   if (!huge_min_prec)
     {
       if (4 * limb_prec >= MAX_FIXED_MODE_SIZE)
@@ -2877,15 +2883,24 @@ bitint_large_huge::lower_mergeable_stmt (gimple *stmt, tree_code &cmp_code,
     = (prec != (unsigned) TYPE_PRECISION (type)
        && (CEIL ((unsigned) TYPE_PRECISION (type), limb_prec)
           > CEIL (prec, limb_prec)));
+  bool zero_ms_limb = false;
   if (bitint_extended == bitint_ext_full
       && !eq_p
+      && !nlhs
       && abi_limb_prec > limb_prec
       && ((CEIL ((unsigned) TYPE_PRECISION (type), abi_limb_prec)
-          * abi_limb_prec / limb_prec) > CEIL (prec, limb_prec)))
+          * abi_limb_prec / limb_prec)
+         > CEIL ((unsigned) TYPE_PRECISION (type), limb_prec)))
     {
       if (prec == (unsigned) TYPE_PRECISION (type))
-       sext = !TYPE_UNSIGNED (type);
-      separate_ext = true;
+       {
+         sext = !TYPE_UNSIGNED (type);
+         separate_ext = true;
+       }
+      else if (TYPE_UNSIGNED (type) && sext)
+       zero_ms_limb = true;
+      else
+       separate_ext = true;
     }
   unsigned dst_idx_off = 0;
   if (separate_ext && bitint_big_endian)
@@ -3124,7 +3139,10 @@ bitint_large_huge::lower_mergeable_stmt (gimple *stmt, tree_code &cmp_code,
       kind = bitint_precision_kind (type);
       unsigned start = CEIL (prec, limb_prec);
       prec = TYPE_PRECISION (type);
-      if (bitint_extended == bitint_ext_full && abi_limb_prec > limb_prec)
+      if (bitint_extended == bitint_ext_full
+         && !nlhs
+         && !zero_ms_limb
+         && abi_limb_prec > limb_prec)
        {
          prec = CEIL (prec, abi_limb_prec) * abi_limb_prec;
          kind = bitint_precision_kind (prec);
@@ -3289,6 +3307,26 @@ bitint_large_huge::lower_mergeable_stmt (gimple *stmt, tree_code &cmp_code,
            }
        }
     }
+  if (zero_ms_limb)
+    {
+      tree p2 = build_int_cst (sizetype,
+                              CEIL ((unsigned) TYPE_PRECISION (type),
+                                    abi_limb_prec)
+                              * abi_limb_prec / limb_prec - 1);
+      tree l = limb_access (lhs_type, lhs, p2, true);
+      g = gimple_build_assign (l, build_zero_cst (m_limb_type));
+      insert_before (g);
+      if (eh)
+       {
+         maybe_duplicate_eh_stmt (g, stmt);
+         if (eh_pad)
+           {
+             edge e = split_block (gsi_bb (m_gsi), g);
+             m_gsi = gsi_after_labels (e->dest);
+             add_eh_edge (e->src, find_edge (gimple_bb (stmt), eh_pad));
+           }
+       }
+    }
 
   if (gimple_store_p (stmt))
     {
@@ -3784,6 +3822,14 @@ bitint_large_huge::lower_shift_stmt (tree obj, gimple *stmt)
       if (bitint_big_endian)
        g = gimple_build_cond (NE_EXPR, idx, size_zero_node,
                               NULL_TREE, NULL_TREE);
+      else if (bitint_extended == bitint_ext_full
+              && abi_limb_prec > limb_prec)
+       {
+         tree p2 = build_int_cst (sizetype,
+                                  CEIL (prec, abi_limb_prec)
+                                  * abi_limb_prec / limb_prec - 1);
+         g = gimple_build_cond (LE_EXPR, idx_next, p2, NULL_TREE, NULL_TREE);
+       }
       else
        g = gimple_build_cond (LE_EXPR, idx_next, p, NULL_TREE, NULL_TREE);
       insert_before (g);
@@ -3967,7 +4013,60 @@ bitint_large_huge::lower_shift_stmt (tree obj, gimple *stmt)
          insert_before (g);
          v = add_cast (type, v);
          l = limb_access (TREE_TYPE (lhs), obj, idx, true);
-         g = gimple_build_assign (l, add_cast (m_limb_type, v));
+         v = add_cast (m_limb_type, v);
+         g = gimple_build_assign (l, v);
+         insert_before (g);
+         if (bitint_extended == bitint_ext_full
+             && abi_limb_prec > limb_prec
+             && (CEIL (prec, abi_limb_prec) * abi_limb_prec
+                 > CEIL (prec, limb_prec) * limb_prec))
+           {
+             tree p2 = build_int_cst (sizetype,
+                                      CEIL (prec, abi_limb_prec)
+                                      * abi_limb_prec / limb_prec - 1);
+             if (TYPE_UNSIGNED (TREE_TYPE (lhs)))
+               v = build_zero_cst (m_limb_type);
+             else
+               {
+                 g = gimple_build_assign (make_ssa_name (m_limb_type),
+                                          RSHIFT_EXPR, v,
+                                          build_int_cst (unsigned_type_node,
+                                                         limb_prec - 1));
+                 v = gimple_assign_lhs (g);
+                 insert_before (g);
+               }
+             l = limb_access (TREE_TYPE (lhs), obj, p2, true);
+             g = gimple_build_assign (l, v);
+             insert_before (g);
+           }
+       }
+      else if (bitint_extended == bitint_ext_full
+              && abi_limb_prec > limb_prec
+              && (CEIL (prec, abi_limb_prec) * abi_limb_prec
+                  > CEIL (prec, limb_prec) * limb_prec))
+       {
+         m_gsi = gsi_after_labels (edge_false->dest);
+         tree p2 = build_int_cst (sizetype,
+                                  CEIL (prec, abi_limb_prec)
+                                  * abi_limb_prec / limb_prec - 1);
+         tree v;
+         if (TYPE_UNSIGNED (TREE_TYPE (lhs)))
+           v = build_zero_cst (m_limb_type);
+         else
+           {
+             tree l = limb_access (TREE_TYPE (lhs), obj, p, true);
+             v = make_ssa_name (m_limb_type);
+             g = gimple_build_assign (v, l);
+             insert_before (g);
+             g = gimple_build_assign (make_ssa_name (m_limb_type),
+                                      RSHIFT_EXPR, v,
+                                      build_int_cst (unsigned_type_node,
+                                                     limb_prec - 1));
+             v = gimple_assign_lhs (g);
+             insert_before (g);
+           }
+         tree l = limb_access (TREE_TYPE (lhs), obj, p2, true);
+         g = gimple_build_assign (l, v);
          insert_before (g);
        }
     }

diff --git a/gcc/testsuite/gcc.dg/bitintext.h b/gcc/testsuite/gcc.dg/bitintext.h
index 61b976d83196d05c6383d31514dab80d4c340902..fa40e6329fbb2e5385eec71aa1d207bffd40068c 100644 (file)
--- a/gcc/testsuite/gcc.dg/bitintext.h
+++ b/gcc/testsuite/gcc.dg/bitintext.h
@@ -16,7 +16,7 @@ do_copy (void *p, const void *q, __SIZE_TYPE__ r)
 #define CEIL(x,y) (((x) + (y) - 1) / (y))
 
 /* Promote a _BitInt type to include its padding bits.  */
-#if defined (__s390x__) || defined(__arm__) || defined(__riscv__)
+#if defined (__s390x__) || defined(__arm__) || defined(__riscv)
 #define PROMOTED_SIZE(x) sizeof (x)
 #elif defined(__loongarch__)
 #define PROMOTED_SIZE(x) (sizeof (x) > 8 ? CEIL (S (x), 64) * 8 : sizeof (x))
@@ -25,7 +25,7 @@ do_copy (void *p, const void *q, __SIZE_TYPE__ r)
 /* Macro to test whether (on targets where psABI requires it) _BitInt
    with padding bits have those filled with sign or zero extension.  */
 #if defined(__s390x__) || defined(__arm__) || defined(__loongarch__) \
-    || defined(__riscv__)
+    || defined(__riscv)
 #define BEXTC1(x, uns) \
   do {                                                   \
     uns _BitInt(PROMOTED_SIZE (x) * __CHAR_BIT__) __x;   \

diff --git a/gcc/testsuite/gcc.dg/torture/bitint-86.c b/gcc/testsuite/gcc.dg/torture/bitint-86.c
index e198c5060b68aa52d2c1d1c5f1718b8a7967afc9..d19319434fdec0a8ff7d0e4622cc76e6725d432f 100644 (file)
--- a/gcc/testsuite/gcc.dg/torture/bitint-86.c
+++ b/gcc/testsuite/gcc.dg/torture/bitint-86.c
@@ -1,6 +1,5 @@
 /* PR middle-end/123635 */
 /* { dg-do run { target bitint } } */
-/* { dg-require-effective-target sync_char_short } */
 /* { dg-options "-std=c23 -pedantic-errors" } */
 /* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
 /* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */

diff --git a/gcc/testsuite/gcc.dg/torture/bitint-87.c b/gcc/testsuite/gcc.dg/torture/bitint-87.c
index 0ac0ee4ef8c680febe615ab24c97c9101e164e01..8d76f389ea46e7a138eca91161c6d87fc7ebb692 100644 (file)
--- a/gcc/testsuite/gcc.dg/torture/bitint-87.c
+++ b/gcc/testsuite/gcc.dg/torture/bitint-87.c
@@ -1,6 +1,5 @@
 /* PR middle-end/123635 */
 /* { dg-do run { target bitint } } */
-/* { dg-require-effective-target sync_char_short } */
 /* { dg-options "-std=c23 -pedantic-errors" } */
 /* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
 /* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */

diff --git a/gcc/testsuite/gcc.dg/torture/bitint-88.c b/gcc/testsuite/gcc.dg/torture/bitint-88.c
new file mode 100644 (file)
index 0000000..aa34c55
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/bitint-88.c
@@ -0,0 +1,95 @@
+/* PR middle-end/123635 */
+/* { dg-do run { target bitint } } */
+/* { dg-options "-std=c23 -pedantic-errors" } */
+/* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
+/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */
+
+#if __BITINT_MAXWIDTH__ >= 1025
+unsigned _BitInt(513) a, b, c, d;
+_BitInt(513) e, f, g, h;
+unsigned _BitInt(1025) i, j, k, l;
+_BitInt(1025) m, n, o, p;
+#endif
+
+#include "../bitintext.h"
+
+#if __BITINT_MAXWIDTH__ >= 1025
+[[gnu::noipa]] void
+f1 (_BitInt(513) q, _BitInt(513) r, _BitInt(513) s,
+    unsigned _BitInt(513) t, unsigned _BitInt(513) u, unsigned _BitInt(513) v)
+{
+  a = q + r;
+  BEXTC (a);
+  b = r + s;
+  BEXTC (b);
+  c = q - r;
+  BEXTC (c);
+  d = q - s;
+  BEXTC (d);
+  e = t + u;
+  BEXTC (e);
+  f = u + v;
+  BEXTC (f);
+  g = t - u;
+  BEXTC (g);
+  h = t - v;
+  BEXTC (h);
+}
+
+[[gnu::noipa]] void
+f2 (_BitInt(513) q, _BitInt(513) r, _BitInt(513) s,
+    unsigned _BitInt(513) t, unsigned _BitInt(513) u, unsigned _BitInt(513) v)
+{
+  i = q + r;
+  BEXTC (i);
+  j = r + s;
+  BEXTC (j);
+  k = q - r;
+  BEXTC (k);
+  l = q - s;
+  BEXTC (l);
+  m = t + u;
+  BEXTC (m);
+  n = u + v;
+  BEXTC (n);
+  o = t - u;
+  BEXTC (o);
+  p = t - v;
+  BEXTC (p);
+}
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 1025
+  __builtin_memset (&a, 0x55, sizeof (a));
+  __builtin_memset (&b, 0xaa, sizeof (b));
+  __builtin_memset (&c, 0x55, sizeof (c));
+  __builtin_memset (&d, 0xaa, sizeof (d));
+  __builtin_memset (&e, 0x55, sizeof (e));
+  __builtin_memset (&f, 0xaa, sizeof (f));
+  __builtin_memset (&g, 0x55, sizeof (g));
+  __builtin_memset (&h, 0xaa, sizeof (h));
+  f1 (-2639616085193412675089727272130019765984398127278861998378045997173219392866835944828454559654047247059773556852593471531433454810831298259785611283536204wb,
+      -7234121192495298112713936268702056205915537824658323839255206188456944966709752205781440683757949161649123152428620619997014209098183677328840647884700332wb,
+      8654283549227219676537451326576929768614001427323560383705131223498505581982738964879437520020436012891649083646965651378407397436785749860023553778646861wb,
+      15046745594550617619205422464231805109110883864578289024439083517871820578179553927615539526791313634437787081814763432804808038115388367331529035246240655uwb,
+      20633637828717837096174917874088391607464281656818868213468970773994599068609617673436080725569780340050358299419252926775025136778754971701553110169281151uwb,
+      513612209045189503622076474995216606086383139671427104179978688982034117764664711277072795083902951564358998498109412142322138933760173628255697435284781uwb);
+  __builtin_memset (&i, 0x55, sizeof (i));
+  __builtin_memset (&j, 0xaa, sizeof (j));
+  __builtin_memset (&k, 0x55, sizeof (k));
+  __builtin_memset (&l, 0xaa, sizeof (l));
+  __builtin_memset (&m, 0x55, sizeof (m));
+  __builtin_memset (&n, 0xaa, sizeof (n));
+  __builtin_memset (&o, 0x55, sizeof (o));
+  __builtin_memset (&p, 0xaa, sizeof (p));
+  f2 (-2639616085193412675089727272130019765984398127278861998378045997173219392866835944828454559654047247059773556852593471531433454810831298259785611283536204wb,
+      -7234121192495298112713936268702056205915537824658323839255206188456944966709752205781440683757949161649123152428620619997014209098183677328840647884700332wb,
+      8654283549227219676537451326576929768614001427323560383705131223498505581982738964879437520020436012891649083646965651378407397436785749860023553778646861wb,
+      15046745594550617619205422464231805109110883864578289024439083517871820578179553927615539526791313634437787081814763432804808038115388367331529035246240655uwb,
+      20633637828717837096174917874088391607464281656818868213468970773994599068609617673436080725569780340050358299419252926775025136778754971701553110169281151uwb,
+      513612209045189503622076474995216606086383139671427104179978688982034117764664711277072795083902951564358998498109412142322138933760173628255697435284781uwb);
+#endif
+}

diff --git a/gcc/testsuite/gcc.dg/torture/bitint-89.c b/gcc/testsuite/gcc.dg/torture/bitint-89.c
new file mode 100644 (file)
index 0000000..780445d
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/bitint-89.c
@@ -0,0 +1,99 @@
+/* PR middle-end/123635 */
+/* { dg-do run { target bitint } } */
+/* { dg-options "-std=c23 -pedantic-errors" } */
+/* { dg-skip-if "" { ! run_expensive_tests }  { "*" } { "-O0" "-O2" } } */
+/* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */
+
+#if __BITINT_MAXWIDTH__ >= 1025
+_BitInt(513) a, b, c, d;
+unsigned _BitInt(513) e, f, g, h;
+_BitInt(513) i, j, k, l;
+unsigned _BitInt(513) m, n, o, p;
+#endif
+
+#include "../bitintext.h"
+
+#if __BITINT_MAXWIDTH__ >= 1025
+[[gnu::noipa]] void
+f1 (_BitInt(513) q, _BitInt(513) r, _BitInt(513) s,
+    unsigned _BitInt(513) t, unsigned _BitInt(513) u, unsigned _BitInt(513) v,
+    int z)
+{
+  a = q >> 23;
+  BEXTC (a);
+  b = r << 23;
+  BEXTC (b);
+  c = r >> z;
+  BEXTC (c);
+  d = s << z;
+  BEXTC (d);
+  e = t >> 23;
+  BEXTC (e);
+  f = u << 23;
+  BEXTC (f);
+  g = t >> z;
+  BEXTC (g);
+  h = v << z;
+  BEXTC (h);
+}
+
+[[gnu::noipa]] void
+f2 (_BitInt(513) q, _BitInt(513) r, _BitInt(513) s,
+    unsigned _BitInt(513) t, unsigned _BitInt(513) u, unsigned _BitInt(513) v,
+    int z)
+{
+  i = q >> 67;
+  BEXTC (i);
+  j = r << 67;
+  BEXTC (j);
+  k = q >> z;
+  BEXTC (k);
+  l = s << z;
+  BEXTC (l);
+  m = t >> 67;
+  BEXTC (m);
+  n = u << 67;
+  BEXTC (n);
+  o = t >> z;
+  BEXTC (o);
+  p = v << z;
+  BEXTC (p);
+}
+#endif
+
+int
+main ()
+{
+#if __BITINT_MAXWIDTH__ >= 1025
+  __builtin_memset (&a, 0x55, sizeof (a));
+  __builtin_memset (&b, 0xaa, sizeof (b));
+  __builtin_memset (&c, 0x55, sizeof (c));
+  __builtin_memset (&d, 0xaa, sizeof (d));
+  __builtin_memset (&e, 0x55, sizeof (e));
+  __builtin_memset (&f, 0xaa, sizeof (f));
+  __builtin_memset (&g, 0x55, sizeof (g));
+  __builtin_memset (&h, 0xaa, sizeof (h));
+  f1 (-2639616085193412675089727272130019765984398127278861998378045997173219392866835944828454559654047247059773556852593471531433454810831298259785611283536204wb,
+      -7234121192495298112713936268702056205915537824658323839255206188456944966709752205781440683757949161649123152428620619997014209098183677328840647884700332wb,
+      8654283549227219676537451326576929768614001427323560383705131223498505581982738964879437520020436012891649083646965651378407397436785749860023553778646861wb,
+      15046745594550617619205422464231805109110883864578289024439083517871820578179553927615539526791313634437787081814763432804808038115388367331529035246240655uwb,
+      20633637828717837096174917874088391607464281656818868213468970773994599068609617673436080725569780340050358299419252926775025136778754971701553110169281151uwb,
+      513612209045189503622076474995216606086383139671427104179978688982034117764664711277072795083902951564358998498109412142322138933760173628255697435284781uwb,
+      129);
+  __builtin_memset (&i, 0x55, sizeof (i));
+  __builtin_memset (&j, 0xaa, sizeof (j));
+  __builtin_memset (&k, 0x55, sizeof (k));
+  __builtin_memset (&l, 0xaa, sizeof (l));
+  __builtin_memset (&m, 0x55, sizeof (m));
+  __builtin_memset (&n, 0xaa, sizeof (n));
+  __builtin_memset (&o, 0x55, sizeof (o));
+  __builtin_memset (&p, 0xaa, sizeof (p));
+  f2 (2639616085193412675089727272130019765984398127278861998378045997173219392866835944828454559654047247059773556852593471531433454810831298259785611283536204wb,
+      -7234121192495298112713936268702056205915537824658323839255206188456944966709752205781440683757949161649123152428620619997014209098183677328840647884700332wb,
+      -8654283549227219676537451326576929768614001427323560383705131223498505581982738964879437520020436012891649083646965651378407397436785749860023553778646861wb,
+      513612209045189503622076474995216606086383139671427104179978688982034117764664711277072795083902951564358998498109412142322138933760173628255697435284781uwb,
+      20633637828717837096174917874088391607464281656818868213468970773994599068609617673436080725569780340050358299419252926775025136778754971701553110169281151uwb,
+      15046745594550617619205422464231805109110883864578289024439083517871820578179553927615539526791313634437787081814763432804808038115388367331529035246240655uwb,
+      211);
+#endif
+}