Update libm tests from NetBSD

I did this without a full vendor update since that would cause too many
conflicts. Since these files now almost match the NetBSD sources the
next git subtree merge should work just fine.

Reviewed By:	lwhsu
Differential Revision: https://reviews.freebsd.org/D28797

21 files changed, 944 insertions, 321 deletions

diff --git a/contrib/netbsd-tests/lib/libm/t_acos.c b/contrib/netbsd-tests/lib/libm/t_acos.c
index f051fb64df42..973f0245cdab 100644
--- a/contrib/netbsd-tests/lib/libm/t_acos.c
+++ b/contrib/netbsd-tests/lib/libm/t_acos.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_acos.c,v 1.10 2014/03/05 20:14:46 dsl Exp $ */
+/* $NetBSD: t_acos.c,v 1.11 2018/11/07 03:59:36 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -72,7 +72,7 @@ ATF_LIBM_TEST(acos_inrange, "Test acos/acosf(x) for some valid values")
 		{  0,    M_PI / 2,          },
 		{  0.1,  1.470628905633337, },
 		{  0.5,  1.047197551196598, },
-		{  0.99, 0.141539473324427, },
+		{  0.99, 0.1415394733244273, },
 	};
 	unsigned int i;
 
diff --git a/contrib/netbsd-tests/lib/libm/t_asin.c b/contrib/netbsd-tests/lib/libm/t_asin.c
index 06de85216429..213b1f875439 100644
--- a/contrib/netbsd-tests/lib/libm/t_asin.c
+++ b/contrib/netbsd-tests/lib/libm/t_asin.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_asin.c,v 1.3 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_asin.c,v 1.4 2018/11/07 03:59:36 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -30,6 +30,7 @@
  */
 
 #include <atf-c.h>
+#include <float.h>
 #include <math.h>
 
 static const struct {
@@ -117,13 +118,14 @@ ATF_TC_HEAD(asin_inrange, tc)
 
 ATF_TC_BODY(asin_inrange, tc)
 {
-	const double eps = 1.0e-15;
-	double y;
+	const double eps = DBL_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(values); i++) {
-		y = asin(values[i].x);
-		if (fabs(y - values[i].y) > eps)
+		double x = values[i].x;
+		double y = values[i].y;
+
+		if (!(fabs((asin(x) - y)/y) <= eps))
 			atf_tc_fail_nonfatal("asin(%g) != %g",
 				values[i].x, values[i].y);
 	}
@@ -230,16 +232,25 @@ ATF_TC_HEAD(asinf_inrange, tc)
 
 ATF_TC_BODY(asinf_inrange, tc)
 {
-	const float eps = 1.0e-6;
-	float x;
-	float y;
+	const float eps = FLT_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(values); i++) {
-		x = values[i].x;
-		y = values[i].y;
-		if (fabs(asinf(x) - y) > eps)
-			atf_tc_fail_nonfatal("asinf(%g) != %g", x, y);
+		float x = values[i].x;
+		float y = values[i].y;
+
+#ifdef __NetBSD__
+		if (fabs(x) == 0.5)
+			atf_tc_expect_fail("asinf is busted,"
+			    " gives ~2ulp error");
+#endif
+		if (!(fabsf((asinf(x) - y)/y) <= eps)) {
+			atf_tc_fail_nonfatal("asinf(%.8g) = %.8g != %.8g,"
+			    " error=~%.1fulp",
+			    x, asinf(x), y, fabsf(((asinf(x) - y)/y)/eps));
+		}
+		if (fabs(x) == 0.5)
+			atf_tc_expect_pass();
 	}
 }
 
diff --git a/contrib/netbsd-tests/lib/libm/t_bit.c b/contrib/netbsd-tests/lib/libm/t_bit.c
new file mode 100644
index 000000000000..b6e0218f601c
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libm/t_bit.c
@@ -0,0 +1,102 @@
+/* $NetBSD: t_bit.c,v 1.1 2019/04/26 08:52:16 maya Exp $ */
+
+/*
+ * Written by Maya Rashish <maya@NetBSD.org>
+ * Public domain.
+ *
+ * Testing signbit{,f,l} function correctly
+ */
+
+#include <atf-c.h>
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+static const struct {
+	double input;
+	bool is_negative;
+} values[] = {
+	{ -1,		true},
+	{ -123,		true},
+	{ -123E6,	true},
+#ifdef INFINITY
+	{ -INFINITY,	true},
+	{ INFINITY,	false},
+#endif
+	{ 123E6,	false},
+	{ 0,		false},
+	{ -FLT_MIN,	true},
+	{ FLT_MIN,	false},
+	/* 
+	 * Cannot be accurately represented as float,
+	 * but sign should be preserved
+	 */
+	{ DBL_MAX,	false},
+	{ -DBL_MAX,	true},
+};
+
+#ifdef __HAVE_LONG_DOUBLE
+static const struct {
+	long double input;
+	bool is_negative;
+} ldbl_values[] = {
+	{ -LDBL_MIN,	true},
+	{ LDBL_MIN,	false},
+	{ LDBL_MAX,	false},
+	{ -LDBL_MAX,	true},
+};
+#endif
+
+ATF_TC(signbit);
+ATF_TC_HEAD(signbit, tc)
+{
+	atf_tc_set_md_var(tc, "descr","Check that signbit functions correctly");
+}
+
+ATF_TC_BODY(signbit, tc)
+{
+	double iterator_d;
+	float iterator_f;
+
+	for (unsigned int i = 0; i < __arraycount(values); i++) {
+		iterator_d = values[i].input;
+		iterator_f = (float) values[i].input;
+		if (signbit(iterator_f) != values[i].is_negative)
+			atf_tc_fail("%s:%d iteration %d signbitf is wrong"
+					" about the sign of %f", __func__,
+					__LINE__, i, iterator_f);
+		if (signbit(iterator_d) != values[i].is_negative)
+			atf_tc_fail("%s:%d iteration %d signbit is wrong"
+					"about the sign of %f", __func__,
+					__LINE__,i, iterator_d);
+
+#ifdef __HAVE_LONG_DOUBLE
+		long double iterator_l = values[i].input;
+		if (signbit(iterator_l) != values[i].is_negative)
+			atf_tc_fail("%s:%d iteration %d signbitl is wrong"
+					" about the sign of %Lf", __func__,
+					__LINE__, i, iterator_l);
+#endif
+	}
+
+#ifdef __HAVE_LONG_DOUBLE
+	for (unsigned int i = 0; i < __arraycount(ldbl_values); i++) {
+		if (signbit(ldbl_values[i].input) != ldbl_values[i].is_negative)
+			atf_tc_fail("%s:%d iteration %d signbitl is"
+					"wrong about the sign of %Lf",
+					__func__, __LINE__, i,
+					ldbl_values[i].input);
+	}
+#endif
+
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, signbit);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libm/t_cabsl.cxx b/contrib/netbsd-tests/lib/libm/t_cabsl.cxx
new file mode 100644
index 000000000000..7dd119b1da3b
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libm/t_cabsl.cxx
@@ -0,0 +1,66 @@
+/*-
+ * Copyright (c) 2018 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Maya Rashish
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Test that C++ "cabsl" is usable. PR lib/50646
+ */
+
+#include <atf-c++.hpp>
+#include <complex>
+
+ATF_TEST_CASE(cabsl);
+ATF_TEST_CASE_HEAD(cabsl)
+{
+	set_md_var("descr", "Check that cabsl is usable from C++");
+}
+ATF_TEST_CASE_BODY(cabsl)
+{
+	int sum = 0;
+
+#ifdef __HAVE_LONG_DOUBLE
+	std::complex<long double> cld(3.0,4.0);
+	sum += std::abs(cld);
+#endif
+	std::complex<double> cd(3.0,4.0);
+	sum += std::abs(cd);
+
+	std::complex<float> cf(3.0,4.0);
+	sum += std::abs(cf);
+
+#ifdef __HAVE_LONG_DOUBLE
+	ATF_REQUIRE_EQ(sum, 3*5);
+#else
+	ATF_REQUIRE_EQ(sum, 2*5);
+#endif
+}
+
+ATF_INIT_TEST_CASES(tcs)
+{
+	ATF_ADD_TEST_CASE(tcs, cabsl);
+}
diff --git a/contrib/netbsd-tests/lib/libm/t_cbrt.c b/contrib/netbsd-tests/lib/libm/t_cbrt.c
index 08e9faeb145c..639bc7e06517 100644
--- a/contrib/netbsd-tests/lib/libm/t_cbrt.c
+++ b/contrib/netbsd-tests/lib/libm/t_cbrt.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_cbrt.c,v 1.3 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_cbrt.c,v 1.5 2018/11/15 05:14:20 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,9 +29,10 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_cbrt.c,v 1.3 2014/03/03 10:39:08 martin Exp $");
+__RCSID("$NetBSD: t_cbrt.c,v 1.5 2018/11/15 05:14:20 riastradh Exp $");
 
 #include <atf-c.h>
+#include <float.h>
 #include <math.h>
 #include <stdio.h>
 
@@ -61,18 +62,26 @@ ATF_TC_HEAD(cbrt_pow, tc)
 ATF_TC_BODY(cbrt_pow, tc)
 {
 	const double x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.0 };
-	const double eps = 1.0e-14;
-	double y, z;
+	/* Neither cbrt nor pow is required to be correctly rounded.  */
+	const double eps = 2*DBL_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(x); i++) {
-
-		y = cbrt(x[i]);
-		z = pow(x[i], 1.0 / 3.0);
-
-		if (fabs(y - z) > eps)
-			atf_tc_fail_nonfatal("cbrt(%0.03f) != "
-			    "pow(%0.03f, 1/3)\n", x[i], x[i]);
+		double x_cbrt = cbrt(x[i]);
+		double x_pow13 = pow(x[i], 1.0 / 3.0);
+		bool ok;
+
+		if (x[i] == 0) {
+			ok = (x_cbrt == x_pow13);
+		} else {
+			ok = (fabs((x_cbrt - x_pow13)/x_cbrt) <= eps);
+		}
+
+		if (!ok) {
+			atf_tc_fail_nonfatal("cbrt(%.17g) = %.17g != "
+			    "pow(%.17g, 1/3) = %.17g\n",
+			    x[i], x_cbrt, x[i], x_pow13);
+		}
 	}
 }
 
@@ -162,18 +171,27 @@ ATF_TC_HEAD(cbrtf_powf, tc)
 ATF_TC_BODY(cbrtf_powf, tc)
 {
 	const float x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.0 };
-	const float eps = 1.0e-5;
-	float y, z;
+	/* Neither cbrt nor pow is required to be correctly rounded.  */
+	const float eps = 2*FLT_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(x); i++) {
-
-		y = cbrtf(x[i]);
-		z = powf(x[i], 1.0 / 3.0);
-
-		if (fabsf(y - z) > eps)
-			atf_tc_fail_nonfatal("cbrtf(%0.03f) != "
-			    "powf(%0.03f, 1/3)\n", x[i], x[i]);
+		float x_cbrt = cbrtf(x[i]);
+		float x_pow13 = powf(x[i], 1.0 / 3.0);
+		bool ok;
+
+		if (x[i] == 0) {
+			ok = (x_cbrt == x_pow13);
+		} else {
+			ok = (fabsf((x_cbrt - x_pow13)/x_cbrt) <= eps);
+		}
+
+		if (!ok) {
+			atf_tc_fail_nonfatal("cbrtf(%.9g) = %.9g. != "
+			    "powf(%.9g, 1/3) = %.9g\n",
+			    (double)x[i], (double)x_cbrt,
+			    (double)x[i], (double)x_pow13);
+		}
 	}
 }
 
@@ -264,27 +282,42 @@ ATF_TC_HEAD(cbrtl_powl, tc)
 ATF_TC_BODY(cbrtl_powl, tc)
 {
 	const long double x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.0 };
-	const long double eps = 1.0e-15;
-	long double y, z;
+	/* Neither cbrt nor pow is required to be correctly rounded.  */
+	const long double eps = 2*LDBL_EPSILON;
 	size_t i;
 
 #if defined(__amd64__) && defined(__clang__) && __clang_major__ >= 7 && \
     __clang_major__ < 10 && __FreeBSD_cc_version < 1300002
 	atf_tc_expect_fail("test fails with clang 7-9 - bug 234040");
 #endif
-
 	for (i = 0; i < __arraycount(x); i++) {
-
-		y = cbrtl(x[i]);
+		long double x_cbrt = cbrtl(x[i]);
 #ifdef __FreeBSD__
-		z = powl(x[i], (long double)1.0 / 3.0);
+		/*
+		 * NetBSD doesn't have a real powl/cbrtl implementation, they
+		 * just call the double version. On FreeBSD we have a real
+		 * powl implementation so we have to cast the second argument
+		 * to long double before dividing to get a more precise
+		 * approximation of 1/3.
+		 * TODO: upstream this diff.
+		 */
+		long double x_pow13 = powl(x[i], (long double)1.0 / 3.0);
 #else
-		z = powl(x[i], 1.0 / 3.0);
+		long double x_pow13 = powl(x[i], 1.0 / 3.0);
 #endif
-
-		if (fabsl(y - z) > eps * fabsl(1 + x[i]))
-			atf_tc_fail_nonfatal("cbrtl(%0.03Lf) != "
-			    "powl(%0.03Lf, 1/3)\n", x[i], x[i]);
+		bool ok;
+
+		if (x[i] == 0) {
+			ok = (x_cbrt == x_pow13);
+		} else {
+			ok = (fabsl((x_cbrt - x_pow13)/x_cbrt) <= eps);
+		}
+
+		if (!ok) {
+			atf_tc_fail_nonfatal("cbrtl(%.35Lg) = %.35Lg != "
+			    "powl(%.35Lg, 1/3) = %.35Lg\n",
+			    x[i], x_cbrt, x[i], x_pow13);
+		}
 	}
 }
 
diff --git a/contrib/netbsd-tests/lib/libm/t_cos.c b/contrib/netbsd-tests/lib/libm/t_cos.c
index d99d60810eeb..ca5f0aab7ffa 100644
--- a/contrib/netbsd-tests/lib/libm/t_cos.c
+++ b/contrib/netbsd-tests/lib/libm/t_cos.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_cos.c,v 1.4 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_cos.c,v 1.9 2019/05/27 00:10:36 maya Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,31 +29,138 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <assert.h>
 #include <atf-c.h>
+#include <float.h>
 #include <math.h>
 
 static const struct {
 	int		angle;
 	double		x;
 	double		y;
+	float		fy;
 } angles[] = {
-	{ -180, -3.141592653589793, -1.0000000000000000 },
-	{ -135, -2.356194490192345, -0.7071067811865476 },
-	{  -90, -1.570796326794897,  0.0000000000000000 },
-	{  -45, -0.785398163397448,  0.7071067811865476 },
-	{    0,  0.000000000000000,  1.0000000000000000 },
-	{   30,  0.523598775598299,  0.8660254037844386 },
-	{   45,  0.785398163397448,  0.7071067811865476 },
-	{   60,  1.047197551196598,  0.5000000000000000 },
-	{   90,  1.570796326794897,  0.0000000000000000 },
-	{  120,  2.094395102393195, -0.5000000000000000 },
-	{  135,  2.356194490192345, -0.7071067811865476 },
-	{  150,  2.617993877991494, -0.8660254037844386 },
-	{  180,  3.141592653589793, -1.0000000000000000 },
-	{  270,  4.712388980384690,  0.0000000000000000 },
-	{  360,  6.283185307179586,  1.0000000000000000 }
+	{ -180, -3.141592653589793, -1.0000000000000000, 999 },
+	{ -135, -2.356194490192345, -0.7071067811865476, 999 },
+	{  -90, -1.5707963267948966, 6.123233995736766e-17, -4.3711388e-08 },
+	{  -90, -1.5707963267948968, -1.6081226496766366e-16, -4.3711388e-08 },
+	{  -45, -0.785398163397448,  0.7071067811865478, 999 },
+	{    0,  0.000000000000000,  1.0000000000000000, 999 },
+	{   30,  0.523598775598299,  0.8660254037844386, 999 },
+	{   45,  0.785398163397448,  0.7071067811865478, 999 },
+	{   60,  1.0471975511965976,  0.5000000000000001, 999 },
+	{   60,  1.0471975511965979,  0.4999999999999999, 999 },
+	{   90,  1.570796326794897, -3.8285686989269494e-16, -4.3711388e-08 },
+	{  120,  2.0943951023931953, -0.4999999999999998, 999 },
+	{  120,  2.0943951023931957, -0.5000000000000002, 999 },
+	{  135,  2.356194490192345, -0.7071067811865476, 999 },
+	{  150,  2.617993877991494, -0.8660254037844386, 999 },
+	{  180,  3.141592653589793, -1.0000000000000000, 999 },
+	{  270,  4.712388980384690, -1.8369701987210297e-16, 1.1924881e-08 },
+	{  360,  6.283185307179586,  1.0000000000000000, 999 },
 };
 
+#ifdef __HAVE_LONG_DOUBLE
+/*
+ * cosl(3)
+ */
+ATF_TC(cosl_angles);
+ATF_TC_HEAD(cosl_angles, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test some selected angles");
+}
+
+ATF_TC_BODY(cosl_angles, tc)
+{
+	/*
+	 * XXX The given data is for double, so take that
+	 * into account and expect less precise results..
+	 */
+	const long double eps = DBL_EPSILON;
+	size_t i;
+
+	for (i = 0; i < __arraycount(angles); i++) {
+		int deg = angles[i].angle;
+		long double theta = angles[i].x;
+		long double cos_theta = angles[i].y;
+
+		assert(cos_theta != 0);
+		if (!(fabsl((cosl(theta) - cos_theta)/cos_theta) <= eps)) {
+			atf_tc_fail_nonfatal("cos(%d deg = %.17Lg) = %.17Lg"
+			    " != %.17Lg",
+			    deg, theta, cosl(theta), cos_theta);
+		}
+	}
+}
+
+ATF_TC(cosl_nan);
+ATF_TC_HEAD(cosl_nan, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test cosl(NaN) == NaN");
+}
+
+ATF_TC_BODY(cosl_nan, tc)
+{
+	const long double x = 0.0L / 0.0L;
+
+	ATF_CHECK(isnan(x) != 0);
+	ATF_CHECK(isnan(cosl(x)) != 0);
+}
+
+ATF_TC(cosl_inf_neg);
+ATF_TC_HEAD(cosl_inf_neg, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test cosl(-Inf) == NaN");
+}
+
+ATF_TC_BODY(cosl_inf_neg, tc)
+{
+	const long double x = -1.0L / 0.0L;
+
+	ATF_CHECK(isnan(cosl(x)) != 0);
+}
+
+ATF_TC(cosl_inf_pos);
+ATF_TC_HEAD(cosl_inf_pos, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test cosl(+Inf) == NaN");
+}
+
+ATF_TC_BODY(cosl_inf_pos, tc)
+{
+	const long double x = 1.0L / 0.0L;
+
+	ATF_CHECK(isnan(cosl(x)) != 0);
+}
+
+
+ATF_TC(cosl_zero_neg);
+ATF_TC_HEAD(cosl_zero_neg, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test cosl(-0.0) == 1.0");
+}
+
+ATF_TC_BODY(cosl_zero_neg, tc)
+{
+	const long double x = -0.0L;
+
+	ATF_CHECK(cosl(x) == 1.0);
+}
+
+ATF_TC(cosl_zero_pos);
+ATF_TC_HEAD(cosl_zero_pos, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test cosl(+0.0) == 1.0");
+}
+
+ATF_TC_BODY(cosl_zero_pos, tc)
+{
+	const long double x = 0.0L;
+
+	ATF_CHECK(cosl(x) == 1.0);
+}
+#endif
+
 /*
  * cos(3)
  */
@@ -65,14 +172,20 @@ ATF_TC_HEAD(cos_angles, tc)
 
 ATF_TC_BODY(cos_angles, tc)
 {
-	const double eps = 1.0e-15;
+	const double eps = DBL_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(angles); i++) {
-
-		if (fabs(cos(angles[i].x) - angles[i].y) > eps)
-			atf_tc_fail_nonfatal("cos(%d deg) != %0.01f",
-			    angles[i].angle, angles[i].y);
+		int deg = angles[i].angle;
+		double theta = angles[i].x;
+		double cos_theta = angles[i].y;
+
+		assert(cos_theta != 0);
+		if (!(fabs((cos(theta) - cos_theta)/cos_theta) <= eps)) {
+			atf_tc_fail_nonfatal("cos(%d deg = %.17g) = %.17g"
+			    " != %.17g",
+			    deg, theta, cos(theta), cos_theta);
+		}
 	}
 }
 
@@ -154,18 +267,33 @@ ATF_TC_HEAD(cosf_angles, tc)
 
 ATF_TC_BODY(cosf_angles, tc)
 {
-	const float eps = 1.0e-7;
-	float x, y;
+	const float eps = FLT_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(angles); i++) {
-
-		x = angles[i].x;
-		y = angles[i].y;
-
-		if (fabsf(cosf(x) - y) > eps)
-			atf_tc_fail_nonfatal("cosf(%d deg) != %0.01f",
-			    angles[i].angle, angles[i].y);
+		int deg = angles[i].angle;
+		float theta = angles[i].x;
+		float cos_theta = angles[i].fy;
+
+		/*
+		 * Force rounding to float even if FLT_EVAL_METHOD=2,
+		 * as is the case on i386.
+		 *
+		 * The volatile should not be necessary, by C99 Sec.
+		 * 5.2.4.2.2. para. 8 on p. 24 which specifies that
+		 * assignment and cast remove all extra range and precision,
+		 * but seems to be needed to work around a compiler bug.
+		 */ 
+		volatile float result = cosf(theta);
+
+		if (cos_theta == 999)
+			cos_theta = angles[i].y;
+
+		assert(cos_theta != 0);
+		if (!(fabsf((result - cos_theta)/cos_theta) <= eps)) {
+			atf_tc_fail_nonfatal("cosf(%d deg = %.8g) = %.8g"
+			    " != %.8g", deg, theta, result, cos_theta);
+		}
 	}
 }
 
@@ -244,6 +372,14 @@ ATF_TC_BODY(cosf_zero_pos, tc)
 
 ATF_TP_ADD_TCS(tp)
 {
+#ifdef __HAVE_LONG_DOUBLE
+	ATF_TP_ADD_TC(tp, cosl_angles);
+	ATF_TP_ADD_TC(tp, cosl_nan);
+	ATF_TP_ADD_TC(tp, cosl_inf_neg);
+	ATF_TP_ADD_TC(tp, cosl_inf_pos);
+	ATF_TP_ADD_TC(tp, cosl_zero_neg);
+	ATF_TP_ADD_TC(tp, cosl_zero_pos);
+#endif
 
 	ATF_TP_ADD_TC(tp, cos_angles);
 	ATF_TP_ADD_TC(tp, cos_nan);
diff --git a/contrib/netbsd-tests/lib/libm/t_cosh.c b/contrib/netbsd-tests/lib/libm/t_cosh.c
index 3f998de761bb..aac3a39b0236 100644
--- a/contrib/netbsd-tests/lib/libm/t_cosh.c
+++ b/contrib/netbsd-tests/lib/libm/t_cosh.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_cosh.c,v 1.6 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_cosh.c,v 1.7 2018/11/07 03:59:36 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,28 +29,28 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_cosh.c,v 1.6 2014/03/03 10:39:08 martin Exp $");
+__RCSID("$NetBSD: t_cosh.c,v 1.7 2018/11/07 03:59:36 riastradh Exp $");
 
 #include <atf-c.h>
+#include <float.h>
 #include <math.h>
 #include <stdio.h>
 
 static const struct {
 	double x;
 	double y;
-	double e;
 } values[] = {
-	{ -10,    11013.23292010332, 1e4, },
-	{ -2,     3.762195691083631, 1,   },
-	{ -1,     1.543080634815244, 1,   },
-	{ -0.05,  1.001250260438369, 1,   },
-	{ -0.001, 1.000000500000042, 1,   },
-	{  0,     1,                 1,   },
-	{  0.001, 1.000000500000042, 1,   },
-	{  0.05,  1.001250260438369, 1,   },
-	{  1,     1.543080634815244, 1,   },
-	{  2,     3.762195691083631, 1,   },
-	{  10,    11013.23292010332, 1e4, },
+	{ -10,    11013.232920103323, },
+	{ -2,     3.762195691083631, },
+	{ -1,     1.543080634815244, },
+	{ -0.05,  1.001250260438369, },
+	{ -0.001, 1.0000005000000418, },
+	{  0,     1,                 },
+	{  0.001, 1.0000005000000418, },
+	{  0.05,  1.001250260438369, },
+	{  1,     1.543080634815244, },
+	{  2,     3.762195691083631, },
+	{  10,    11013.232920103323, },
 };
 
 /*
@@ -64,18 +64,17 @@ ATF_TC_HEAD(cosh_inrange, tc)
 
 ATF_TC_BODY(cosh_inrange, tc)
 {
-	double eps;
-	double x;
-	double y;
+	const double eps = DBL_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(values); i++) {
-		x = values[i].x;
-		y = values[i].y;
-		eps = 1e-15 * values[i].e;
+		double x = values[i].x;
+		double cosh_x = values[i].y;
 
-		if (fabs(cosh(x) - y) > eps)
-			atf_tc_fail_nonfatal("cosh(%g) != %g\n", x, y);
+		if (!(fabs((cosh(x) - cosh_x)/cosh_x) <= eps)) {
+			atf_tc_fail_nonfatal("cosh(%.17g) = %.17g != %.17g\n",
+			    x, cosh(x), cosh_x);
+		}
 	}
 }
 
@@ -162,18 +161,17 @@ ATF_TC_HEAD(coshf_inrange, tc)
 
 ATF_TC_BODY(coshf_inrange, tc)
 {
-	float eps;
-	float x;
-	float y;
+	const float eps = FLT_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(values); i++) {
-		x = values[i].x;
-		y = values[i].y;
-		eps = 1e-6 * values[i].e;
+		float x = values[i].x;
+		float cosh_x = values[i].y;
 
-		if (fabsf(coshf(x) - y) > eps)
-			atf_tc_fail_nonfatal("coshf(%g) != %g\n", x, y);
+		if (!(fabsf((coshf(x) - cosh_x)/cosh_x) <= eps)) {
+			atf_tc_fail_nonfatal("coshf(%.17g) = %.17g != %.17g\n",
+			    x, coshf(x), cosh_x);
+		}
 	}
 }
 
diff --git a/contrib/netbsd-tests/lib/libm/t_exp.c b/contrib/netbsd-tests/lib/libm/t_exp.c
index 0eb6412b566e..acef4c0e91de 100644
--- a/contrib/netbsd-tests/lib/libm/t_exp.c
+++ b/contrib/netbsd-tests/lib/libm/t_exp.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_exp.c,v 1.8 2014/10/07 16:53:44 gson Exp $ */
+/* $NetBSD: t_exp.c,v 1.9 2018/11/07 03:59:36 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -30,6 +30,7 @@
  */
 
 #include <atf-c.h>
+#include <float.h>
 #include <math.h>
 #include "t_libm.h"
 
@@ -37,17 +38,16 @@
 static const struct {
 	double x;
 	double y;
-	double e;
 } exp_values[] = {
-	{  -10, 0.4539992976248485e-4, 1e-4, },
-	{   -5, 0.6737946999085467e-2, 1e-2, },
-	{   -1, 0.3678794411714423,    1e-1, },
-	{ -0.1, 0.9048374180359595,    1e-1, },
-	{    0, 1.0000000000000000,    1,    },
-	{  0.1, 1.1051709180756477,    1,    },
-	{    1, 2.7182818284590452,    1,    },
-	{    5, 148.41315910257660,    1e2, },
-	{   10, 22026.465794806718,    1e4, },
+	{  -10, 0.4539992976248485e-4, },
+	{   -5, 0.6737946999085467e-2, },
+	{   -1, 0.3678794411714423,    },
+	{ -0.1, 0.9048374180359595,    },
+	{    0, 1.0000000000000000,    },
+	{  0.1, 1.1051709180756477,    },
+	{    1, 2.7182818284590452,    },
+	{    5, 148.41315910257660,    },
+	{   10, 22026.465794806718,    },
 };
 
 /*
@@ -238,18 +238,17 @@ ATF_TC_HEAD(exp_product, tc)
 
 ATF_TC_BODY(exp_product, tc)
 {
-	double eps;
-	double x;
-	double y;
+	const double eps = DBL_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(exp_values); i++) {
-		x = exp_values[i].x;
-		y = exp_values[i].y;
-		eps = 1e-15 * exp_values[i].e;
+		double x = exp_values[i].x;
+		double e_x = exp_values[i].y;
 
-		if (fabs(exp(x) - y) > eps)
-			atf_tc_fail_nonfatal("exp(%0.01f) != %18.18e", x, y);
+		if (!(fabs((exp(x) - e_x)/e_x) <= eps)) {
+			atf_tc_fail_nonfatal("exp(%.17g) = %.17g != %.17g",
+			    x, exp(x), e_x);
+		}
 	}
 }
 
@@ -336,18 +335,17 @@ ATF_TC_HEAD(expf_product, tc)
 
 ATF_TC_BODY(expf_product, tc)
 {
-	float eps;
-	float x;
-	float y;
+	const float eps = FLT_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(exp_values); i++) {
-		x = exp_values[i].x;
-		y = exp_values[i].y;
-		eps = 1e-6 * exp_values[i].e;
+		float x = exp_values[i].x;
+		float e_x = exp_values[i].y;
 
-		if (fabsf(expf(x) - y) > eps)
-			atf_tc_fail_nonfatal("expf(%0.01f) != %18.18e", x, y);
+		if (!(fabsf((expf(x) - e_x)/e_x) <= eps)) {
+			atf_tc_fail_nonfatal("expf(%.8g) = %.8g != %.8g",
+			    x, exp(x), e_x);
+		}
 	}
 }
 
diff --git a/contrib/netbsd-tests/lib/libm/t_fe_round.c b/contrib/netbsd-tests/lib/libm/t_fe_round.c
index fe805b4f86b8..33da289eb156 100644
--- a/contrib/netbsd-tests/lib/libm/t_fe_round.c
+++ b/contrib/netbsd-tests/lib/libm/t_fe_round.c
@@ -89,7 +89,97 @@ ATF_TC_BODY(fe_round, tc)
 		    (fegetround() == values[i].round_mode),
 		    "Didn't get the same rounding mode out!\n"
 		    "(index %d) fed in %d rounding mode, got %d out\n",
-		    i, fegetround(), values[i].round_mode);
+		    i, values[i].round_mode, fegetround());
+	}
+}
+
+ATF_TC(fe_nearbyint);
+ATF_TC_HEAD(fe_nearbyint, tc)
+{
+	atf_tc_set_md_var(tc, "descr","Checking IEEE 754 rounding modes using nearbyint");
+}
+
+ATF_TC_BODY(fe_nearbyint, tc)
+{
+	double received;
+
+	for (unsigned int i = 0; i < __arraycount(values); i++) {
+		fesetround(values[i].round_mode);
+
+		received = nearbyint(values[i].input);
+		ATF_CHECK_MSG(
+		    (fabs(received - values[i].expected) < EPSILON),
+		    "nearbyint rounding wrong, difference too large\n"
+		    "input: %f (index %d): got %f, expected %ld\n",
+		    values[i].input, i, received, values[i].expected);
+
+		/* Do we get the same rounding mode out? */
+		ATF_CHECK_MSG(
+		    (fegetround() == values[i].round_mode),
+		    "Didn't get the same rounding mode out!\n"
+		    "(index %d) fed in %d rounding mode, got %d out\n",
+		    i, values[i].round_mode, fegetround());
+	}
+}
+
+static const struct {
+	double input;
+	double toward;
+	double expected;
+} values2[] = {
+	{ 10.0, 11.0, 10.0 },
+	{ -5.0, -6.0, -5.0 },
+};
+
+ATF_TC(fe_nextafter);
+ATF_TC_HEAD(fe_nextafter, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Checking IEEE 754 rounding using nextafter()");
+}
+
+ATF_TC_BODY(fe_nextafter, tc)
+{
+	double received;
+	int res;
+
+	for (unsigned int i = 0; i < __arraycount(values2); i++) {
+		received = nextafter(values2[i].input, values2[i].toward);
+		if (values2[i].input < values2[i].toward) {
+			res = (received > values2[i].input);
+		} else {
+			res = (received < values2[i].input);
+		}
+		ATF_CHECK_MSG(
+			res && (fabs(received - values2[i].expected) < EPSILON),
+			"nextafter() rounding wrong, difference too large\n"
+			"input: %f (index %d): got %f, expected %f, res %d\n",
+			values2[i].input, i, received, values2[i].expected, res);
+	}
+}
+
+ATF_TC(fe_nexttoward);
+ATF_TC_HEAD(fe_nexttoward, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Checking IEEE 754 rounding using nexttoward()");
+}
+
+ATF_TC_BODY(fe_nexttoward, tc)
+{
+	double received;
+	int res;
+
+	for (unsigned int i = 0; i < __arraycount(values2); i++) {
+		received = nexttoward(values2[i].input, values2[i].toward);
+		if (values2[i].input < values2[i].toward) {
+			res = (received > values2[i].input);
+		} else {
+			res = (received < values2[i].input);
+		}
+		ATF_CHECK_MSG(
+			res && (fabs(received - values2[i].expected) < EPSILON),
+			"nexttoward() rounding wrong, difference too large\n"
+			"input: %f (index %d): got %f, expected %f, res %d\n",
+			values2[i].input, i, received, values2[i].expected, res);
 	}
 }
 
@@ -97,6 +187,9 @@ ATF_TP_ADD_TCS(tp)
 {
 
 	ATF_TP_ADD_TC(tp, fe_round);
+	ATF_TP_ADD_TC(tp, fe_nearbyint);
+	ATF_TP_ADD_TC(tp, fe_nextafter);
+	ATF_TP_ADD_TC(tp, fe_nexttoward);
 
 	return atf_no_error();
 }
@@ -109,15 +202,56 @@ ATF_TC_HEAD(t_nofe_round, tc)
 	    "dummy test case - no fenv.h support");
 }
 
-
 ATF_TC_BODY(t_nofe_round, tc)
 {
 	atf_tc_skip("no fenv.h support on this architecture");
 }
 
+ATF_TC(t_nofe_nearbyint);
+
+ATF_TC_HEAD(t_nofe_nearbyint, tc)
+{
+	atf_tc_set_md_var(tc, "descr",
+	    "dummy test case - no fenv.h support");
+}
+
+ATF_TC_BODY(t_nofe_nearbyint, tc)
+{
+	atf_tc_skip("no fenv.h support on this architecture");
+}
+
+ATF_TC(t_nofe_nextafter);
+
+ATF_TC_HEAD(t_nofe_nextafter, tc)
+{
+	atf_tc_set_md_var(tc, "descr",
+	    "dummy test case - no fenv.h support");
+}
+
+ATF_TC_BODY(t_nofe_nextafter, tc)
+{
+	atf_tc_skip("no fenv.h support on this architecture");
+}
+
+ATF_TC(t_nofe_nexttoward);
+
+ATF_TC_HEAD(t_nofe_nexttoward, tc)
+{
+	atf_tc_set_md_var(tc, "descr",
+	    "dummy test case - no fenv.h support");
+}
+
+ATF_TC_BODY(t_nofe_nexttoward, tc)
+{
+	atf_tc_skip("no fenv.h support on this architecture");
+}
+
 ATF_TP_ADD_TCS(tp)
 {
 	ATF_TP_ADD_TC(tp, t_nofe_round);
+	ATF_TP_ADD_TC(tp, t_nofe_nearbyint);
+	ATF_TP_ADD_TC(tp, t_nofe_nextafter);
+	ATF_TP_ADD_TC(tp, t_nofe_nexttoward);
 	return atf_no_error();
 }
 
diff --git a/contrib/netbsd-tests/lib/libm/t_fenv.c b/contrib/netbsd-tests/lib/libm/t_fenv.c
index 544503673a98..613bf3027950 100644
--- a/contrib/netbsd-tests/lib/libm/t_fenv.c
+++ b/contrib/netbsd-tests/lib/libm/t_fenv.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_fenv.c,v 1.3 2015/12/22 14:20:59 christos Exp $ */
+/* $NetBSD: t_fenv.c,v 1.6 2019/04/25 20:48:54 kamil Exp $ */
 
 /*-
  * Copyright (c) 2014 The NetBSD Foundation, Inc.
@@ -29,7 +29,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_fenv.c,v 1.3 2015/12/22 14:20:59 christos Exp $");
+__RCSID("$NetBSD: t_fenv.c,v 1.6 2019/04/25 20:48:54 kamil Exp $");
 
 #include <atf-c.h>
 
@@ -40,15 +40,15 @@ __RCSID("$NetBSD: t_fenv.c,v 1.3 2015/12/22 14:20:59 christos Exp $");
 #include <stdlib.h>
 
 
-#if __arm__ && !__SOFTFP__
+#if (__arm__ && !__SOFTFP__) || __aarch64__
 	/*
-	 * Some NEON fpus do not implement IEEE exception handling,
-	 * skip these tests if running on them and compiled for
+	 * Some NEON fpus  do not trap on IEEE 754 FP exceptions.
+	 * Skip these tests if running on them and compiled for
 	 * hard float.
 	 */
 #define	FPU_EXC_PREREQ()						\
 	if (0 == fpsetmask(fpsetmask(FP_X_INV)))			\
-		atf_tc_skip("FPU does not implement exception handling");
+		atf_tc_skip("FPU does not implement traps on FP exceptions");
 
 	/*
 	 * Same as above: some don't allow configuring the rounding mode.
diff --git a/contrib/netbsd-tests/lib/libm/t_fmod.c b/contrib/netbsd-tests/lib/libm/t_fmod.c
index 2a221f5f62e1..1866c3d23d21 100644
--- a/contrib/netbsd-tests/lib/libm/t_fmod.c
+++ b/contrib/netbsd-tests/lib/libm/t_fmod.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_fmod.c,v 1.3 2015/01/03 14:23:53 gson Exp $ */
+/* $NetBSD: t_fmod.c,v 1.4 2020/08/25 13:39:16 gson Exp $ */
 
 /*-
  * Copyright (c) 2013 The NetBSD Foundation, Inc.
@@ -50,21 +50,15 @@ ATF_TC_BODY(fmod, tc)
 
 	ATF_CHECK(fmodf(2.0, 1.0) == 0);
 	ATF_CHECK(fmod(2.0, 1.0) == 0);
-#if !defined(__FreeBSD__) || LDBL_PREC != 53
 	ATF_CHECK(fmodl(2.0, 1.0) == 0);
-#endif
 
 	ATF_CHECK(fmodf(2.0, 0.5) == 0);
 	ATF_CHECK(fmod(2.0, 0.5) == 0);
-#if !defined(__FreeBSD__) || LDBL_PREC != 53
 	ATF_CHECK(fmodl(2.0, 0.5) == 0);
-#endif
 
 	ATF_CHECK(fabsf(fmodf(1.0, 0.1) - 0.1f) <= 55 * FLT_EPSILON);
 	ATF_CHECK(fabs(fmod(1.0, 0.1) - 0.1) <= 55 * DBL_EPSILON);
-#if !defined(__FreeBSD__) || LDBL_PREC != 53
 	ATF_CHECK(fabsl(fmodl(1.0, 0.1L) - 0.1L) <= 55 * LDBL_EPSILON);
-#endif
 }
 
 ATF_TP_ADD_TCS(tp)
diff --git a/contrib/netbsd-tests/lib/libm/t_ilogb.c b/contrib/netbsd-tests/lib/libm/t_ilogb.c
index 1d35cb64127b..bbccaca39bc1 100644
--- a/contrib/netbsd-tests/lib/libm/t_ilogb.c
+++ b/contrib/netbsd-tests/lib/libm/t_ilogb.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_ilogb.c,v 1.7 2017/01/13 19:23:40 christos Exp $ */
+/* $NetBSD: t_ilogb.c,v 1.9 2018/06/14 21:57:25 maya Exp $ */
 
 /*-
  * Copyright (c) 2016 The NetBSD Foundation, Inc.
@@ -29,7 +29,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_ilogb.c,v 1.7 2017/01/13 19:23:40 christos Exp $");
+__RCSID("$NetBSD: t_ilogb.c,v 1.9 2018/06/14 21:57:25 maya Exp $");
 
 #include <atf-c.h>
 #include <fenv.h>
@@ -44,7 +44,9 @@ __RCSID("$NetBSD: t_ilogb.c,v 1.7 2017/01/13 19:23:40 christos Exp $");
 #else
 # define ATF_CHECK_RAISED_INVALID do { \
 	int r = fetestexcept(FE_ALL_EXCEPT); \
-	ATF_CHECK_MSG(r == FE_INVALID, "r=%#x != %#x\n", r, FE_INVALID); \
+	ATF_CHECK_MSG((r & FE_INVALID) != 0, \
+	    "r & FE_INVALID == 0 (r=%#x, FE_INVALID=%#x)\n", \
+	     r, FE_INVALID); \
 	(void)feclearexcept(FE_ALL_EXCEPT); \
 } while (/*CONSTCOND*/0)
 
diff --git a/contrib/netbsd-tests/lib/libm/t_ldexp.c b/contrib/netbsd-tests/lib/libm/t_ldexp.c
index 251f2aeba5fb..977b2219873b 100644
--- a/contrib/netbsd-tests/lib/libm/t_ldexp.c
+++ b/contrib/netbsd-tests/lib/libm/t_ldexp.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_ldexp.c,v 1.16 2016/08/25 00:32:31 maya Exp $ */
+/* $NetBSD: t_ldexp.c,v 1.17 2018/11/07 03:59:36 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,14 +29,15 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_ldexp.c,v 1.16 2016/08/25 00:32:31 maya Exp $");
+__RCSID("$NetBSD: t_ldexp.c,v 1.17 2018/11/07 03:59:36 riastradh Exp $");
 
 #include <sys/param.h>
 
 #include <atf-c.h>
 
-#include <math.h>
+#include <float.h>
 #include <limits.h>
+#include <math.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -195,22 +196,17 @@ ATF_TC_HEAD(ldexp_exp2, tc)
 ATF_TC_BODY(ldexp_exp2, tc)
 {
 	const double n[] = { 1, 2, 3, 10, 50, 100 };
-#if __DBL_MIN_10_EXP__ <= -40
-	const double eps = 1.0e-40;
-#else
-	const double eps = __DBL_MIN__*4.0;
-#endif
+	const double eps = DBL_EPSILON;
 	const double x = 12.0;
-	double y;
 	size_t i;
 
 	for (i = 0; i < __arraycount(n); i++) {
+		double y = ldexp(x, n[i]);
 
-		y = ldexp(x, n[i]);
-
-		if (fabs(y - (x * exp2(n[i]))) > eps) {
-			atf_tc_fail_nonfatal("ldexp(%0.01f, %0.01f) "
-			    "!= %0.01f * exp2(%0.01f)", x, n[i], x, n[i]);
+		if (!(fabs((y - (x * exp2(n[i])))/y) <= eps)) {
+			atf_tc_fail_nonfatal("ldexp(%.17g, %.17g) = %.17g "
+			    "!= %.17g * exp2(%.17g) = %.17g",
+			    x, n[i], y, x, n[i], (x * exp2(n[i])));
 		}
 	}
 }
@@ -320,18 +316,17 @@ ATF_TC_HEAD(ldexpf_exp2f, tc)
 ATF_TC_BODY(ldexpf_exp2f, tc)
 {
 	const float n[] = { 1, 2, 3, 10, 50, 100 };
-	const float eps = 1.0e-9;
+	const float eps = FLT_EPSILON;
 	const float x = 12.0;
-	float y;
 	size_t i;
 
 	for (i = 0; i < __arraycount(n); i++) {
+		float y = ldexpf(x, n[i]);
 
-		y = ldexpf(x, n[i]);
-
-		if (fabsf(y - (x * exp2f(n[i]))) > eps) {
-			atf_tc_fail_nonfatal("ldexpf(%0.01f, %0.01f) "
-			    "!= %0.01f * exp2f(%0.01f)", x, n[i], x, n[i]);
+		if (!(fabsf((y - (x * exp2f(n[i])))/y) <= eps)) {
+			atf_tc_fail_nonfatal("ldexpf(%.17g, %.17g) = %.17g "
+			    "!= %.17g * exp2f(%.17g) = %.17g",
+			    x, n[i], y, x, n[i], (x * exp2f(n[i])));
 		}
 	}
 }
diff --git a/contrib/netbsd-tests/lib/libm/t_libm.h b/contrib/netbsd-tests/lib/libm/t_libm.h
index 34e3cb28abf5..0831f22d468d 100644
--- a/contrib/netbsd-tests/lib/libm/t_libm.h
+++ b/contrib/netbsd-tests/lib/libm/t_libm.h
@@ -1,4 +1,4 @@
-/* $NetBSD: t_libm.h,v 1.6 2014/03/25 17:30:14 joerg Exp $ */
+/* $NetBSD: t_libm.h,v 1.7 2018/11/07 03:59:36 riastradh Exp $ */
 
 /*
  * Check result of fn(arg) is correct within the bounds.
@@ -11,8 +11,8 @@
 	long double epsilon = epsilon_; \
 	long double expect = expect_; \
 	long double r = fn(arg); \
-	long double e = fabsl(r - expect); \
-	if (r != expect && e > epsilon) \
+	long double e = fabsl((r - expect)/expect); \
+	if (!(r == expect || e <= epsilon)) \
 		atf_tc_fail_nonfatal( \
 		    "subtest %u: " #fn "(%g) is %Lg (%.14La) " \
 		    "not %Lg (%.13La), error %Lg (%.6La) > %Lg", \
diff --git a/contrib/netbsd-tests/lib/libm/t_log.c b/contrib/netbsd-tests/lib/libm/t_log.c
index 756efcf39769..41aae4c7c967 100644
--- a/contrib/netbsd-tests/lib/libm/t_log.c
+++ b/contrib/netbsd-tests/lib/libm/t_log.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_log.c,v 1.13 2015/02/09 19:39:48 martin Exp $ */
+/* $NetBSD: t_log.c,v 1.14 2018/11/07 03:59:36 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,10 +29,11 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_log.c,v 1.13 2015/02/09 19:39:48 martin Exp $");
+__RCSID("$NetBSD: t_log.c,v 1.14 2018/11/07 03:59:36 riastradh Exp $");
 
 #include <atf-c.h>
 
+#include <float.h>
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
@@ -614,10 +615,10 @@ ATF_TC_HEAD(log_base, tc)
 
 ATF_TC_BODY(log_base, tc)
 {
-	const double eps = 1.0e-38;
+	const double eps = DBL_EPSILON;
 
-	if (fabs(log(M_E) - 1.0) > eps)
-		atf_tc_fail_nonfatal("log(e) != 1");
+	if (!(fabs(log(M_E) - 1.0) <= eps))
+		atf_tc_fail_nonfatal("log(e) = %.17g != 1", log(M_E));
 }
 
 ATF_TC(log_nan);
@@ -714,10 +715,11 @@ ATF_TC_HEAD(logf_base, tc)
 
 ATF_TC_BODY(logf_base, tc)
 {
-	const float eps = 1.0e-7;
+	const float eps = FLT_EPSILON;
 
-	if (fabsf(logf(M_E) - 1.0f) > eps)
-		atf_tc_fail_nonfatal("logf(e) != 1");
+	if (!(fabsf(logf(M_E) - 1.0f) <= eps))
+		atf_tc_fail_nonfatal("logf(e) = %.17g != 1",
+		    (double)logf(M_E));
 }
 
 ATF_TC(logf_nan);
diff --git a/contrib/netbsd-tests/lib/libm/t_round.c b/contrib/netbsd-tests/lib/libm/t_round.c
index f47e1a0f8a13..7d32586f1aa5 100644
--- a/contrib/netbsd-tests/lib/libm/t_round.c
+++ b/contrib/netbsd-tests/lib/libm/t_round.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_round.c,v 1.4 2013/11/11 23:57:34 joerg Exp $ */
+/* $NetBSD: t_round.c,v 1.9 2017/09/03 13:41:19 wiz Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -26,9 +26,14 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <sys/param.h>
+
 #include <atf-c.h>
 #include <float.h>
 #include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
 
 /*
  * This tests for a bug in the initial implementation where
@@ -76,10 +81,58 @@ ATF_TC_BODY(round_dir, tc)
 	ATF_CHECK(fabsl(cl) < SMALL_NUM);
 }
 
+ATF_TC(rounding_alpha);
+ATF_TC_HEAD(rounding_alpha, tc)
+{
+	atf_tc_set_md_var(tc, "descr","Checking MPFR's config failure with -mieee on Alpha");
+}
+
+typedef uint64_t gimpy_limb_t;
+#define GIMPY_NUMB_BITS 64
+
+ATF_TC_BODY(rounding_alpha, tc)
+{
+        double d;
+        gimpy_limb_t u;
+        int i;
+
+        d = 1.0;
+        for (i = 0; i < GIMPY_NUMB_BITS - 1; i++)
+                d = d + d;
+
+        printf("d = %g\n", d);
+        u = (gimpy_limb_t) d;
+
+        for (; i > 0; i--) {
+                ATF_CHECK_MSG((u % 2 == 0),
+		    "%"PRIu64" is not an even number! (iteration %d)", u , i);
+                u = u >> 1;
+        }
+}
+
+ATF_TC(rounding_alpha_simple);
+ATF_TC_HEAD(rounding_alpha_simple, tc)
+{
+	atf_tc_set_md_var(tc, "descr","Checking double to uint64_t edge case");
+}
+
+
+double rounding_alpha_simple_even = 9223372036854775808.000000; /* 2^63 */
+
+ATF_TC_BODY(rounding_alpha_simple, tc)
+{
+	uint64_t unsigned_even = rounding_alpha_simple_even;
+
+	ATF_CHECK_MSG(unsigned_even % 2 == 0,
+	    "2^63 cast to uint64_t is odd (got %"PRIu64")", unsigned_even);
+
+}
 ATF_TP_ADD_TCS(tp)
 {
 
 	ATF_TP_ADD_TC(tp, round_dir);
+	ATF_TP_ADD_TC(tp, rounding_alpha);
+	ATF_TP_ADD_TC(tp, rounding_alpha_simple);
 
 	return atf_no_error();
 }
diff --git a/contrib/netbsd-tests/lib/libm/t_scalbn.c b/contrib/netbsd-tests/lib/libm/t_scalbn.c
index 4bf00c3415d1..f6adaaa993ec 100644
--- a/contrib/netbsd-tests/lib/libm/t_scalbn.c
+++ b/contrib/netbsd-tests/lib/libm/t_scalbn.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_scalbn.c,v 1.14 2017/01/13 21:09:12 agc Exp $ */
+/* $NetBSD: t_scalbn.c,v 1.16 2018/11/07 03:59:36 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,12 +29,13 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_scalbn.c,v 1.14 2017/01/13 21:09:12 agc Exp $");
+__RCSID("$NetBSD: t_scalbn.c,v 1.16 2018/11/07 03:59:36 riastradh Exp $");
 
 #include <math.h>
 #include <limits.h>
 #include <float.h>
 #include <errno.h>
+#include <fenv.h>
 
 #include <atf-c.h>
 
@@ -46,16 +47,17 @@ struct testcase {
 	double inval;
 	double result;
 	int error;
+	int except;
 };
 struct testcase test_vals[] = {
-	{ 0,		1.00085,	1.00085,	0 },
-	{ 0,		0.99755,	0.99755,	0 },
-	{ 0,		-1.00085,	-1.00085,	0 },
-	{ 0,		-0.99755,	-0.99755,	0 },
-	{ 1,		1.00085,	2.0* 1.00085,	0 },
-	{ 1,		0.99755,	2.0* 0.99755,	0 },
-	{ 1,		-1.00085,	2.0* -1.00085,	0 },
-	{ 1,		-0.99755,	2.0* -0.99755,	0 },
+	{ 0,		1.00085,	1.00085,	0, 0 },
+	{ 0,		0.99755,	0.99755,	0, 0 },
+	{ 0,		-1.00085,	-1.00085,	0, 0 },
+	{ 0,		-0.99755,	-0.99755,	0, 0 },
+	{ 1,		1.00085,	2.0* 1.00085,	0, 0 },
+	{ 1,		0.99755,	2.0* 0.99755,	0, 0 },
+	{ 1,		-1.00085,	2.0* -1.00085,	0, 0 },
+	{ 1,		-0.99755,	2.0* -0.99755,	0, 0 },
 
 	/*
 	 * We could add more corner test cases here, but we would have to
@@ -82,13 +84,25 @@ ATF_TC_BODY(scalbn_val, tc)
 
 	for (i = 0; i < tcnt; i++) {
 		errno = 0;
+#ifndef __vax__
+		feclearexcept(FE_ALL_EXCEPT);
+#endif
 		rv = scalbn(tests[i].inval, tests[i].exp);
 		ATF_CHECK_EQ_MSG(errno, tests[i].error,
 		    "test %zu: errno %d instead of %d", i, errno,
 		    tests[i].error);
-		ATF_CHECK_MSG(fabs(rv-tests[i].result)<2.0*DBL_EPSILON,
-		    "test %zu: return value %g instead of %g (difference %g)",
-		    i, rv, tests[i].result, tests[i].result-rv);
+#ifndef __vax__
+		ATF_CHECK_EQ_MSG(errno, tests[i].error,
+		    "test %zu: fetestexcept %d instead of %d", i,
+		    fetestexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW),
+		    tests[i].except);
+#endif
+		/* scalbn is always exact except for underflow or overflow.  */
+		ATF_CHECK_MSG(rv == tests[i].result,
+		    "test %zu: return value %.17g instead of %.17g"
+		    " (error %.17g)",
+		    i, rv, tests[i].result,
+		    fabs((tests[i].result - rv)/tests[i].result));
 	}
 }
 
@@ -228,9 +242,12 @@ ATF_TC_BODY(scalbnf_val, tc)
 		ATF_CHECK_EQ_MSG(errno, tests[i].error,
 		    "test %zu: errno %d instead of %d", i, errno,
 		    tests[i].error);
-		ATF_CHECK_MSG(fabs(rv-tests[i].result)<2.0*FLT_EPSILON,
-		    "test %zu: return value %g instead of %g (difference %g)",
-		    i, rv, tests[i].result, tests[i].result-rv);
+		/* scalbn is always exact except for underflow or overflow.  */
+		ATF_CHECK_MSG(rv == (float)tests[i].result,
+		    "test %zu: return value %.8g instead of %.8g"
+		    " (error %.8g)",
+		    i, rv, tests[i].result,
+		    fabs((tests[i].result - rv)/tests[i].result));
 	}
 }
 
@@ -373,9 +390,12 @@ ATF_TC_BODY(scalbnl_val, tc)
 		ATF_CHECK_EQ_MSG(errno, tests[i].error,
 		    "test %zu: errno %d instead of %d", i, errno,
 		    tests[i].error);
-		ATF_CHECK_MSG(fabsl(rv-(long double)tests[i].result)<2.0*LDBL_EPSILON,
-		    "test %zu: return value %Lg instead of %Lg (difference %Lg)",
-		    i, rv, (long double)tests[i].result, (long double)tests[i].result-rv);
+		/* scalbn is always exact except for underflow or overflow.  */
+		ATF_CHECK_MSG(rv == (long double)tests[i].result,
+		    "test %zu: return value %.35Lg instead of %.35Lg"
+		    " (error %.35Lg)",
+		    i, rv, (long double)tests[i].result,
+		    fabsl(((long double)tests[i].result - rv)/tests[i].result));
 	}
 #endif
 }
diff --git a/contrib/netbsd-tests/lib/libm/t_sin.c b/contrib/netbsd-tests/lib/libm/t_sin.c
index a82f49dc65d6..ca581f03fad0 100644
--- a/contrib/netbsd-tests/lib/libm/t_sin.c
+++ b/contrib/netbsd-tests/lib/libm/t_sin.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_sin.c,v 1.4 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_sin.c,v 1.7 2019/05/27 00:24:37 maya Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,29 +29,33 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <assert.h>
 #include <atf-c.h>
+#include <float.h>
 #include <math.h>
 
 static const struct {
 	int		angle;
 	double		x;
 	double		y;
+	float		fy;
 } angles[] = {
-	{ -180, -3.141592653589793,  0.0000000000000000 },
-	{ -135, -2.356194490192345, -0.7071067811865476 },
-	{  -90, -1.570796326794897, -1.0000000000000000 },
-	{  -45, -0.785398163397448, -0.7071067811865476 },
-	{    0,  0.000000000000000,  0.0000000000000000 },
-	{   30,  0.523598775598299,  0.5000000000000000 },
-	{   45,  0.785398163397448,  0.7071067811865476 },
-	{   60,  1.047197551196598,  0.8660254037844386 },
-	{   90,  1.570796326794897,  1.0000000000000000 },
-	{  120,  2.094395102393195,  0.8660254037844386 },
-	{  135,  2.356194490192345,  0.7071067811865476 },
-	{  150,  2.617993877991494,  0.5000000000000000 },
-	{  180,  3.141592653589793,  0.0000000000000000 },
-	{  270,  4.712388980384690, -1.0000000000000000 },
-	{  360,  6.283185307179586,  0.0000000000000000 }
+	{ -360, -6.283185307179586,  2.4492935982947064e-16, -1.7484555e-07 },
+	{ -180, -3.141592653589793, -1.2246467991473532e-16, 8.7422777e-08 },
+	{ -135, -2.356194490192345, -0.7071067811865476, 999 },
+	{  -90, -1.570796326794897, -1.0000000000000000, 999 },
+	{  -45, -0.785398163397448, -0.7071067811865472, 999 },
+	{    0,  0.000000000000000,  0.0000000000000000, 999 },
+	{   30,  0.5235987755982989, 0.5000000000000000, 999 },
+	{   45,  0.785398163397448,  0.7071067811865472, 999 },
+	{   60,  1.047197551196598,  0.8660254037844388, 999 },
+	{   90,  1.570796326794897,  1.0000000000000000, 999 },
+	{  120,  2.094395102393195,  0.8660254037844389, 999 },
+	{  135,  2.356194490192345,  0.7071067811865476, 999 },
+	{  150,  2.617993877991494,  0.5000000000000003, 999 },
+	{  180,  3.141592653589793,  1.2246467991473532e-16, -8.7422777e-08 },
+	{  270,  4.712388980384690, -1.0000000000000000, 999 },
+	{  360,  6.283185307179586, -2.4492935982947064e-16, 1.7484555e-07 },
 };
 
 /*
@@ -65,14 +69,29 @@ ATF_TC_HEAD(sin_angles, tc)
 
 ATF_TC_BODY(sin_angles, tc)
 {
-	const double eps = 1.0e-15;
+	const double eps = DBL_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(angles); i++) {
-
-		if (fabs(sin(angles[i].x) - angles[i].y) > eps)
-			atf_tc_fail_nonfatal("sin(%d deg) != %0.01f",
-			    angles[i].angle, angles[i].y);
+		int deg = angles[i].angle;
+		double theta = angles[i].x;
+		double sin_theta = angles[i].y;
+		bool ok;
+
+		if (sin_theta == 0) {
+			/* Should be computed exactly.  */
+			assert(sin_theta == 0);
+			ok = (sin(theta) == 0);
+		} else {
+			assert(sin_theta != 0);
+			ok = (fabs((sin(theta) - sin_theta)/sin_theta) <= eps);
+		}
+
+		if (!ok) {
+			atf_tc_fail_nonfatal("sin(%d deg = %.17g) = %.17g"
+			    " != %.17g",
+			    deg, theta, sin(theta), sin_theta);
+		}
 	}
 }
 
@@ -154,18 +173,30 @@ ATF_TC_HEAD(sinf_angles, tc)
 
 ATF_TC_BODY(sinf_angles, tc)
 {
-	const float eps = 1.0e-6;
-	float x, y;
+	const float eps = FLT_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(angles); i++) {
-
-		x = angles[i].x;
-		y = angles[i].y;
-
-		if (fabsf(sinf(x) - y) > eps)
-			atf_tc_fail_nonfatal("sinf(%d deg) != %0.01f",
-			    angles[i].angle, angles[i].y);
+		int deg = angles[i].angle;
+		float theta = angles[i].x;
+		float sin_theta = angles[i].fy;
+		bool ok;
+
+		if (sin_theta == 999)
+			sin_theta = angles[i].y;
+
+		if (sin_theta == 0) {
+			/* Should be computed exactly.  */
+			ok = (sinf(theta) == 0);
+		} else {
+			ok = (fabsf((sinf(theta) - sin_theta)/sin_theta)
+			    <= eps);
+		}
+
+		if (!ok) {
+			atf_tc_fail_nonfatal("sinf(%d deg) = %.8g != %.8g",
+			    deg, sinf(theta), sin_theta);
+		}
 	}
 }
 
diff --git a/contrib/netbsd-tests/lib/libm/t_sinh.c b/contrib/netbsd-tests/lib/libm/t_sinh.c
index d935f0ea7ffb..d5f764fea573 100644
--- a/contrib/netbsd-tests/lib/libm/t_sinh.c
+++ b/contrib/netbsd-tests/lib/libm/t_sinh.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_sinh.c,v 1.6 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_sinh.c,v 1.7 2018/11/07 03:59:36 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,27 +29,27 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_sinh.c,v 1.6 2014/03/03 10:39:08 martin Exp $");
+__RCSID("$NetBSD: t_sinh.c,v 1.7 2018/11/07 03:59:36 riastradh Exp $");
 
 #include <atf-c.h>
+#include <float.h>
 #include <math.h>
 #include <stdio.h>
 
 static const struct {
 	double x;
 	double y;
-	double e;
 } values[] = {
-	{ -10,   -11013.23287470339, 1e4, },
-	{ -2,    -3.626860407847019, 1,   },
-	{ -1,    -1.175201193643801, 1,   },
-	{ -0.05, -0.050020835937655, 1,   },
-	{ -0.001,-0.001000000166667, 1,   },
-	{  0.001, 0.001000000166667, 1,   },
-	{  0.05,  0.050020835937655, 1,   },
-	{  1,     1.175201193643801, 1,   },
-	{  2,     3.626860407847019, 1,   },
-	{  10,    11013.23287470339, 1e4, },
+	{ -10,   -11013.232874703393, },
+	{ -2,    -3.626860407847019, },
+	{ -1,    -1.1752011936438014, },
+	{ -0.05, -0.050020835937655016, },
+	{ -0.001,-0.0010000001666666751, },
+	{  0.001, 0.0010000001666666751, },
+	{  0.05,  0.050020835937655016, },
+	{  1,     1.1752011936438014, },
+	{  2,     3.626860407847019, },
+	{  10,    11013.232874703393, },
 };
 
 /*
@@ -63,18 +63,17 @@ ATF_TC_HEAD(sinh_inrange, tc)
 
 ATF_TC_BODY(sinh_inrange, tc)
 {
-	double eps;
-	double x;
-	double y;
+	const double eps = DBL_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(values); i++) {
-		x = values[i].x;
-		y = values[i].y;
-		eps = 1e-15 * values[i].e;
+		double x = values[i].x;
+		double sinh_x = values[i].y;
 
-		if (fabs(sinh(x) - y) > eps)
-			atf_tc_fail_nonfatal("sinh(%g) != %g\n", x, y);
+		if (!(fabs((sinh(x) - sinh_x)/sinh_x) <= eps)) {
+			atf_tc_fail_nonfatal("sinh(%.17g) = %.17g != %.17g\n",
+			    x, sinh(x), sinh_x);
+		}
 	}
 }
 
@@ -163,18 +162,17 @@ ATF_TC_HEAD(sinhf_inrange, tc)
 
 ATF_TC_BODY(sinhf_inrange, tc)
 {
-	float eps;
-	float x;
-	float y;
+	const float eps = FLT_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(values); i++) {
-		x = values[i].x;
-		y = values[i].y;
-		eps = 1e-6 * values[i].e;
+		float x = values[i].x;
+		float sinh_x = values[i].y;
 
-		if (fabsf(sinhf(x) - y) > eps)
-			atf_tc_fail_nonfatal("sinhf(%g) != %g\n", x, y);
+		if (!(fabsf((sinhf(x) - sinh_x)/sinh_x) <= eps)) {
+			atf_tc_fail_nonfatal("sinhf(%.8g) = %.8g != %.8g\n",
+			    (double)x, (double)sinhf(x), (double)sinh_x);
+		}
 	}
 }
 
diff --git a/contrib/netbsd-tests/lib/libm/t_sqrt.c b/contrib/netbsd-tests/lib/libm/t_sqrt.c
index 1d551ec3101d..080aff1c40e8 100644
--- a/contrib/netbsd-tests/lib/libm/t_sqrt.c
+++ b/contrib/netbsd-tests/lib/libm/t_sqrt.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_sqrt.c,v 1.7 2014/03/12 21:40:07 martin Exp $ */
+/* $NetBSD: t_sqrt.c,v 1.8 2018/11/07 03:59:36 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,7 +29,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_sqrt.c,v 1.7 2014/03/12 21:40:07 martin Exp $");
+__RCSID("$NetBSD: t_sqrt.c,v 1.8 2018/11/07 03:59:36 riastradh Exp $");
 
 #include <atf-c.h>
 #include <math.h>
@@ -62,22 +62,25 @@ ATF_TC_HEAD(sqrt_pow, tc)
 ATF_TC_BODY(sqrt_pow, tc)
 {
 	const double x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.9999 };
-#if __DBL_MIN_10_EXP__ <= -40
-	const double eps = 1.0e-40;
-#else
-	const double eps = __DBL_MIN__*4.0;
-#endif
-	double y, z;
+	const double eps = DBL_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(x); i++) {
-
-		y = sqrt(x[i]);
-		z = pow(x[i], 1.0 / 2.0);
-
-		if (fabs(y - z) > eps)
-			atf_tc_fail_nonfatal("sqrt(%0.03f) != "
-			    "pow(%0.03f, 1/2)\n", x[i], x[i]);
+		double x_sqrt = sqrt(x[i]);
+		double x_pow12 = pow(x[i], 1.0 / 2.0);
+		bool ok;
+
+		if (x[i] == 0) {
+			ok = (x_sqrt == x_pow12);
+		} else {
+			ok = (fabs((x_sqrt - x_pow12)/x_sqrt) <= eps);
+		}
+
+		if (!ok) {
+			atf_tc_fail_nonfatal("sqrt(%.17g) = %.17g != "
+			    "pow(%.17g, 1/2) = %.17g\n",
+			    x[i], x_sqrt, x[i], x_pow12);
+		}
 	}
 }
 
@@ -166,18 +169,26 @@ ATF_TC_HEAD(sqrtf_powf, tc)
 ATF_TC_BODY(sqrtf_powf, tc)
 {
 	const float x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.9999 };
-	const float eps = 1.0e-30;
-	volatile float y, z;
+	const float eps = FLT_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(x); i++) {
-
-		y = sqrtf(x[i]);
-		z = powf(x[i], 1.0 / 2.0);
-
-		if (fabsf(y - z) > eps)
-			atf_tc_fail_nonfatal("sqrtf(%0.03f) != "
-			    "powf(%0.03f, 1/2)\n", x[i], x[i]);
+		float x_sqrt = sqrtf(x[i]);
+		float x_pow12 = powf(x[i], 1.0 / 2.0);
+		bool ok;
+
+		if (x[i] == 0) {
+			ok = (x_sqrt == x_pow12);
+		} else {
+			ok = (fabsf((x_sqrt - x_pow12)/x_sqrt) <= eps);
+		}
+
+		if (!ok) {
+			atf_tc_fail_nonfatal("sqrtf(%.8g) = %.8g != "
+			    "powf(%.8g, 1/2) = %.8g\n",
+			    (double)x[i], (double)x_sqrt,
+			    (double)x[i], (double)x_pow12);
+		}
 	}
 }
 
@@ -266,18 +277,25 @@ ATF_TC_HEAD(sqrtl_powl, tc)
 ATF_TC_BODY(sqrtl_powl, tc)
 {
 	const long double x[] = { 0.0, 0.005, 1.0, 99.0, 123.123, 9999.9999 };
-	const long double eps = 5.0*DBL_EPSILON; /* XXX powl == pow for now */
-	volatile long double y, z;
+	const long double eps = DBL_EPSILON; /* XXX powl == pow for now */
 	size_t i;
 
 	for (i = 0; i < __arraycount(x); i++) {
-
-		y = sqrtl(x[i]);
-		z = powl(x[i], 1.0 / 2.0);
-
-		if (fabsl(y - z) > eps)
-			atf_tc_fail_nonfatal("sqrtl(%0.03Lf) != "
-			    "powl(%0.03Lf, 1/2)\n", x[i], x[i]);
+		long double x_sqrt = sqrtl(x[i]);
+		long double x_pow12 = powl(x[i], 1.0 / 2.0);
+		bool ok;
+
+		if (x[i] == 0) {
+			ok = (x_sqrt == x_pow12);
+		} else {
+			ok = (fabsl((x_sqrt - x_pow12)/x_sqrt) <= eps);
+		}
+
+		if (!ok) {
+			atf_tc_fail_nonfatal("sqrtl(%.35Lg) = %.35Lg != "
+			    "powl(%.35Lg, 1/2) = %.35Lg\n",
+			    x[i], x_sqrt, x[i], x_pow12);
+		}
 	}
 }
 
diff --git a/contrib/netbsd-tests/lib/libm/t_tan.c b/contrib/netbsd-tests/lib/libm/t_tan.c
index 807e3d1f3364..1bbc4b4d4c95 100644
--- a/contrib/netbsd-tests/lib/libm/t_tan.c
+++ b/contrib/netbsd-tests/lib/libm/t_tan.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_tan.c,v 1.5 2014/03/03 10:39:08 martin Exp $ */
+/* $NetBSD: t_tan.c,v 1.7 2018/11/07 04:00:13 riastradh Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -29,26 +29,29 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <assert.h>
 #include <atf-c.h>
+#include <float.h>
 #include <math.h>
 
 static const struct {
 	int		angle;
 	double		x;
 	double		y;
+	float		fy;
 } angles[] = {
-	{ -180, -3.141592653589793,  0.0000000000000000 },
-	{ -135, -2.356194490192345,  1.0000000000000000 },
-	{  -45, -0.785398163397448, -1.0000000000000000 },
-	{    0,  0.000000000000000,  0.0000000000000000 },
-	{   30,  0.523598775598299,  0.5773502691896258 },
-	{   45,  0.785398163397448,  1.0000000000000000 },
-	{   60,  1.047197551196598,  1.7320508075688773 },
-	{  120,  2.094395102393195, -1.7320508075688773 },
-	{  135,  2.356194490192345, -1.0000000000000000 },
-	{  150,  2.617993877991494, -0.5773502691896258 },
-	{  180,  3.141592653589793,  0.0000000000000000 },
-	{  360,  6.283185307179586,  0.0000000000000000 }
+	{ -180, -3.141592653589793,  1.2246467991473532e-16, -8.7422777e-08 },
+	{ -135, -2.356194490192345,  1.0000000000000002, 999 },
+	{  -45, -0.785398163397448, -0.9999999999999992, 999 },
+	{    0,  0.000000000000000,  0.0000000000000000, 999 },
+	{   30,  0.5235987755982988, 0.57735026918962573, 999 },
+	{   45,  0.785398163397448,  0.9999999999999992, 999 },
+	{   60,  1.047197551196598,  1.7320508075688785,  1.7320509 },
+	{  120,  2.094395102393195, -1.7320508075688801, -1.7320505 },
+	{  135,  2.356194490192345, -1.0000000000000002, 999 },
+	{  150,  2.617993877991494, -0.57735026918962629, -0.57735032 },
+	{  180,  3.141592653589793, -1.2246467991473532e-16, 8.7422777e-08 },
+	{  360,  6.283185307179586, -2.4492935982947064e-16, 1.7484555e-07 },
 };
 
 /*
@@ -62,14 +65,29 @@ ATF_TC_HEAD(tan_angles, tc)
 
 ATF_TC_BODY(tan_angles, tc)
 {
-	const double eps = 1.0e-14;
+	const double eps = DBL_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(angles); i++) {
-
-		if (fabs(tan(angles[i].x) - angles[i].y) > eps)
-			atf_tc_fail_nonfatal("tan(%d deg) != %0.01f",
-			    angles[i].angle, angles[i].y);
+		int deg = angles[i].angle;
+		double theta = angles[i].x;
+		double tan_theta = angles[i].y;
+		bool ok;
+
+		if (theta == 0) {
+			/* Should be computed exactly.  */
+			assert(tan_theta == 0);
+			ok = (tan(theta) == 0);
+		} else {
+			assert(tan_theta != 0);
+			ok = (fabs((tan(theta) - tan_theta)/tan_theta) <= eps);
+		}
+
+		if (!ok) {
+			atf_tc_fail_nonfatal("tan(%d deg = %.17g) = %.17g"
+			    " != %.17g",
+			    deg, theta, tan(theta), tan_theta);
+		}
 	}
 }
 
@@ -151,18 +169,32 @@ ATF_TC_HEAD(tanf_angles, tc)
 
 ATF_TC_BODY(tanf_angles, tc)
 {
-	const float eps = 1.0e-6;
-	float x, y;
+	const float eps = FLT_EPSILON;
 	size_t i;
 
 	for (i = 0; i < __arraycount(angles); i++) {
-
-		x = angles[i].x;
-		y = angles[i].y;
-
-		if (fabsf(tanf(x) - y) > eps)
-			atf_tc_fail_nonfatal("tanf(%d deg) != %0.01f",
-			    angles[i].angle, angles[i].y);
+		int deg = angles[i].angle;
+		float theta = angles[i].x;
+		float tan_theta = angles[i].fy;
+		bool ok;
+
+		if (tan_theta == 999)
+			tan_theta = angles[i].y;
+
+		if (theta == 0) {
+			/* Should be computed exactly.  */
+			assert(tan_theta == 0);
+			ok = (tan(theta) == 0);
+		} else {
+			assert(tan_theta != 0);
+			ok = (fabsf((tanf(theta) - tan_theta)/tan_theta)
+			    <= eps);
+		}
+
+		if (!ok) {
+			atf_tc_fail_nonfatal("tanf(%d deg) = %.8g != %.8g",
+			    deg, tanf(theta), tan_theta);
+		}
 	}
 }