define isnan as macro for platform use core\sahred\platform\common\math.c

TianlongLiang · TianlongLiang · commit cfce0b7a9c5d · 2025-09-09T17:41:30.000+08:00
diff --git a/core/iwasm/aot/aot_intrinsic.c b/core/iwasm/aot/aot_intrinsic.c
@@ -128,7 +128,7 @@ aot_intrinsic_sqrt_f64(float64 a)
 float32
 aot_intrinsic_copysign_f32(float32 a, float32 b)
 {
-    return signbitf(b) ? -fabsf(a) : fabsf(a);
+    return signbit(b) ? -fabsf(a) : fabsf(a);
 }
 
 float64
@@ -140,10 +140,10 @@ aot_intrinsic_copysign_f64(float64 a, float64 b)
 float32
 aot_intrinsic_fmin_f32(float32 a, float32 b)
 {
-    if (isnanf(a) || isnanf(b))
+    if (isnan(a) || isnan(b))
         return NAN;
     else if (a == 0 && a == b)
-        return signbitf(a) ? a : b;
+        return signbit(a) ? a : b;
     else
         return a > b ? b : a;
 }
@@ -162,10 +162,10 @@ aot_intrinsic_fmin_f64(float64 a, float64 b)
 float32
 aot_intrinsic_fmax_f32(float32 a, float32 b)
 {
-    if (isnanf(a) || isnanf(b))
+    if (isnan(a) || isnan(b))
         return NAN;
     else if (a == 0 && a == b)
-        return signbitf(a) ? b : a;
+        return signbit(a) ? b : a;
     else
         return a > b ? a : b;
 }
@@ -383,10 +383,10 @@ aot_intrinsic_f32_cmp(AOTFloatCond cond, float32 lhs, float32 rhs)
             return lhs >= rhs ? 1 : 0;
 
         case FLOAT_NE:
-            return (isnanf(lhs) || isnanf(rhs) || lhs != rhs) ? 1 : 0;
+            return (isnan(lhs) || isnan(rhs) || lhs != rhs) ? 1 : 0;
 
         case FLOAT_UNO:
-            return (isnanf(lhs) || isnanf(rhs)) ? 1 : 0;
+            return (isnan(lhs) || isnan(rhs)) ? 1 : 0;
 
         default:
             break;
diff --git a/core/iwasm/common/wasm_application.c b/core/iwasm/common/wasm_application.c
@@ -454,7 +454,7 @@ execute_func(WASMModuleInstanceCommon *module_inst, const char *name,
             case VALUE_TYPE_F32:
             {
                 float32 f32 = strtof(argv[i], &endptr);
-                if (isnanf(f32)) {
+                if (isnan(f32)) {
 #ifdef _MSC_VER
                     /*
                      * Spec tests require the binary representation of NaN to be
diff --git a/core/iwasm/compilation/aot_emit_const.c b/core/iwasm/compilation/aot_emit_const.c
@@ -79,7 +79,7 @@ aot_compile_op_f32_const(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
         }
         PUSH_F32(value);
     }
-    else if (!isnanf(f32_const)) {
+    else if (!isnan(f32_const)) {
         value = F32_CONST(f32_const);
         CHECK_LLVM_CONST(value);
         PUSH_F32(value);
diff --git a/core/iwasm/fast-jit/fe/jit_emit_compare.c b/core/iwasm/fast-jit/fe/jit_emit_compare.c
@@ -117,7 +117,7 @@ jit_compile_op_i64_compare(JitCompContext *cc, IntCond cond)
 static int32
 float_cmp_eq(float f1, float f2)
 {
-    if (isnanf(f1) || isnanf(f2))
+    if (isnan(f1) || isnan(f2))
         return 0;
 
     return f1 == f2;
@@ -126,7 +126,7 @@ float_cmp_eq(float f1, float f2)
 static int32
 float_cmp_ne(float f1, float f2)
 {
-    if (isnanf(f1) || isnanf(f2))
+    if (isnan(f1) || isnan(f2))
         return 1;
 
     return f1 != f2;
diff --git a/core/iwasm/fast-jit/fe/jit_emit_conversion.c b/core/iwasm/fast-jit/fe/jit_emit_conversion.c
@@ -45,7 +45,7 @@ local_isnan(double x)
 static int
 local_isnanf(float x)
 {
-    return isnanf(x);
+    return isnan(x);
 }
 
 #define RETURN_IF_NANF(fp)  \
@@ -198,7 +198,7 @@ jit_compile_check_value_range(JitCompContext *cc, JitReg value, JitReg min_fp,
         float min_fp_f32_const = jit_cc_get_const_F32(cc, min_fp);
         float max_fp_f32_const = jit_cc_get_const_F32(cc, max_fp);
 
-        if (isnanf(value_f32_const)) {
+        if (isnan(value_f32_const)) {
             /* throw exception if value is nan */
             if (!jit_emit_exception(cc, EXCE_INVALID_CONVERSION_TO_INTEGER,
                                     JIT_OP_JMP, 0, NULL))
diff --git a/core/iwasm/fast-jit/fe/jit_emit_numberic.c b/core/iwasm/fast-jit/fe/jit_emit_numberic.c
@@ -1541,21 +1541,21 @@ jit_compile_op_f64_math(JitCompContext *cc, FloatMath math_op)
 static float32
 f32_min(float32 a, float32 b)
 {
-    if (isnanf(a) || isnanf(b))
+    if (isnan(a) || isnan(b))
         return NAN;
     else if (a == 0 && a == b)
-        return signbitf(a) ? a : b;
+        return signbit(a) ? a : b;
     else
         return a > b ? b : a;
 }
 
 static float32
 f32_max(float32 a, float32 b)
 {
-    if (isnanf(a) || isnanf(b))
+    if (isnan(a) || isnan(b))
         return NAN;
     else if (a == 0 && a == b)
-        return signbitf(a) ? b : a;
+        return signbit(a) ? b : a;
     else
         return a > b ? a : b;
 }
diff --git a/core/iwasm/interpreter/wasm_interp_classic.c b/core/iwasm/interpreter/wasm_interp_classic.c
@@ -200,21 +200,21 @@ rotr64(uint64 n, uint64 c)
 static inline float32
 f32_min(float32 a, float32 b)
 {
-    if (isnanf(a) || isnanf(b))
+    if (isnan(a) || isnan(b))
         return NAN;
     else if (a == 0 && a == b)
-        return signbitf(a) ? a : b;
+        return signbit(a) ? a : b;
     else
         return a > b ? b : a;
 }
 
 static inline float32
 f32_max(float32 a, float32 b)
 {
-    if (isnanf(a) || isnanf(b))
+    if (isnan(a) || isnan(b))
         return NAN;
     else if (a == 0 && a == b)
-        return signbitf(a) ? b : a;
+        return signbit(a) ? b : a;
     else
         return a > b ? a : b;
 }
@@ -882,8 +882,8 @@ wasm_interp_get_frame_ref(WASMInterpFrame *frame)
         return dst_value;                                                    \
     }
 
-TRUNC_FUNCTION(trunc_f32_to_i32, float32, uint32, int32, isnanf)
-TRUNC_FUNCTION(trunc_f32_to_i64, float32, uint64, int64, isnanf)
+TRUNC_FUNCTION(trunc_f32_to_i32, float32, uint32, int32, isnan)
+TRUNC_FUNCTION(trunc_f32_to_i64, float32, uint64, int64, isnan)
 TRUNC_FUNCTION(trunc_f64_to_i32, float64, uint32, int32, isnan)
 TRUNC_FUNCTION(trunc_f64_to_i64, float64, uint64, int64, isnan)
 
@@ -896,7 +896,7 @@ trunc_f32_to_int(WASMModuleInstance *module, uint32 *frame_sp, float32 src_min,
     uint32 dst_value_i32;
 
     if (!saturating) {
-        if (isnanf(src_value)) {
+        if (isnan(src_value)) {
             wasm_set_exception(module, "invalid conversion to integer");
             return false;
         }
diff --git a/core/iwasm/interpreter/wasm_interp_fast.c b/core/iwasm/interpreter/wasm_interp_fast.c
@@ -141,21 +141,21 @@ rotr64(uint64 n, uint64 c)
 static inline float32
 f32_min(float32 a, float32 b)
 {
-    if (isnanf(a) || isnanf(b))
+    if (isnan(a) || isnan(b))
         return NAN;
     else if (a == 0 && a == b)
-        return signbitf(a) ? a : b;
+        return signbit(a) ? a : b;
     else
         return a > b ? b : a;
 }
 
 static inline float32
 f32_max(float32 a, float32 b)
 {
-    if (isnanf(a) || isnanf(b))
+    if (isnan(a) || isnan(b))
         return NAN;
     else if (a == 0 && a == b)
-        return signbitf(a) ? b : a;
+        return signbit(a) ? b : a;
     else
         return a > b ? a : b;
 }
@@ -740,8 +740,8 @@ wasm_interp_get_frame_ref(WASMInterpFrame *frame)
         return dst_value;                                                    \
     }
 
-TRUNC_FUNCTION(trunc_f32_to_i32, float32, uint32, int32, isnanf)
-TRUNC_FUNCTION(trunc_f32_to_i64, float32, uint64, int64, isnanf)
+TRUNC_FUNCTION(trunc_f32_to_i32, float32, uint32, int32, isnan)
+TRUNC_FUNCTION(trunc_f32_to_i64, float32, uint64, int64, isnan)
 TRUNC_FUNCTION(trunc_f64_to_i32, float64, uint32, int32, isnan)
 TRUNC_FUNCTION(trunc_f64_to_i64, float64, uint64, int64, isnan)
 
@@ -755,7 +755,7 @@ trunc_f32_to_int(WASMModuleInstance *module, uint8 *frame_ip, uint32 *frame_lp,
     uint32 dst_value_i32;
 
     if (!saturating) {
-        if (isnanf(src_value)) {
+        if (isnan(src_value)) {
             wasm_set_exception(module, "invalid conversion to integer");
             return false;
         }
diff --git a/core/shared/platform/alios/platform_internal.h b/core/shared/platform/alios/platform_internal.h
@@ -66,10 +66,12 @@ float fmaxf(float x, float y);
 float rintf(float x);
 float fabsf(float x);
 float truncf(float x);
-int signbit(double x);
-int signbitf(float x);
-int isnan(double x);
-int isnanf(float x);
+int isnan_double(double x);
+int isnan_float(float x);
+int signbit_double(double x);
+int signbit_float(float x);
+#define isnan(x) (sizeof(x) == sizeof(double) ? isnan_double((double)x) : isnan_float(x))
+#define signbit(x) (sizeof(x) == sizeof(double) ? signbit_double((double)x) : signbit_float(x))
 /* clang-format on */
 
 /* The below types are used in platform_api_extension.h,
diff --git a/core/shared/platform/common/math/math.c b/core/shared/platform/common/math/math.c
@@ -330,6 +330,11 @@ typedef union {
     } while (0)
 #endif
 
+#define isnan(x) \
+    (sizeof(x) == sizeof(double) ? isnan_double((double)x) : isnan_float(x))
+#define signbit(x) \
+    (sizeof(x) == sizeof(double) ? signbit_double((double)x) : signbit_float(x))
+
 #ifdef __FDLIBM_STDC__
 static const double huge = 1.0e300;
 #else
@@ -1616,13 +1621,13 @@ fabs(double x)
 }
 
 int
-isnanf(float x)
+isnan_float(float x)
 {
     return freebsd_isnanf(x);
 }
 
 int
-isnan(double x)
+isnan_double(double x)
 {
     return freebsd_isnan(x);
 }
@@ -1634,17 +1639,17 @@ trunc(double x)
 }
 
 int
-signbit(double x)
+signbit_float(float x)
 {
-    return ((__HI(x) & 0x80000000) >> 31);
+    unsigned int i;
+    GET_FLOAT_WORD(i, x);
+    return (int)(i >> 31);
 }
 
 int
-signbitf(float x)
+signbit_double(double x)
 {
-    unsigned int i;
-    GET_FLOAT_WORD(i, x);
-    return (int)(i >> 31);
+    return ((__HI(x) & 0x80000000) >> 31);
 }
 
 float
diff --git a/core/shared/platform/include/platform_common.h b/core/shared/platform/include/platform_common.h
@@ -197,15 +197,6 @@ typedef void *(*thread_start_routine_t)(void *);
 #define NAN (0.0 / 0.0)
 #endif
 
-/* add isnanf and signbitf macros, map them to existing double version when
- * float versions are absent */
-#ifndef signbitf
-#define signbitf signbit
-#endif
-#ifndef isnanf
-#define isnanf isnan
-#endif
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/core/shared/platform/linux/platform_internal.h b/core/shared/platform/linux/platform_internal.h
@@ -122,9 +122,6 @@ os_sigreturn();
 void
 os_set_signal_number_for_blocking_op(int signo);
 
-int
-signbitf(float x);
-
 typedef int os_file_handle;
 typedef DIR *os_dir_stream;
 typedef int os_raw_file_handle;
diff --git a/core/shared/platform/riot/platform_internal.h b/core/shared/platform/riot/platform_internal.h
@@ -86,10 +86,12 @@ float fmaxf(float x, float y);
 float rintf(float x);
 float fabsf(float x);
 float truncf(float x);
-int signbit(double x);
-int signbitf(float x);
-int isnan(double x);
-int isnanf(float x);
+int isnan_double(double x);
+int isnan_float(float x);
+int signbit_double(double x);
+int signbit_float(float x);
+#define isnan(x) (sizeof(x) == sizeof(double) ? isnan_double((double)x) : isnan_float(x))
+#define signbit(x) (sizeof(x) == sizeof(double) ? signbit_double((double)x) : signbit_float(x))
 /* clang-format on */
 #endif
 
diff --git a/core/shared/platform/zephyr/platform_internal.h b/core/shared/platform/zephyr/platform_internal.h
@@ -189,14 +189,16 @@ float fmaxf(float x, float y);
 float rintf(float x);
 float fabsf(float x);
 float truncf(float x);
-int isnan(double x);
-int isnanf(float x);
+int isnan_double(double x);
+int isnan_float(float x);
+#define isnan(x) (sizeof(x) == sizeof(double) ? isnan_double((double)x) : isnan_float(x))
 double pow(double x, double y);
 double scalbn(double x, int n);
 
 #ifndef BH_HAS_SIGNBIT
-int signbit(double x);
-int signbitf(float x);
+int signbit_double(double x);
+int signbit_float(float x);
+#define signbit(x) (sizeof(x) == sizeof(double) ? signbit_double((double)x) : signbit_float(x))
 #endif
 
 unsigned long long int strtoull(const char *nptr, char **endptr, int base);
diff --git a/tests/unit/aot/aot_test.cc b/tests/unit/aot/aot_test.cc
@@ -1014,10 +1014,10 @@ TEST_F(AOTTest, aot_intrinsic_f32_cmp)
                 res = (lhs >= rhs ? 1 : 0);
                 break;
             case FLOAT_NE: // 1
-                res = (isnanf(lhs) || isnanf(rhs) || lhs != rhs) ? 1 : 0;
+                res = (isnan(lhs) || isnan(rhs) || lhs != rhs) ? 1 : 0;
                 break;
             case FLOAT_UNO: // 6
-                res = (isnanf(lhs) || isnanf(rhs)) ? 1 : 0;
+                res = (isnan(lhs) || isnan(rhs)) ? 1 : 0;
                 break;
 
             default:

Original file line number	Diff line number	Diff line change
`@@ -454,7 +454,7 @@ execute_func(WASMModuleInstanceCommon module_inst, const char name,`
`454`	`454`	`case VALUE_TYPE_F32:`
`455`	`455`	`{`
`456`	`456`	`float32 f32 = strtof(argv[i], &endptr);`
`457`		`- if (isnanf(f32)) {`
	`457`	`+ if (isnan(f32)) {`
`458`	`458`	`#ifdef _MSC_VER`
`459`	`459`	`/*`
`460`	`460`	`* Spec tests require the binary representation of NaN to be`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ aot_compile_op_f32_const(AOTCompContext comp_ctx, AOTFuncContext func_ctx,`
`79`	`79`	`}`
`80`	`80`	`PUSH_F32(value);`
`81`	`81`	`}`
`82`		`- else if (!isnanf(f32_const)) {`
	`82`	`+ else if (!isnan(f32_const)) {`
`83`	`83`	`value = F32_CONST(f32_const);`
`84`	`84`	`CHECK_LLVM_CONST(value);`
`85`	`85`	`PUSH_F32(value);`
Original file line number	Diff line number	Diff line change
`@@ -330,6 +330,11 @@ typedef union {`
`330`	`330`	`} while (0)`
`331`	`331`	`#endif`
`332`	`332`
	`333`	`+#define isnan(x) \`
	`334`	`+ (sizeof(x) == sizeof(double) ? isnan_double((double)x) : isnan_float(x))`
	`335`	`+#define signbit(x) \`
	`336`	`+ (sizeof(x) == sizeof(double) ? signbit_double((double)x) : signbit_float(x))`
	`337`	`+`
`333`	`338`	`#ifdef __FDLIBM_STDC__`
`334`	`339`	`static const double huge = 1.0e300;`
`335`	`340`	`#else`
`@@ -1616,13 +1621,13 @@ fabs(double x)`
`1616`	`1621`	`}`
`1617`	`1622`
`1618`	`1623`	`int`
`1619`		`-isnanf(float x)`
	`1624`	`+isnan_float(float x)`
`1620`	`1625`	`{`
`1621`	`1626`	`return freebsd_isnanf(x);`
`1622`	`1627`	`}`
`1623`	`1628`
`1624`	`1629`	`int`
`1625`		`-isnan(double x)`
	`1630`	`+isnan_double(double x)`
`1626`	`1631`	`{`
`1627`	`1632`	`return freebsd_isnan(x);`
`1628`	`1633`	`}`
`@@ -1634,17 +1639,17 @@ trunc(double x)`
`1634`	`1639`	`}`
`1635`	`1640`
`1636`	`1641`	`int`
`1637`		`-signbit(double x)`
	`1642`	`+signbit_float(float x)`
`1638`	`1643`	`{`
`1639`		`- return ((__HI(x) & 0x80000000) >> 31);`
	`1644`	`+ unsigned int i;`
	`1645`	`+ GET_FLOAT_WORD(i, x);`
	`1646`	`+ return (int)(i >> 31);`
`1640`	`1647`	`}`
`1641`	`1648`
`1642`	`1649`	`int`
`1643`		`-signbitf(float x)`
	`1650`	`+signbit_double(double x)`
`1644`	`1651`	`{`
`1645`		`- unsigned int i;`
`1646`		`- GET_FLOAT_WORD(i, x);`
`1647`		`- return (int)(i >> 31);`
	`1652`	`+ return ((__HI(x) & 0x80000000) >> 31);`
`1648`	`1653`	`}`
`1649`	`1654`
`1650`	`1655`	`float`