fpu/softfloat: re-factor minmax (89360067) · Commits · SUMMER2020 / students / proj-2021291

fpu/softfloat.c

+120 −107

Original line number	Diff line number	Diff line
		@@ -1663,6 +1663,126 @@ float64 uint16_to_float64(uint16_t a, float_status *status)
		return uint64_to_float64(a, status);
		}

		/* Float Min/Max */
		/* min() and max() functions. These can't be implemented as
		* 'compare and pick one input' because that would mishandle
		* NaNs and +0 vs -0.
		*
		* minnum() and maxnum() functions. These are similar to the min()
		* and max() functions but if one of the arguments is a QNaN and
		* the other is numerical then the numerical argument is returned.
		* SNaNs will get quietened before being returned.
		* minnum() and maxnum correspond to the IEEE 754-2008 minNum()
		* and maxNum() operations. min() and max() are the typical min/max
		* semantics provided by many CPUs which predate that specification.
		*
		* minnummag() and maxnummag() functions correspond to minNumMag()
		* and minNumMag() from the IEEE-754 2008.
		*/
		static FloatParts minmax_floats(FloatParts a, FloatParts b, bool ismin,
		bool ieee, bool ismag, float_status *s)
		{
		if (unlikely(is_nan(a.cls) \|\| is_nan(b.cls))) {
		if (ieee) {
		/* Takes two floating-point values `a' and `b', one of
		* which is a NaN, and returns the appropriate NaN
		* result. If either `a' or `b' is a signaling NaN,
		* the invalid exception is raised.
		*/
		if (is_snan(a.cls) \|\| is_snan(b.cls)) {
		return pick_nan(a, b, s);
		} else if (is_nan(a.cls) && !is_nan(b.cls)) {
		return b;
		} else if (is_nan(b.cls) && !is_nan(a.cls)) {
		return a;
		}
		}
		return pick_nan(a, b, s);
		} else {
		int a_exp, b_exp;
		bool a_sign, b_sign;

		switch (a.cls) {
		case float_class_normal:
		a_exp = a.exp;
		break;
		case float_class_inf:
		a_exp = INT_MAX;
		break;
		case float_class_zero:
		a_exp = INT_MIN;
		break;
		default:
		g_assert_not_reached();
		break;
		}
		switch (b.cls) {
		case float_class_normal:
		b_exp = b.exp;
		break;
		case float_class_inf:
		b_exp = INT_MAX;
		break;
		case float_class_zero:
		b_exp = INT_MIN;
		break;
		default:
		g_assert_not_reached();
		break;
		}

		a_sign = a.sign;
		b_sign = b.sign;
		if (ismag) {
		a_sign = b_sign = 0;
		}

		if (a_sign == b_sign) {
		bool a_less = a_exp < b_exp;
		if (a_exp == b_exp) {
		a_less = a.frac < b.frac;
		}
		return a_sign ^ a_less ^ ismin ? b : a;
		} else {
		return a_sign ^ ismin ? b : a;
		}
		}
		}

		#define MINMAX(sz, name, ismin, isiee, ismag) \
		float ## sz float ## sz ## _ ## name(float ## sz a, float ## sz b, \
		float_status *s) \
		{ \
		FloatParts pa = float ## sz ## _unpack_canonical(a, s); \
		FloatParts pb = float ## sz ## _unpack_canonical(b, s); \
		FloatParts pr = minmax_floats(pa, pb, ismin, isiee, ismag, s); \
		\
		return float ## sz ## _round_pack_canonical(pr, s); \
		}

		MINMAX(16, min, true, false, false)
		MINMAX(16, minnum, true, true, false)
		MINMAX(16, minnummag, true, true, true)
		MINMAX(16, max, false, false, false)
		MINMAX(16, maxnum, false, true, false)
		MINMAX(16, maxnummag, false, true, true)

		MINMAX(32, min, true, false, false)
		MINMAX(32, minnum, true, true, false)
		MINMAX(32, minnummag, true, true, true)
		MINMAX(32, max, false, false, false)
		MINMAX(32, maxnum, false, true, false)
		MINMAX(32, maxnummag, false, true, true)

		MINMAX(64, min, true, false, false)
		MINMAX(64, minnum, true, true, false)
		MINMAX(64, minnummag, true, true, true)
		MINMAX(64, max, false, false, false)
		MINMAX(64, maxnum, false, true, false)
		MINMAX(64, maxnummag, false, true, true)

		#undef MINMAX

		/* Multiply A by 2 raised to the power N. */
		static FloatParts scalbn_decomposed(FloatParts a, int n, float_status *s)
		{
		@@ -6912,113 +7032,6 @@ int float128_compare_quiet(float128 a, float128 b, float_status *status)
		return float128_compare_internal(a, b, 1, status);
		}

		/* min() and max() functions. These can't be implemented as
		* 'compare and pick one input' because that would mishandle
		* NaNs and +0 vs -0.
		*
		* minnum() and maxnum() functions. These are similar to the min()
		* and max() functions but if one of the arguments is a QNaN and
		* the other is numerical then the numerical argument is returned.
		* minnum() and maxnum correspond to the IEEE 754-2008 minNum()
		* and maxNum() operations. min() and max() are the typical min/max
		* semantics provided by many CPUs which predate that specification.
		*
		* minnummag() and maxnummag() functions correspond to minNumMag()
		* and minNumMag() from the IEEE-754 2008.
		*/
		#define MINMAX(s) \
		static inline float ## s float ## s ## _minmax(float ## s a, float ## s b, \
		int ismin, int isieee, \
		int ismag, \
		float_status *status) \
		{ \
		flag aSign, bSign; \
		uint ## s ## _t av, bv, aav, abv; \
		a = float ## s ## _squash_input_denormal(a, status); \
		b = float ## s ## _squash_input_denormal(b, status); \
		if (float ## s ## _is_any_nan(a) \|\| \
		float ## s ## _is_any_nan(b)) { \
		if (isieee) { \
		if (float ## s ## _is_quiet_nan(a, status) && \
		!float ## s ##_is_any_nan(b)) { \
		return b; \
		} else if (float ## s ## _is_quiet_nan(b, status) && \
		!float ## s ## _is_any_nan(a)) { \
		return a; \
		} \
		} \
		return propagateFloat ## s ## NaN(a, b, status); \
		} \
		aSign = extractFloat ## s ## Sign(a); \
		bSign = extractFloat ## s ## Sign(b); \
		av = float ## s ## _val(a); \
		bv = float ## s ## _val(b); \
		if (ismag) { \
		aav = float ## s ## _abs(av); \
		abv = float ## s ## _abs(bv); \
		if (aav != abv) { \
		if (ismin) { \
		return (aav < abv) ? a : b; \
		} else { \
		return (aav < abv) ? b : a; \
		} \
		} \
		} \
		if (aSign != bSign) { \
		if (ismin) { \
		return aSign ? a : b; \
		} else { \
		return aSign ? b : a; \
		} \
		} else { \
		if (ismin) { \
		return (aSign ^ (av < bv)) ? a : b; \
		} else { \
		return (aSign ^ (av < bv)) ? b : a; \
		} \
		} \
		} \
		\
		float ## s float ## s ## _min(float ## s a, float ## s b, \
		float_status *status) \
		{ \
		return float ## s ## _minmax(a, b, 1, 0, 0, status); \
		} \
		\
		float ## s float ## s ## _max(float ## s a, float ## s b, \
		float_status *status) \
		{ \
		return float ## s ## _minmax(a, b, 0, 0, 0, status); \
		} \
		\
		float ## s float ## s ## _minnum(float ## s a, float ## s b, \
		float_status *status) \
		{ \
		return float ## s ## _minmax(a, b, 1, 1, 0, status); \
		} \
		\
		float ## s float ## s ## _maxnum(float ## s a, float ## s b, \
		float_status *status) \
		{ \
		return float ## s ## _minmax(a, b, 0, 1, 0, status); \
		} \
		\
		float ## s float ## s ## _minnummag(float ## s a, float ## s b, \
		float_status *status) \
		{ \
		return float ## s ## _minmax(a, b, 1, 1, 1, status); \
		} \
		\
		float ## s float ## s ## _maxnummag(float ## s a, float ## s b, \
		float_status *status) \
		{ \
		return float ## s ## _minmax(a, b, 0, 1, 1, status); \
		}

		MINMAX(32)
		MINMAX(64)


		floatx80 floatx80_scalbn(floatx80 a, int n, float_status *status)
		{
		flag aSign;

include/fpu/softfloat.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -245,6 +245,12 @@ float16 float16_mul(float16, float16, float_status *status);
		float16 float16_muladd(float16, float16, float16, int, float_status *status);
		float16 float16_div(float16, float16, float_status *status);
		float16 float16_scalbn(float16, int, float_status *status);
		float16 float16_min(float16, float16, float_status *status);
		float16 float16_max(float16, float16, float_status *status);
		float16 float16_minnum(float16, float16, float_status *status);
		float16 float16_maxnum(float16, float16, float_status *status);
		float16 float16_minnummag(float16, float16, float_status *status);
		float16 float16_maxnummag(float16, float16, float_status *status);

		int float16_is_quiet_nan(float16, float_status *status);
		int float16_is_signaling_nan(float16, float_status *status);