gh-130317: fix PyFloat_Pack2/Unpack2 for NaN's with payload

Author: skirpichev

Lib/test/test_struct.py

@@ -935,6 +935,13 @@ def test_half_float(self):
             self.assertTrue(math.isnan(struct.unpack('<e', bits)[0]))
             self.assertTrue(math.isnan(struct.unpack('>e', bits[::-1])[0]))
 
+        # Check round-trip for NaN's:
+        for formatcode, bits in format_bits__nan_list:
+            nan = struct.unpack('<e', bits)[0]
+            self.assertEqual(struct.pack('<e', nan), bits)
+            nan = struct.unpack('>e', bits[::-1])[0]
+            self.assertEqual(struct.pack('>e', nan), bits[::-1])
+
         # Check that packing produces a bit pattern representing a quiet NaN:
         # all exponent bits and the msb of the fraction should all be 1.
         packed = struct.pack('<e', math.nan)

Misc/NEWS.d/next/Library/2025-02-22-13-07-06.gh-issue-130317.tnxd0I.rst

@@ -0,0 +1,4 @@
+Fix :c:func:`PyFloat_Pack2` and :c:func:`PyFloat_Unpack2` for NaN's with
+payload.  This corrects round-trip for :func:`struct.unpack` and
+:func:`struct.pack` in case of the IEEE 754 binary16 "half precision" type.
+Patch by Sergey B Kirpichev.

Objects/floatobject.c

@@ -2048,14 +2048,16 @@ PyFloat_Pack2(double x, char *data, int le)
         bits = 0;
     }
     else if (isnan(x)) {
-        /* There are 2046 distinct half-precision NaNs (1022 signaling and
-           1024 quiet), but there are only two quiet NaNs that don't arise by
-           quieting a signaling NaN; we get those by setting the topmost bit
-           of the fraction field and clearing all other fraction bits. We
-           choose the one with the appropriate sign. */
         sign = (copysign(1.0, x) == -1.0);
         e = 0x1f;
-        bits = 512;
+
+        uint64_t v;
+
+        memcpy(&v, &x, sizeof(v));
+        bits = v & 0x1ff; /* NaN's payload */
+        if (v & 0x8000000000000) { /* is a quiet NaN? */
+            bits += 0x200;
+        }
     }
     else {
         sign = (x < 0.0);
@@ -2401,7 +2403,15 @@ PyFloat_Unpack2(const char *data, int le)
         }
         else {
             /* NaN */
-            return sign ? -fabs(Py_NAN) : fabs(Py_NAN);
+            uint64_t v = sign ? 0xfff0000000000000 : 0x7ff0000000000000;
+
+            if (f & 0x200) { /* is a quiet NaN? */
+                v += 0x8000000000000;
+                f -= 0x200;
+            }
+            v += f; /* add NaN's payload */
+            memcpy(&x, &v, sizeof(v));
+            return x;
         }
     }