py/obj: Fix nan handling in REPR_C and REPR_D.

yoctopuce · yoctopuce · commit a90379e6d1a9 · 2025-06-19T20:59:49.000+02:00
CPython math.nan is positive with regards to copysign.
The signaling bit (aka sign flag) was incorrectly set.

In addition, REPR_C and REPR_D should only use the
_true_ nan to prevent system crash in case of
hand-crafted floats. For instance, with REPR_C,
any nan-like float following the pattern
`01111111 1xxxxxxx xxxxxxxx xxxxx1xx` would be
switched to an immediate object or a qstr string.
When the qstr index is too large, this would cause
a crash.

This commit fixes the issue, and adds the relevant test cases.

Signed-off-by: Yoctopuce dev &lt;dev@yoctopuce.com&gt;
diff --git a/ports/windows/mpconfigport.h b/ports/windows/mpconfigport.h
@@ -266,6 +266,11 @@ typedef long mp_off_t;
 #endif
 #endif
 
+// VC++ 2017 fixes
+#if (_MSC_VER < 1920)
+#define MICROPY_PY_MATH_COPYSIGN_FIX_NAN (1)
+#endif
+
 // CL specific definitions
 
 #ifndef __cplusplus
diff --git a/py/modmath.c b/py/modmath.c
@@ -161,6 +161,11 @@ MATH_FUN_2(atan2, atan2)
 MATH_FUN_1_TO_INT(ceil, ceil)
 // copysign(x, y)
 static mp_float_t MICROPY_FLOAT_C_FUN(copysign_func)(mp_float_t x, mp_float_t y) {
+    #if MICROPY_PY_MATH_COPYSIGN_FIX_NAN
+    if (isnan(y)) {
+        y = 0.0;
+    }
+    #endif
     return MICROPY_FLOAT_C_FUN(copysign)(x, y);
 }
 MATH_FUN_2(copysign, copysign_func)
diff --git a/py/obj.h b/py/obj.h
@@ -184,6 +184,7 @@ static inline bool mp_obj_is_small_int(mp_const_obj_t o) {
 #define MP_OBJ_NEW_SMALL_INT(small_int) ((mp_obj_t)((((mp_uint_t)(small_int)) << 1) | 1))
 
 #if MICROPY_PY_BUILTINS_FLOAT
+#include <math.h>
 #define MP_OBJ_NEW_CONST_FLOAT(f) MP_ROM_PTR((mp_obj_t)((((((uint64_t)f) & ~3) | 2) + 0x80800000) & 0xffffffff))
 #define mp_const_float_e  MP_OBJ_NEW_CONST_FLOAT(0x402df854)
 #define mp_const_float_pi MP_OBJ_NEW_CONST_FLOAT(0x40490fdb)
@@ -203,14 +204,18 @@ static inline mp_float_t mp_obj_float_get(mp_const_obj_t o) {
     union {
         mp_float_t f;
         mp_uint_t u;
-    } num = {.u = ((mp_uint_t)o - 0x80800000u) & ~3u};
+    } num = {.u = ((mp_uint_t)o - 0x80800000u) };
     return num.f;
 }
 static inline mp_obj_t mp_obj_new_float(mp_float_t f) {
     union {
         mp_float_t f;
         mp_uint_t u;
     } num = {.f = f};
+    if (isnan(f)) {
+        // prevent creation of bad nanboxed pointers via array.array or struct
+        return (mp_obj_t)((((uint64_t)0xffc00000 & ~0x3u) | 2u) + 0x80800000u);
+    }
     return (mp_obj_t)(((num.u & ~0x3u) | 2u) + 0x80800000u);
 }
 #endif
@@ -257,12 +262,15 @@ static inline bool mp_obj_is_immediate_obj(mp_const_obj_t o) {
 #error MICROPY_OBJ_REPR_D requires MICROPY_FLOAT_IMPL_DOUBLE
 #endif
 
+#include <math.h>
+#define mp_obj_true_nan ((mp_obj_t)((uint64_t)0x7ff8000000000000 + 0x8004000000000000))
+
 #define mp_const_float_e {((mp_obj_t)((uint64_t)0x4005bf0a8b145769 + 0x8004000000000000))}
 #define mp_const_float_pi {((mp_obj_t)((uint64_t)0x400921fb54442d18 + 0x8004000000000000))}
 #if MICROPY_PY_MATH_CONSTANTS
 #define mp_const_float_tau {((mp_obj_t)((uint64_t)0x401921fb54442d18 + 0x8004000000000000))}
 #define mp_const_float_inf {((mp_obj_t)((uint64_t)0x7ff0000000000000 + 0x8004000000000000))}
-#define mp_const_float_nan {((mp_obj_t)((uint64_t)0xfff8000000000000 + 0x8004000000000000))}
+#define mp_const_float_nan {mp_obj_true_nan}
 #endif
 
 static inline bool mp_obj_is_float(mp_const_obj_t o) {
@@ -276,6 +284,10 @@ static inline mp_float_t mp_obj_float_get(mp_const_obj_t o) {
     return num.f;
 }
 static inline mp_obj_t mp_obj_new_float(mp_float_t f) {
+    if (isnan(f)) {
+        // prevent creation of bad nanboxed pointers via array.array or struct
+        return mp_obj_true_nan;
+    }
     union {
         mp_float_t f;
         uint64_t r;
diff --git a/tests/float/float_array.py b/tests/float/float_array.py
@@ -19,4 +19,10 @@ def test(a):
 test(array("f"))
 test(array("d"))
 
-print("{:.4f}".format(array("f", bytes(array("I", [0x3DCCCCCC])))[0]))
+# hand-crafter floats, including non-standard nan
+for _ in (0x3DCCCCCC, 0x7F800024, 0x7FC00004):
+    f = array("f", bytes(array("I", [_])))[0]
+    if type(f) is float:
+        print("{:.4e}".format(f))
+    else:
+        print(f)
diff --git a/tests/float/math_constants_extra.py b/tests/float/math_constants_extra.py
@@ -9,9 +9,12 @@
     raise SystemExit
 
 print(math.tau == 2.0 * math.pi)
+print(math.copysign(1.0, math.tau))
 
 print(math.inf == float("inf"))
 print(-math.inf == -float("inf"))
+print(math.copysign(1.0, math.inf))
 
 print(isnan(math.nan))
 print(isnan(-math.nan))
+print(math.copysign(1.0, math.nan))
