fixed autotests, and modified undefined behaviour when converting long double to an integer

Author: ZERICO2005

src/crt/float64_to_int.c

@@ -64,6 +64,16 @@ uint64_t _dtoull_c(long double x) {
 }
 #endif
 
+/**
+ * @brief set to 0 or 1
+ * If set to 1, values that truncate to `INT32_MIN`/`INT64_MIN` will be
+ * handled correctly.
+ * If set to 0, it can save a little bit of space by removing a comparison from
+ * `_dtol_c` and `_dtoll_c`. However this will cause values that would truncate
+ * to `INT32_MIN`/`INT64_MIN` to have an undefined result.
+ */
+#define HANDLE_INT_MIN 1
+
 /**
  * @note val must have the signbit cleared
  */
@@ -92,29 +102,23 @@ static uint64_t f64_to_unsigned(F64_pun val) {
 }
 
 uint64_t _dtoull_c(long double x) {
-    if (signbit(x)) {
-        return 0;
-    }
     F64_pun val;
     val.flt = x;
     /* overflow || signbit(x) || isinf(x) || isnan(x) */
     if (val.reg.BC >= ((Float64_bias + Float64_u64_max_exp) << Float64_exp_BC_shift)) {
-        /* undefined return value for negative/inf/NaN values of x */
-        return UINT64_MAX;
+        /* undefined return value for negative/overflow/inf/NaN of x */
+        return 0;
     }
     return f64_to_unsigned(val);
 }
 
 uint32_t _dtoul_c(long double x) {
-    if (signbit(x)) {
-        return 0;
-    }
     F64_pun val;
     val.flt = x;
     /* overflow || signbit(x) || isinf(x) || isnan(x) */
     if (val.reg.BC >= ((Float64_bias + Float64_u32_max_exp) << Float64_exp_BC_shift)) {
-        /* undefined return value for negative/inf/NaN values of x */
-        return UINT32_MAX;
+        /* undefined return value for negative/overflow/inf/NaN values of x */
+        return 0;
     }
     return (uint32_t)f64_to_unsigned(val);
 }
@@ -126,9 +130,16 @@ int64_t _dtoll_c(long double x) {
 
     /* overflow || isinf(x) || isnan(x) */
     if (val.reg.BC >= ((Float64_bias + Float64_i64_max_exp) << Float64_exp_BC_shift)) {
-        /* undefined return value for inf/NaN values of x */
-        return x_sign ? INT64_MIN : INT64_MAX;
+        #if HANDLE_INT_MIN != 0
+            /* if the value truncates to INT64_MIN */
+            if (x_sign && val.bin == UINT64_C(0x43E0000000000000)) {
+                return INT64_MIN;
+            }
+        #endif
+        /* undefined return value for underflow/overflow/inf/NaN values of x */
+        return 0;
     }
+
     int64_t ret = (int64_t)f64_to_unsigned(val);
     ret = x_sign ? -ret : ret;
     return ret;
@@ -141,8 +152,14 @@ int32_t _dtol_c(long double x) {
 
     /* overflow || isinf(x) || isnan(x) */
     if (val.reg.BC >= ((Float64_bias + Float64_i32_max_exp) << Float64_exp_BC_shift)) {
-        /* undefined return value for inf/NaN values of x */
-        return x_sign ? INT32_MIN : INT32_MAX;
+        #if HANDLE_INT_MIN != 0
+            /* if the value truncates to INT32_MIN */
+            if (x_sign && val.bin <= UINT64_C(0x41E00000001FFFFF)) {
+                return INT32_MIN;
+            }
+        #endif
+        /* undefined return value for underflow/overflow/inf/NaN values of x */
+        return 0;
     }
     int32_t ret = (int32_t)f64_to_unsigned(val);
     ret = x_sign ? -ret : ret;

src/libc/frexpf.c

@@ -69,8 +69,9 @@ float _frexpf_c(float value, int *pExponent)
 
 #else
 
-#include <stdint.h>
+#include <limits.h>
 #include <math.h>
+#include <stdint.h>
 
 typedef union F32_pun {
     float flt;
@@ -97,7 +98,7 @@ float _frexpf_c(float x, int *expon) {
         case FP_INFINITE:
         case FP_NAN: {
             // Unspecified exponent value for inf and NaN
-            *expon = FP_ILOGBNAN;
+            *expon = INT_MAX;
             return val.flt;
         }
         case FP_ZERO: {

src/libc/frexpl.c

@@ -1,3 +1,4 @@
+#include <limits.h>
 #include <math.h>
 #include <stdint.h>
 
@@ -36,7 +37,7 @@ static long double _frexpl_c_positive(long double x, int *expon) {
         /* isinf(x) || isnan(x) */
         if (x_exp == Float64_biased_inf_nan_exp) {
             // Unspecified exponent value for inf and NaN
-            *expon = FP_ILOGBNAN;
+            *expon = INT_MAX;
             return val.flt;
         }
         /* isnormal(x) */

src/softfloat/include/specialize.h

@@ -51,23 +51,23 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | The values to return on conversions to 32-bit integer formats that raise an
 | invalid exception.
 *----------------------------------------------------------------------------*/
-#define ui32_fromPosOverflow 0xFFFFFFFF
-#define ui32_fromNegOverflow 0xFFFFFFFF
-#define ui32_fromNaN         0xFFFFFFFF
-#define i32_fromPosOverflow  (-0x7FFFFFFF - 1)
-#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
-#define i32_fromNaN          (-0x7FFFFFFF - 1)
+#define ui32_fromPosOverflow UINT32_C( 0x0 )
+#define ui32_fromNegOverflow UINT32_C( 0x0 )
+#define ui32_fromNaN         UINT32_C( 0x0 )
+#define i32_fromPosOverflow  INT32_C( 0x0 )
+#define i32_fromNegOverflow  INT32_C( 0x0 )
+#define i32_fromNaN          INT32_C( 0x0 )
 
 /*----------------------------------------------------------------------------
 | The values to return on conversions to 64-bit integer formats that raise an
 | invalid exception.
 *----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
-#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
-#define ui64_fromNaN         UINT64_C( 0xFFFFFFFFFFFFFFFF )
-#define i64_fromPosOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
-#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
-#define i64_fromNaN          (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define ui64_fromPosOverflow UINT64_C( 0x0 )
+#define ui64_fromNegOverflow UINT64_C( 0x0 )
+#define ui64_fromNaN         UINT64_C( 0x0 )
+#define i64_fromPosOverflow  INT64_C( 0x0 )
+#define i64_fromNegOverflow  INT64_C( 0x0 )
+#define i64_fromNaN          INT64_C( 0x0 )
 
 /*----------------------------------------------------------------------------
 | "Common NaN" structure, used to transfer NaN representations from one format