Merge remote-tracking branch 'origin/stable/10' into devel

28 files changed, 2078 insertions, 66 deletions

diff --git a/lib/Makefile b/lib/Makefile
index 250d583..742bd5e 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -84,7 +84,7 @@ SUBDIR=	${SUBDIR_ORDERED} \
 	libsbuf \
 	${_libsdp} \
 	${_libsm} \
-	${_libsmb} \
+	libsmb \
 	${_libsmdb} \
 	${_libsmutil} \
 	libstand \
@@ -214,7 +214,6 @@ _libypclnt=	libypclnt
 .endif
 
 .if ${MACHINE_CPUARCH} == "i386" || ${MACHINE_CPUARCH} == "amd64"
-_libsmb=	libsmb
 _libvgl=	libvgl
 _libproc=	libproc
 _librtld_db=	librtld_db
@@ -228,7 +227,6 @@ _libvmmapi=	libvmmapi
 
 .if ${MACHINE_CPUARCH} == "ia64"
 _libefi=	libefi
-_libsmb=	libsmb
 .endif
 
 .if ${MACHINE_CPUARCH} == "mips"
@@ -239,11 +237,6 @@ _librtld_db=	librtld_db
 .if ${MACHINE_CPUARCH} == "powerpc"
 _libproc=	libproc
 _librtld_db=	librtld_db
-_libsmb=	libsmb
-.endif
-
-.if ${MACHINE_CPUARCH} == "sparc64"
-_libsmb=	libsmb
 .endif
 
 .if ${MK_OPENSSL} != "no"
diff --git a/lib/libc/net/if_nametoindex.c b/lib/libc/net/if_nametoindex.c
index 8f04921..debf3fa 100644
--- a/lib/libc/net/if_nametoindex.c
+++ b/lib/libc/net/if_nametoindex.c
@@ -70,9 +70,7 @@ if_nametoindex(const char *ifname)
 
 	s = _socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 	if (s != -1) {
-#ifdef PURIFY
 		memset(&ifr, 0, sizeof(ifr));
-#endif
 		strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
 		if (_ioctl(s, SIOCGIFINDEX, &ifr) != -1) {
 			_close(s);
diff --git a/lib/libc/rpc/rpc_soc.c b/lib/libc/rpc/rpc_soc.c
index 8d0f34e..ff7a289 100644
--- a/lib/libc/rpc/rpc_soc.c
+++ b/lib/libc/rpc/rpc_soc.c
@@ -525,7 +525,7 @@ svcunix_create(sock, sendsize, recvsize, path)
 			break;
 	}
 	if (nconf == NULL)
-		return(xprt);
+		goto done;
 
 	if ((sock = __rpc_nconf2fd(nconf)) < 0)
 		goto done;
diff --git a/lib/libc/rpc/rpcb_clnt.c b/lib/libc/rpc/rpcb_clnt.c
index 943d7c8..117ee0f 100644
--- a/lib/libc/rpc/rpcb_clnt.c
+++ b/lib/libc/rpc/rpcb_clnt.c
@@ -675,11 +675,11 @@ __rpcbind_is_up()
 		    strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0)
 			 break;
 	}
+	endnetconfig(localhandle);
+
 	if (nconf == NULL)
 		return (FALSE);
 
-	endnetconfig(localhandle);
-
 	memset(&sun, 0, sizeof sun);
 	sock = _socket(AF_LOCAL, SOCK_STREAM, 0);
 	if (sock < 0)
diff --git a/lib/libc/rpc/rpcb_prot.c b/lib/libc/rpc/rpcb_prot.c
index f543aaf..92463c0 100644
--- a/lib/libc/rpc/rpcb_prot.c
+++ b/lib/libc/rpc/rpcb_prot.c
@@ -217,14 +217,14 @@ xdr_rpcb_entry_list_ptr(xdrs, rp)
 		 * the case of freeing we must remember the next object
 		 * before we free the current object ...
 		 */
-		if (freeing)
+		if (freeing && *rp)
 			next = (*rp)->rpcb_entry_next;
 		if (! xdr_reference(xdrs, (caddr_t *)rp,
 		    (u_int)sizeof (rpcb_entry_list),
 				    (xdrproc_t)xdr_rpcb_entry)) {
 			return (FALSE);
 		}
-		if (freeing && *rp) {
+		if (freeing) {
 			next_copy = next;
 			rp = &next_copy;
 			/*
diff --git a/lib/libc/string/wcslcat.c b/lib/libc/string/wcslcat.c
index f5f1e1e..2df9477 100644
--- a/lib/libc/string/wcslcat.c
+++ b/lib/libc/string/wcslcat.c
@@ -54,7 +54,7 @@ wcslcat(wchar_t *dst, const wchar_t *src, size_t siz)
 	size_t dlen;
 
 	/* Find the end of dst and adjust bytes left but don't go past end */
-	while (*d != '\0' && n-- != 0)
+	while (n-- != 0 && *d != '\0')
 		d++;
 	dlen = d - dst;
 	n = siz - dlen;
diff --git a/lib/libc/string/wcsncat.c b/lib/libc/string/wcsncat.c
index 44f1ff9..5a24347 100644
--- a/lib/libc/string/wcsncat.c
+++ b/lib/libc/string/wcsncat.c
@@ -48,7 +48,7 @@ wcsncat(wchar_t * __restrict s1, const wchar_t * __restrict s2, size_t n)
 		p++;
 	q = p;
 	r = s2;
-	while (*r && n) {
+	while (n && *r) {
 		*q++ = *r++;
 		n--;
 	}
diff --git a/lib/libc/sys/futimens.c b/lib/libc/sys/futimens.c
index 2014cc5..59fb37f 100644
--- a/lib/libc/sys/futimens.c
+++ b/lib/libc/sys/futimens.c
@@ -42,8 +42,11 @@ futimens(int fd, const struct timespec times[2])
 {
 	struct timeval now, tv[2], *tvp;
 	struct stat sb;
+	int osreldate;
 
-	if (__getosreldate() >= 1100056)
+	osreldate = __getosreldate();
+	if (osreldate >= 1100056 ||
+	    (osreldate >= 1002506 && osreldate < 1100000))
 		return (__sys_futimens(fd, times));
 
 	if (times == NULL || (times[0].tv_nsec == UTIME_NOW &&
diff --git a/lib/libc/sys/utimensat.2 b/lib/libc/sys/utimensat.2
index 0f397c6..a714b34 100644
--- a/lib/libc/sys/utimensat.2
+++ b/lib/libc/sys/utimensat.2
@@ -31,7 +31,7 @@
 .\"     @(#)utimes.2	8.1 (Berkeley) 6/4/93
 .\" $FreeBSD$
 .\"
-.Dd January 23, 2015
+.Dd January 17, 2016
 .Dt UTIMENSAT 2
 .Os
 .Sh NAME
@@ -183,10 +183,13 @@ argument
 points outside the process's allocated address space.
 .It Bq Er EINVAL
 The
-.Va tv_usec
+.Va tv_nsec
 component of at least one of the values specified by the
 .Fa times
-argument has a value less than 0 or greater than 999999.
+argument has a value less than 0 or greater than 999999999 and is not equal to
+.Dv UTIME_NOW
+or
+.Dv UTIME_OMIT .
 .It Bq Er EIO
 An I/O error occurred while reading or writing the affected inode.
 .It Bq Er EPERM
@@ -289,4 +292,4 @@ The
 and
 .Fn utimensat
 system calls appeared in
-.Fx 11.0 .
+.Fx 10.3 .
diff --git a/lib/libc/sys/utimensat.c b/lib/libc/sys/utimensat.c
index 67d19cb..a1c3c21 100644
--- a/lib/libc/sys/utimensat.c
+++ b/lib/libc/sys/utimensat.c
@@ -42,8 +42,11 @@ utimensat(int fd, const char *path, const struct timespec times[2], int flag)
 {
 	struct timeval now, tv[2], *tvp;
 	struct stat sb;
+	int osreldate;
 
-	if (__getosreldate() >= 1100056)
+	osreldate = __getosreldate();
+	if (osreldate >= 1100056 ||
+	    (osreldate >= 1002506 && osreldate < 1100000))
 		return (__sys_utimensat(fd, path, times, flag));
 
 	if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0) {
diff --git a/lib/libc/tests/net/Makefile b/lib/libc/tests/net/Makefile
index a88f44f..fb76f26 100644
--- a/lib/libc/tests/net/Makefile
+++ b/lib/libc/tests/net/Makefile
@@ -28,6 +28,8 @@ PROGS+=		h_dns_server
 DPADD.h_nsd_recurse+=	${LIBPTHREAD}
 LDADD.h_nsd_recurse+=	-lpthread
 
+__MAKE_SHELL?=	/bin/sh
+
 CLEANFILES+=	aton_ether_subr.c
 aton_ether_subr.c: gen_ether_subr ${.CURDIR:H:H:H:H}/sys/net/if_ethersubr.c
 	${__MAKE_SHELL} ${.ALLSRC} ${.TARGET}
diff --git a/lib/libfetch/common.c b/lib/libfetch/common.c
index eabea2b..ae8b79d 100644
--- a/lib/libfetch/common.c
+++ b/lib/libfetch/common.c
@@ -495,7 +495,8 @@ fetch_ssl_get_numeric_addrinfo(const char *hostname, size_t len)
 	hints.ai_protocol = 0;
 	hints.ai_flags = AI_NUMERICHOST;
 	/* port is not relevant for this purpose */
-	getaddrinfo(host, "443", &hints, &res);
+	if (getaddrinfo(host, "443", &hints, &res) != 0)
+		res = NULL;
 	free(host);
 	return res;
 }
@@ -672,9 +673,7 @@ fetch_ssl_setup_transport_layer(SSL_CTX *ctx, int verbose)
 {
 	long ssl_ctx_options;
 
-	ssl_ctx_options = SSL_OP_ALL | SSL_OP_NO_TICKET;
-	if (getenv("SSL_ALLOW_SSL2") == NULL)
-		ssl_ctx_options |= SSL_OP_NO_SSLv2;
+	ssl_ctx_options = SSL_OP_ALL | SSL_OP_NO_SSLv2 | SSL_OP_NO_TICKET;
 	if (getenv("SSL_ALLOW_SSL3") == NULL)
 		ssl_ctx_options |= SSL_OP_NO_SSLv3;
 	if (getenv("SSL_NO_TLS1") != NULL)
diff --git a/lib/libfetch/fetch.3 b/lib/libfetch/fetch.3
index 139363f..0ddc2c2 100644
--- a/lib/libfetch/fetch.3
+++ b/lib/libfetch/fetch.3
@@ -26,7 +26,7 @@
 .\"
 .\" $FreeBSD$
 .\"
-.Dd October 15, 2014
+.Dd November 29, 2015
 .Dt FETCH 3
 .Os
 .Sh NAME
@@ -441,10 +441,8 @@ By default
 allows TLSv1 and newer when negotiating the connecting with the remote
 peer.
 You can change this behavior by setting the
-.Ev SSL_ALLOW_SSL2
-and
 .Ev SSL_ALLOW_SSL3
-environment variables to allow SSLv2 and SSLv3, respectively, and
+environment variable to allow SSLv3 and
 .Ev SSL_NO_TLS1 ,
 .Ev SSL_NO_TLS1_1 and
 .Ev SSL_NO_TLS1_2
@@ -633,11 +631,11 @@ If defined but empty, no User-Agent header is sent.
 .It Ev NETRC
 Specifies a file to use instead of
 .Pa ~/.netrc
-to look up login names and passwords for FTP sites.
+to look up login names and passwords for FTP and HTTP sites as well as
+HTTP proxies.
 See
 .Xr ftp 1
 for a description of the file format.
-This feature is experimental.
 .It Ev NO_PROXY
 Either a single asterisk, which disables the use of proxies
 altogether, or a comma- or whitespace-separated list of hosts for
@@ -646,8 +644,6 @@ which proxies should not be used.
 Same as
 .Ev NO_PROXY ,
 for compatibility.
-.It Ev SSL_ALLOW_SSL2
-Allow SSL version 2 when negotiating the connection (not recommended).
 .It Ev SSL_ALLOW_SSL3
 Allow SSL version 3 when negotiating the connection (not recommended).
 .It Ev SSL_CA_CERT_FILE
diff --git a/lib/libfetch/file.c b/lib/libfetch/file.c
index 8c1d404..7b6462f 100644
--- a/lib/libfetch/file.c
+++ b/lib/libfetch/file.c
@@ -48,7 +48,7 @@ fetchXGetFile(struct url *u, struct url_stat *us, const char *flags)
 	if (us && fetchStatFile(u, us, flags) == -1)
 		return (NULL);
 
-	f = fopen(u->doc, "r");
+	f = fopen(u->doc, "re");
 
 	if (f == NULL) {
 		fetch_syserr();
@@ -61,7 +61,6 @@ fetchXGetFile(struct url *u, struct url_stat *us, const char *flags)
 		return (NULL);
 	}
 
-	fcntl(fileno(f), F_SETFD, FD_CLOEXEC);
 	return (f);
 }
 
@@ -77,9 +76,9 @@ fetchPutFile(struct url *u, const char *flags)
 	FILE *f;
 
 	if (CHECK_FLAG('a'))
-		f = fopen(u->doc, "a");
+		f = fopen(u->doc, "ae");
 	else
-		f = fopen(u->doc, "w+");
+		f = fopen(u->doc, "w+e");
 
 	if (f == NULL) {
 		fetch_syserr();
@@ -92,7 +91,6 @@ fetchPutFile(struct url *u, const char *flags)
 		return (NULL);
 	}
 
-	fcntl(fileno(f), F_SETFD, FD_CLOEXEC);
 	return (f);
 }
 
diff --git a/lib/libfetch/http.c b/lib/libfetch/http.c
index e0c2979..206648d 100644
--- a/lib/libfetch/http.c
+++ b/lib/libfetch/http.c
@@ -130,8 +130,8 @@ struct httpio
 	int		 chunked;	/* chunked mode */
 	char		*buf;		/* chunk buffer */
 	size_t		 bufsize;	/* size of chunk buffer */
-	ssize_t		 buflen;	/* amount of data currently in buffer */
-	int		 bufpos;	/* current read offset in buffer */
+	size_t		 buflen;	/* amount of data currently in buffer */
+	size_t		 bufpos;	/* current read offset in buffer */
 	int		 eof;		/* end-of-file flag */
 	int		 error;		/* error flag */
 	size_t		 chunksize;	/* remaining size of current chunk */
@@ -215,6 +215,7 @@ http_fillbuf(struct httpio *io, size_t len)
 	if (io->eof)
 		return (0);
 
+	/* not chunked: just fetch the requested amount */
 	if (io->chunked == 0) {
 		if (http_growbuf(io, len) == -1)
 			return (-1);
@@ -227,6 +228,7 @@ http_fillbuf(struct httpio *io, size_t len)
 		return (io->buflen);
 	}
 
+	/* chunked, but we ran out: get the next chunk header */
 	if (io->chunksize == 0) {
 		switch (http_new_chunk(io)) {
 		case -1:
@@ -238,6 +240,7 @@ http_fillbuf(struct httpio *io, size_t len)
 		}
 	}
 
+	/* fetch the requested amount, but no more than the current chunk */
 	if (len > io->chunksize)
 		len = io->chunksize;
 	if (http_growbuf(io, len) == -1)
@@ -246,8 +249,9 @@ http_fillbuf(struct httpio *io, size_t len)
 		io->error = errno;
 		return (-1);
 	}
+	io->bufpos = 0;
 	io->buflen = nbytes;
-	io->chunksize -= io->buflen;
+	io->chunksize -= nbytes;
 
 	if (io->chunksize == 0) {
 		if (fetch_read(io->conn, &ch, 1) != 1 || ch != '\r' ||
@@ -255,8 +259,6 @@ http_fillbuf(struct httpio *io, size_t len)
 			return (-1);
 	}
 
-	io->bufpos = 0;
-
 	return (io->buflen);
 }
 
@@ -1330,7 +1332,6 @@ static int
 http_authorize(conn_t *conn, const char *hdr, http_auth_challenges_t *cs,
 	       http_auth_params_t *parms, struct url *url)
 {
-	http_auth_challenge_t *basic = NULL;
 	http_auth_challenge_t *digest = NULL;
 	int i;
 
@@ -1340,10 +1341,8 @@ http_authorize(conn_t *conn, const char *hdr, http_auth_challenges_t *cs,
 		return (-1);
 	}
 
-	/* Look for a Digest and a Basic challenge */
+	/* Look for a Digest */
 	for (i = 0; i < cs->count; i++) {
-		if (cs->challenges[i]->scheme == HTTPAS_BASIC)
-			basic = cs->challenges[i];
 		if (cs->challenges[i]->scheme == HTTPAS_DIGEST)
 			digest = cs->challenges[i];
 	}
@@ -1379,8 +1378,12 @@ http_connect(struct url *URL, struct url *purl, const char *flags)
 {
 	struct url *curl;
 	conn_t *conn;
+	hdr_t h;
+	http_headerbuf_t headerbuf;
+	const char *p;
 	int verbose;
 	int af, val;
+	int serrno;
 
 #ifdef INET6
 	af = AF_UNSPEC;
@@ -1401,6 +1404,7 @@ http_connect(struct url *URL, struct url *purl, const char *flags)
 	if ((conn = fetch_connect(curl->host, curl->port, af, verbose)) == NULL)
 		/* fetch_connect() has already set an error code */
 		return (NULL);
+	init_http_headerbuf(&headerbuf);
 	if (strcasecmp(URL->scheme, SCHEME_HTTPS) == 0 && purl) {
 		http_cmd(conn, "CONNECT %s:%d HTTP/1.1",
 		    URL->host, URL->port);
@@ -1408,10 +1412,26 @@ http_connect(struct url *URL, struct url *purl, const char *flags)
 		    URL->host, URL->port);
 		http_cmd(conn, "");
 		if (http_get_reply(conn) != HTTP_OK) {
-			fetch_close(conn);
-			return (NULL);
+			http_seterr(conn->err);
+			goto ouch;
+		}
+		/* Read and discard the rest of the proxy response */
+		if (fetch_getln(conn) < 0) {
+			fetch_syserr();
+			goto ouch;
 		}
-		http_get_reply(conn);
+		do {
+			switch ((h = http_next_header(conn, &headerbuf, &p))) {
+			case hdr_syserror:
+				fetch_syserr();
+				goto ouch;
+			case hdr_error:
+				http_seterr(HTTP_PROTOCOL_ERROR);
+				goto ouch;
+			default:
+				/* ignore */ ;
+			}
+		} while (h < hdr_end);
 	}
 	if (strcasecmp(URL->scheme, SCHEME_HTTPS) == 0 &&
 	    fetch_ssl(conn, URL, verbose) == -1) {
@@ -1419,13 +1439,20 @@ http_connect(struct url *URL, struct url *purl, const char *flags)
 		/* grrr */
 		errno = EAUTH;
 		fetch_syserr();
-		return (NULL);
+		goto ouch;
 	}
 
 	val = 1;
 	setsockopt(conn->sd, IPPROTO_TCP, TCP_NOPUSH, &val, sizeof(val));
 
+	clean_http_headerbuf(&headerbuf);
 	return (conn);
+ouch:
+	serrno = errno;
+	clean_http_headerbuf(&headerbuf);
+	fetch_close(conn);
+	errno = serrno;
+	return (NULL);
 }
 
 static struct url *
@@ -1633,6 +1660,9 @@ http_request_body(struct url *URL, const char *op, struct url_stat *us,
 					http_seterr(HTTP_NEED_PROXY_AUTH);
 					goto ouch;
 				}
+			} else if (fetch_netrc_auth(purl) == 0) {
+				aparams.user = strdup(purl->user);
+				aparams.password = strdup(purl->pwd);
 			}
 			http_authorize(conn, "Proxy-Authorization",
 				       &proxy_challenges, &aparams, url);
@@ -1660,6 +1690,9 @@ http_request_body(struct url *URL, const char *op, struct url_stat *us,
 					http_seterr(HTTP_NEED_AUTH);
 					goto ouch;
 				}
+			} else if (fetch_netrc_auth(url) == 0) {
+				aparams.user = strdup(url->user);
+				aparams.password = strdup(url->pwd);
 			} else if (fetchAuthMethod &&
 				   fetchAuthMethod(url) == 0) {
 				aparams.user = strdup(url->user);
diff --git a/lib/libpam/Makefile.inc b/lib/libpam/Makefile.inc
index d2d1d42..59a8ced 100644
--- a/lib/libpam/Makefile.inc
+++ b/lib/libpam/Makefile.inc
@@ -27,7 +27,6 @@
 CFLAGS+=	-DOPENPAM_DEBUG
 
 SHLIB_MAJOR=	5
-PAM_MOD_DIR=	${LIBDIR}
 
 STATIC_CFLAGS+=	-DOPENPAM_STATIC_MODULES
 
diff --git a/lib/libpam/libpam/Makefile b/lib/libpam/libpam/Makefile
index 62293e3..105748e 100644
--- a/lib/libpam/libpam/Makefile
+++ b/lib/libpam/libpam/Makefile
@@ -155,7 +155,6 @@ MLINKS=	pam.conf.5 pam.d.5
 CSTD?= c99
 CFLAGS+= -I${.CURDIR} -I${OPENPAM}/include
 CFLAGS+= -DLIB_MAJ=${SHLIB_MAJOR}
-CFLAGS+= -DOPENPAM_MODULES_DIR='"${PAM_MOD_DIR:C/\/*$//}/"'
 CFLAGS+= -DHAVE_DLFUNC=1
 CFLAGS+= -DHAVE_FDLOPEN=1
 CFLAGS+= -DHAVE_FPURGE=1
diff --git a/lib/libstand/Makefile b/lib/libstand/Makefile
index 7c253c8..893ed68 100644
--- a/lib/libstand/Makefile
+++ b/lib/libstand/Makefile
@@ -59,8 +59,8 @@ SRCS+= ntoh.c
 .if ${MACHINE_CPUARCH} != "ia64"
 SRCS+=	bcmp.c bcopy.c bzero.c ffs.c memccpy.c memchr.c memcmp.c memcpy.c \
 	memmove.c memset.c qdivrem.c strcat.c strchr.c strcmp.c strcpy.c \
-	strcspn.c strlen.c strncat.c strncmp.c strncpy.c strpbrk.c \
-	strrchr.c strsep.c strspn.c strstr.c strtok.c swab.c
+	strcspn.c strlcat.c strlcpy.c strlen.c strncat.c strncmp.c strncpy.c \
+	strpbrk.c strrchr.c strsep.c strspn.c strstr.c strtok.c swab.c
 .endif
 .if ${MACHINE_CPUARCH} == "arm"
 .PATH: ${.CURDIR}/../libc/arm/gen
@@ -86,6 +86,7 @@ SRCS+=	aeabi_memcmp.S aeabi_memcpy.S aeabi_memmove.S aeabi_memset.S
 .PATH: ${.CURDIR}/../libc/ia64/string
 SRCS+=	bcmp.c bcopy.S bzero.S ffs.S memccpy.c memchr.c memcmp.c memcpy.S \
 	memmove.S memset.c strcat.c strchr.c strcmp.c strcpy.c strcspn.c \
+	strlcat.c strlcpy.c \
 	strlen.c strncat.c strncmp.c strncpy.c strpbrk.c strrchr.c strsep.c \
 	strspn.c strstr.c strtok.c swab.c
 
diff --git a/lib/libstand/bootp.c b/lib/libstand/bootp.c
index 904b3ba..1af7bd5 100644
--- a/lib/libstand/bootp.c
+++ b/lib/libstand/bootp.c
@@ -354,6 +354,7 @@ vend_rfc1048(cp, len)
 	u_char *ep;
 	int size;
 	u_char tag;
+	const char *val;
 
 #ifdef BOOTP_DEBUG
 	if (debug)
@@ -380,15 +381,17 @@ vend_rfc1048(cp, len)
 		}
 		if (tag == TAG_SWAPSERVER) {
 			/* let it override bp_siaddr */
-			bcopy(cp, &rootip.s_addr, sizeof(swapip.s_addr));
+			bcopy(cp, &rootip.s_addr, sizeof(rootip.s_addr));
 		}
 		if (tag == TAG_ROOTPATH) {
-			strncpy(rootpath, (char *)cp, sizeof(rootpath));
-			rootpath[size] = '\0';
+			if ((val = getenv("dhcp.root-path")) == NULL)
+				val = (const char *)cp;
+			strlcpy(rootpath, val, sizeof(rootpath));
 		}
 		if (tag == TAG_HOSTNAME) {
-			strncpy(hostname, (char *)cp, sizeof(hostname));
-			hostname[size] = '\0';
+			if ((val = getenv("dhcp.host-name")) == NULL)
+				val = (const char *)cp;
+			strlcpy(hostname, val, sizeof(hostname));
 		}
 #ifdef SUPPORT_DHCP
 		if (tag == TAG_DHCP_MSGTYPE) {
@@ -730,7 +733,11 @@ setenv_(u_char *cp,  u_char *ep, struct dhcp_opt *opts)
 		sprintf(env, op->desc, opts[0].desc, tag);
 	    else
 		sprintf(env, "%s%s", opts[0].desc, op->desc);
-	    setenv(env, buf, 1);
+	    /*
+	     * Do not replace existing values in the environment, so that
+	     * locally-obtained values can override server-provided values.
+	     */
+	    setenv(env, buf, 0);
 	}
     }
     if (tp != tags) {
diff --git a/lib/libthr/thread/thr_umtx.c b/lib/libthr/thread/thr_umtx.c
index a61dab0..37e5df1 100644
--- a/lib/libthr/thread/thr_umtx.c
+++ b/lib/libthr/thread/thr_umtx.c
@@ -42,7 +42,7 @@ int _umtx_op_err(void *obj, int op, u_long val, void *uaddr, void *uaddr2)
 void
 _thr_umutex_init(struct umutex *mtx)
 {
-	static struct umutex default_mtx = DEFAULT_UMUTEX;
+	static const struct umutex default_mtx = DEFAULT_UMUTEX;
 
 	*mtx = default_mtx;
 }
@@ -50,7 +50,8 @@ _thr_umutex_init(struct umutex *mtx)
 void
 _thr_urwlock_init(struct urwlock *rwl)
 {
-	static struct urwlock default_rwl = DEFAULT_URWLOCK;
+	static const struct urwlock default_rwl = DEFAULT_URWLOCK;
+
 	*rwl = default_rwl;
 }
 
diff --git a/lib/msun/tests/Makefile b/lib/msun/tests/Makefile
index ffa1765..2561ef7 100644
--- a/lib/msun/tests/Makefile
+++ b/lib/msun/tests/Makefile
@@ -39,12 +39,19 @@ NETBSD_ATF_TESTS_C+=	tanh_test
 TAP_TESTS_C+=	cexp_test
 TAP_TESTS_C+=	conj_test
 TAP_TESTS_C+=	csqrt_test
+TAP_TESTS_C+=	ctrig_test
+TAP_TESTS_C+=	exponential_test
 TAP_TESTS_C+=	fenv_test
+TAP_TESTS_C+=	fma_test
 TAP_TESTS_C+=	fmaxmin_test
 TAP_TESTS_C+=	ilogb_test
+TAP_TESTS_C+=	invtrig_test
 TAP_TESTS_C+=	invctrig_test
 TAP_TESTS_C+=	logarithm_test
 TAP_TESTS_C+=	lrint_test
+# XXX: the testcase crashes on all platforms, but only on head
+# (bug 205451)
+#TAP_TESTS_C+=	lround_test
 TAP_TESTS_C+=	nan_test
 TAP_TESTS_C+=	nearbyint_test
 TAP_TESTS_C+=	next_test
@@ -53,7 +60,6 @@ TAP_TESTS_C+=	trig_test
 
 .for t in ${TAP_TESTS_C}
 CFLAGS.$t+=	-O0
-CFLAGS.$t+=	-I${SRCTOP}/tools/regression/lib/msun
 .endfor
 
 CSTD=		c99
diff --git a/lib/msun/tests/ctrig_test.c b/lib/msun/tests/ctrig_test.c
new file mode 100644
index 0000000..475b6c5
--- /dev/null
+++ b/lib/msun/tests/ctrig_test.c
@@ -0,0 +1,482 @@
+/*-
+ * Copyright (c) 2008-2011 David Schultz <das@FreeBSD.org>
+ * All rights reserved.
+ *
+ * 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 AUTHOR 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 AUTHOR 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.
+ */
+
+/*
+ * Tests for csin[h](), ccos[h](), and ctan[h]().
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <assert.h>
+#include <complex.h>
+#include <fenv.h>
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+
+#include "test-utils.h"
+
+#pragma STDC FENV_ACCESS	ON
+#pragma	STDC CX_LIMITED_RANGE	OFF
+
+/*
+ * Test that a function returns the correct value and sets the
+ * exception flags correctly. The exceptmask specifies which
+ * exceptions we should check. We need to be lenient for several
+ * reasons, but mainly because on some architectures it's impossible
+ * to raise FE_OVERFLOW without raising FE_INEXACT.
+ *
+ * These are macros instead of functions so that assert provides more
+ * meaningful error messages.
+ *
+ * XXX The volatile here is to avoid gcc's bogus constant folding and work
+ *     around the lack of support for the FENV_ACCESS pragma.
+ */
+#define	test_p(func, z, result, exceptmask, excepts, checksign)	do {	\
+	volatile long double complex _d = z;				\
+	debug("  testing %s(%Lg + %Lg I) == %Lg + %Lg I\n", #func,	\
+	    creall(_d), cimagl(_d), creall(result), cimagl(result));	\
+	assert(feclearexcept(FE_ALL_EXCEPT) == 0);			\
+	assert(cfpequal_cs((func)(_d), (result), (checksign)));		\
+	assert(((void)(func), fetestexcept(exceptmask) == (excepts)));	\
+} while (0)
+
+/*
+ * Test within a given tolerance.  The tolerance indicates relative error
+ * in ulps.  If result is 0, however, it measures absolute error in units
+ * of <format>_EPSILON.
+ */
+#define	test_p_tol(func, z, result, tol)			do {	\
+	volatile long double complex _d = z;				\
+	debug("  testing %s(%Lg + %Lg I) ~= %Lg + %Lg I\n", #func,	\
+	    creall(_d), cimagl(_d), creall(result), cimagl(result));	\
+	assert(cfpequal_tol((func)(_d), (result), (tol), FPE_ABS_ZERO)); \
+} while (0)
+
+/* These wrappers apply the identities f(conj(z)) = conj(f(z)). */
+#define	test(func, z, result, exceptmask, excepts, checksign)	do {	\
+	test_p(func, z, result, exceptmask, excepts, checksign);	\
+	test_p(func, conjl(z), conjl(result), exceptmask, excepts, checksign); \
+} while (0)
+#define	test_tol(func, z, result, tol)				do {	\
+	test_p_tol(func, z, result, tol);				\
+	test_p_tol(func, conjl(z), conjl(result), tol);			\
+} while (0)
+#define	test_odd_tol(func, z, result, tol)			do {	\
+	test_tol(func, z, result, tol);					\
+	test_tol(func, -(z), -(result), tol);				\
+} while (0)
+#define	test_even_tol(func, z, result, tol)			do {	\
+	test_tol(func, z, result, tol);					\
+	test_tol(func, -(z), result, tol);				\
+} while (0)
+
+/* Test the given function in all precisions. */
+#define	testall(func, x, result, exceptmask, excepts, checksign) do {	\
+	test(func, x, result, exceptmask, excepts, checksign);		\
+	test(func##f, x, result, exceptmask, excepts, checksign);	\
+} while (0)
+#define	testall_odd(func, x, result, exceptmask, excepts, checksign) do { \
+	testall(func, x, result, exceptmask, excepts, checksign);	\
+	testall(func, -x, -result, exceptmask, excepts, checksign);	\
+} while (0)
+#define	testall_even(func, x, result, exceptmask, excepts, checksign) do { \
+	testall(func, x, result, exceptmask, excepts, checksign);	\
+	testall(func, -x, result, exceptmask, excepts, checksign);	\
+} while (0)
+
+/*
+ * Test the given function in all precisions, within a given tolerance.
+ * The tolerance is specified in ulps.
+ */
+#define	testall_tol(func, x, result, tol)	       		   do { \
+	test_tol(func, x, result, tol * DBL_ULP());			\
+	test_tol(func##f, x, result, tol * FLT_ULP());			\
+} while (0)
+#define	testall_odd_tol(func, x, result, tol)	       		   do { \
+	test_odd_tol(func, x, result, tol * DBL_ULP());			\
+	test_odd_tol(func##f, x, result, tol * FLT_ULP());		\
+} while (0)
+#define	testall_even_tol(func, x, result, tol)	       		   do { \
+	test_even_tol(func, x, result, tol * DBL_ULP());		\
+	test_even_tol(func##f, x, result, tol * FLT_ULP());		\
+} while (0)
+
+
+/* Tests for 0 */
+void
+test_zero(void)
+{
+	long double complex zero = CMPLXL(0.0, 0.0);
+
+	/* csinh(0) = ctanh(0) = 0; ccosh(0) = 1 (no exceptions raised) */
+	testall_odd(csinh, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH);
+	testall_odd(csin, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH);
+	testall_even(ccosh, zero, 1.0, ALL_STD_EXCEPT, 0, CS_BOTH);
+	testall_even(ccos, zero, CMPLXL(1.0, -0.0), ALL_STD_EXCEPT, 0, CS_BOTH);
+	testall_odd(ctanh, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH);
+	testall_odd(ctan, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH);
+}
+
+/*
+ * Tests for NaN inputs.
+ */
+void
+test_nan()
+{
+	long double complex nan_nan = CMPLXL(NAN, NAN);
+	long double complex z;
+
+	/*
+	 * IN		CSINH		CCOSH		CTANH
+	 * NaN,NaN	NaN,NaN		NaN,NaN		NaN,NaN
+	 * finite,NaN	NaN,NaN [inval]	NaN,NaN [inval]	NaN,NaN [inval]
+	 * NaN,finite	NaN,NaN [inval]	NaN,NaN [inval]	NaN,NaN [inval]
+	 * NaN,Inf	NaN,NaN [inval]	NaN,NaN	[inval]	NaN,NaN [inval]
+	 * Inf,NaN	+-Inf,NaN	Inf,NaN		1,+-0
+	 * 0,NaN	+-0,NaN		NaN,+-0		NaN,NaN	[inval]
+	 * NaN,0	NaN,0		NaN,+-0		NaN,0
+	 */
+	z = nan_nan;
+	testall_odd(csinh, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
+	testall_even(ccosh, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
+	testall_odd(ctanh, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
+	testall_odd(csin, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
+	testall_even(ccos, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
+	testall_odd(ctan, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
+
+	z = CMPLXL(42, NAN);
+	testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0);
+	/* XXX We allow a spurious inexact exception here. */
+	testall_odd(ctanh, z, nan_nan, OPT_INVALID & ~FE_INEXACT, 0, 0);
+	testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0);
+
+	z = CMPLXL(NAN, 42);
+	testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0);
+	/* XXX We allow a spurious inexact exception here. */
+	testall_odd(ctan, z, nan_nan, OPT_INVALID & ~FE_INEXACT, 0, 0);
+
+	z = CMPLXL(NAN, INFINITY);
+	testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_odd(csin, z, CMPLXL(NAN, INFINITY), ALL_STD_EXCEPT, 0, 0);
+	testall_even(ccos, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0,
+	    CS_IMAG);
+	testall_odd(ctan, z, CMPLXL(0, 1), ALL_STD_EXCEPT, 0, CS_IMAG);
+
+	z = CMPLXL(INFINITY, NAN);
+	testall_odd(csinh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, 0);
+	testall_even(ccosh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0,
+		     CS_REAL);
+	testall_odd(ctanh, z, CMPLXL(1, 0), ALL_STD_EXCEPT, 0, CS_REAL);
+	testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0);
+
+	z = CMPLXL(0, NAN);
+	testall_odd(csinh, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, 0);
+	testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0);
+	testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0);
+	testall_odd(csin, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, CS_REAL);
+	testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0);
+	testall_odd(ctan, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, CS_REAL);
+
+	z = CMPLXL(NAN, 0);
+	testall_odd(csinh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, CS_IMAG);
+	testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0);
+	testall_odd(ctanh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, CS_IMAG);
+	testall_odd(csin, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0);
+	testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0);
+	testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0);
+}
+
+void
+test_inf(void)
+{
+	static const long double finites[] = {
+	    0, M_PI / 4, 3 * M_PI / 4, 5 * M_PI / 4,
+	};
+	long double complex z, c, s;
+	int i;
+
+	/*
+	 * IN		CSINH		CCOSH		CTANH
+	 * Inf,Inf	+-Inf,NaN inval	+-Inf,NaN inval	1,+-0
+	 * Inf,finite	Inf cis(finite)	Inf cis(finite)	1,0 sin(2 finite)
+	 * 0,Inf	+-0,NaN	inval	NaN,+-0 inval	NaN,NaN	inval
+	 * finite,Inf	NaN,NaN inval	NaN,NaN inval	NaN,NaN inval
+	 */
+	z = CMPLXL(INFINITY, INFINITY);
+	testall_odd(csinh, z, CMPLXL(INFINITY, NAN),
+		    ALL_STD_EXCEPT, FE_INVALID, 0);
+	testall_even(ccosh, z, CMPLXL(INFINITY, NAN),
+		     ALL_STD_EXCEPT, FE_INVALID, 0);
+	testall_odd(ctanh, z, CMPLXL(1, 0), ALL_STD_EXCEPT, 0, CS_REAL);
+	testall_odd(csin, z, CMPLXL(NAN, INFINITY),
+		    ALL_STD_EXCEPT, FE_INVALID, 0);
+	testall_even(ccos, z, CMPLXL(INFINITY, NAN),
+		     ALL_STD_EXCEPT, FE_INVALID, 0);
+	testall_odd(ctan, z, CMPLXL(0, 1), ALL_STD_EXCEPT, 0, CS_REAL);
+
+	/* XXX We allow spurious inexact exceptions here (hard to avoid). */
+	for (i = 0; i < sizeof(finites) / sizeof(finites[0]); i++) {
+		z = CMPLXL(INFINITY, finites[i]);
+		c = INFINITY * cosl(finites[i]);
+		s = finites[i] == 0 ? finites[i] : INFINITY * sinl(finites[i]);
+		testall_odd(csinh, z, CMPLXL(c, s), OPT_INEXACT, 0, CS_BOTH);
+		testall_even(ccosh, z, CMPLXL(c, s), OPT_INEXACT, 0, CS_BOTH);
+		testall_odd(ctanh, z, CMPLXL(1, 0 * sin(finites[i] * 2)),
+			    OPT_INEXACT, 0, CS_BOTH);
+		z = CMPLXL(finites[i], INFINITY);
+		testall_odd(csin, z, CMPLXL(s, c), OPT_INEXACT, 0, CS_BOTH);
+		testall_even(ccos, z, CMPLXL(c, -s), OPT_INEXACT, 0, CS_BOTH);
+		testall_odd(ctan, z, CMPLXL(0 * sin(finites[i] * 2), 1),
+			    OPT_INEXACT, 0, CS_BOTH);
+	}
+
+	z = CMPLXL(0, INFINITY);
+	testall_odd(csinh, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
+	testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0);
+	testall_odd(ctanh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
+	z = CMPLXL(INFINITY, 0);
+	testall_odd(csin, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0);
+	testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0);
+	testall_odd(ctan, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
+
+	z = CMPLXL(42, INFINITY);
+	testall_odd(csinh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
+	testall_even(ccosh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
+	/* XXX We allow a spurious inexact exception here. */
+	testall_odd(ctanh, z, CMPLXL(NAN, NAN), OPT_INEXACT, FE_INVALID, 0);
+	z = CMPLXL(INFINITY, 42);
+	testall_odd(csin, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
+	testall_even(ccos, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
+	/* XXX We allow a spurious inexact exception here. */
+	testall_odd(ctan, z, CMPLXL(NAN, NAN), OPT_INEXACT, FE_INVALID, 0);
+}
+
+/* Tests along the real and imaginary axes. */
+void
+test_axes(void)
+{
+	static const long double nums[] = {
+	    M_PI / 4, M_PI / 2, 3 * M_PI / 4,
+	    5 * M_PI / 4, 3 * M_PI / 2, 7 * M_PI / 4,
+	};
+	long double complex z;
+	int i;
+
+	for (i = 0; i < sizeof(nums) / sizeof(nums[0]); i++) {
+		/* Real axis */
+		z = CMPLXL(nums[i], 0.0);
+		test_odd_tol(csinh, z, CMPLXL(sinh(nums[i]), 0), DBL_ULP());
+		test_even_tol(ccosh, z, CMPLXL(cosh(nums[i]), 0), DBL_ULP());
+		test_odd_tol(ctanh, z, CMPLXL(tanh(nums[i]), 0), DBL_ULP());
+		test_odd_tol(csin, z, CMPLXL(sin(nums[i]),
+		    copysign(0, cos(nums[i]))), DBL_ULP());
+		test_even_tol(ccos, z, CMPLXL(cos(nums[i]),
+		    -copysign(0, sin(nums[i]))), DBL_ULP());
+		test_odd_tol(ctan, z, CMPLXL(tan(nums[i]), 0), DBL_ULP());
+
+		test_odd_tol(csinhf, z, CMPLXL(sinhf(nums[i]), 0), FLT_ULP());
+		test_even_tol(ccoshf, z, CMPLXL(coshf(nums[i]), 0), FLT_ULP());
+		printf("%a %a\n", creal(z), cimag(z));
+		printf("%a %a\n", creal(ctanhf(z)), cimag(ctanhf(z)));
+		printf("%a\n", nextafterf(tanhf(nums[i]), INFINITY));
+		test_odd_tol(ctanhf, z, CMPLXL(tanhf(nums[i]), 0),
+			     1.3 * FLT_ULP());
+		test_odd_tol(csinf, z, CMPLXL(sinf(nums[i]),
+		    copysign(0, cosf(nums[i]))), FLT_ULP());
+		test_even_tol(ccosf, z, CMPLXL(cosf(nums[i]),
+		    -copysign(0, sinf(nums[i]))), 2 * FLT_ULP());
+		test_odd_tol(ctanf, z, CMPLXL(tanf(nums[i]), 0), FLT_ULP());
+
+		/* Imaginary axis */
+		z = CMPLXL(0.0, nums[i]);
+		test_odd_tol(csinh, z, CMPLXL(copysign(0, cos(nums[i])),
+						 sin(nums[i])), DBL_ULP());
+		test_even_tol(ccosh, z, CMPLXL(cos(nums[i]),
+		    copysign(0, sin(nums[i]))), DBL_ULP());
+		test_odd_tol(ctanh, z, CMPLXL(0, tan(nums[i])), DBL_ULP());
+		test_odd_tol(csin, z, CMPLXL(0, sinh(nums[i])), DBL_ULP());
+		test_even_tol(ccos, z, CMPLXL(cosh(nums[i]), -0.0), DBL_ULP());
+		test_odd_tol(ctan, z, CMPLXL(0, tanh(nums[i])), DBL_ULP());
+
+		test_odd_tol(csinhf, z, CMPLXL(copysign(0, cosf(nums[i])),
+						 sinf(nums[i])), FLT_ULP());
+		test_even_tol(ccoshf, z, CMPLXL(cosf(nums[i]),
+		    copysign(0, sinf(nums[i]))), FLT_ULP());
+		test_odd_tol(ctanhf, z, CMPLXL(0, tanf(nums[i])), FLT_ULP());
+		test_odd_tol(csinf, z, CMPLXL(0, sinhf(nums[i])), FLT_ULP());
+		test_even_tol(ccosf, z, CMPLXL(coshf(nums[i]), -0.0),
+			      FLT_ULP());
+		test_odd_tol(ctanf, z, CMPLXL(0, tanhf(nums[i])),
+			     1.3 * FLT_ULP());
+	}
+}
+
+void
+test_small(void)
+{
+	/*
+	 * z =  0.5 + i Pi/4
+	 *     sinh(z) = (sinh(0.5) + i cosh(0.5)) * sqrt(2)/2
+	 *     cosh(z) = (cosh(0.5) + i sinh(0.5)) * sqrt(2)/2
+	 *     tanh(z) = (2cosh(0.5)sinh(0.5) + i) / (2 cosh(0.5)**2 - 1)
+	 * z = -0.5 + i Pi/2
+	 *     sinh(z) = cosh(0.5)
+	 *     cosh(z) = -i sinh(0.5)
+	 *     tanh(z) = -coth(0.5)
+	 * z =  1.0 + i 3Pi/4
+	 *     sinh(z) = (-sinh(1) + i cosh(1)) * sqrt(2)/2
+	 *     cosh(z) = (-cosh(1) + i sinh(1)) * sqrt(2)/2
+	 *     tanh(z) = (2cosh(1)sinh(1) - i) / (2cosh(1)**2 - 1)
+	 */
+	static const struct {
+		long double a, b;
+		long double sinh_a, sinh_b;
+		long double cosh_a, cosh_b;
+		long double tanh_a, tanh_b;
+	} tests[] = {
+		{  0.5L,
+		   0.78539816339744830961566084581987572L,
+		   0.36847002415910435172083660522240710L,
+		   0.79735196663945774996093142586179334L,
+		   0.79735196663945774996093142586179334L,
+		   0.36847002415910435172083660522240710L,
+		   0.76159415595576488811945828260479359L,
+		   0.64805427366388539957497735322615032L },
+		{ -0.5L,
+		   1.57079632679489661923132169163975144L,
+		   0.0L,
+		   1.12762596520638078522622516140267201L,
+		   0.0L,
+		  -0.52109530549374736162242562641149156L,
+		  -2.16395341373865284877000401021802312L,
+		   0.0L },
+		{  1.0L,
+		   2.35619449019234492884698253745962716L,
+		  -0.83099273328405698212637979852748608L,
+		   1.09112278079550143030545602018565236L,
+		  -1.09112278079550143030545602018565236L,
+		   0.83099273328405698212637979852748609L,
+		   0.96402758007581688394641372410092315L,
+		  -0.26580222883407969212086273981988897L }
+	};
+	long double complex z;
+	int i;
+
+	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
+		z = CMPLXL(tests[i].a, tests[i].b);
+		testall_odd_tol(csinh, z,
+		    CMPLXL(tests[i].sinh_a, tests[i].sinh_b), 1.1);
+		testall_even_tol(ccosh, z,
+		    CMPLXL(tests[i].cosh_a, tests[i].cosh_b), 1.1);
+		testall_odd_tol(ctanh, z,
+		    CMPLXL(tests[i].tanh_a, tests[i].tanh_b), 1.4);
+        }
+}
+
+/* Test inputs that might cause overflow in a sloppy implementation. */
+void
+test_large(void)
+{
+	long double complex z;
+
+	/* tanh() uses a threshold around x=22, so check both sides. */
+	z = CMPLXL(21, 0.78539816339744830961566084581987572L);
+	testall_odd_tol(ctanh, z,
+	    CMPLXL(1.0, 1.14990445285871196133287617611468468e-18L), 1.2);
+	z++;
+	testall_odd_tol(ctanh, z,
+	    CMPLXL(1.0, 1.55622644822675930314266334585597964e-19L), 1);
+
+	z = CMPLXL(355, 0.78539816339744830961566084581987572L);
+	test_odd_tol(ctanh, z,
+		     CMPLXL(1.0, 8.95257245135025991216632140458264468e-309L),
+		     DBL_ULP());
+#if !defined(__i386__)
+	z = CMPLXL(30, 0x1p1023L);
+	test_odd_tol(ctanh, z,
+		     CMPLXL(1.0, -1.62994325413993477997492170229268382e-26L),
+		     DBL_ULP());
+	z = CMPLXL(1, 0x1p1023L);
+	test_odd_tol(ctanh, z,
+		     CMPLXL(0.878606311888306869546254022621986509L,
+			    -0.225462792499754505792678258169527424L),
+		     DBL_ULP());
+#endif
+
+	z = CMPLXL(710.6, 0.78539816339744830961566084581987572L);
+	test_odd_tol(csinh, z,
+	    CMPLXL(1.43917579766621073533185387499658944e308L,
+		   1.43917579766621073533185387499658944e308L), DBL_ULP());
+	test_even_tol(ccosh, z,
+	    CMPLXL(1.43917579766621073533185387499658944e308L,
+		   1.43917579766621073533185387499658944e308L), DBL_ULP());
+
+	z = CMPLXL(1500, 0.78539816339744830961566084581987572L);
+	testall_odd(csinh, z, CMPLXL(INFINITY, INFINITY), OPT_INEXACT,
+	    FE_OVERFLOW, CS_BOTH);
+	testall_even(ccosh, z, CMPLXL(INFINITY, INFINITY), OPT_INEXACT,
+	    FE_OVERFLOW, CS_BOTH);
+}
+
+int
+main(int argc, char *argv[])
+{
+
+	printf("1..6\n");
+
+	test_zero();
+	printf("ok 1 - ctrig zero\n");
+
+	test_nan();
+	printf("ok 2 - ctrig nan\n");
+
+	test_inf();
+	printf("ok 3 - ctrig inf\n");
+
+	test_axes();
+	printf("ok 4 - ctrig axes\n");
+
+	test_small();
+	printf("ok 5 - ctrig small\n");
+
+	test_large();
+	printf("ok 6 - ctrig large\n");
+
+	return (0);
+}
diff --git a/lib/msun/tests/exponential_test.c b/lib/msun/tests/exponential_test.c
new file mode 100644
index 0000000..df552ee
--- /dev/null
+++ b/lib/msun/tests/exponential_test.c
@@ -0,0 +1,169 @@
+/*-
+ * Copyright (c) 2008 David Schultz <das@FreeBSD.org>
+ * All rights reserved.
+ *
+ * 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 AUTHOR 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 AUTHOR 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.
+ */
+
+/*
+ * Tests for corner cases in exp*().
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <assert.h>
+#include <fenv.h>
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+
+#ifdef __i386__
+#include <ieeefp.h>
+#endif
+
+#include "test-utils.h"
+
+#pragma STDC FENV_ACCESS ON
+
+/*
+ * Test that a function returns the correct value and sets the
+ * exception flags correctly. The exceptmask specifies which
+ * exceptions we should check. We need to be lenient for several
+ * reasoons, but mainly because on some architectures it's impossible
+ * to raise FE_OVERFLOW without raising FE_INEXACT.
+ *
+ * These are macros instead of functions so that assert provides more
+ * meaningful error messages.
+ *
+ * XXX The volatile here is to avoid gcc's bogus constant folding and work
+ *     around the lack of support for the FENV_ACCESS pragma.
+ */
+#define	test(func, x, result, exceptmask, excepts)	do {		\
+	volatile long double _d = x;					\
+	assert(feclearexcept(FE_ALL_EXCEPT) == 0);			\
+	assert(fpequal((func)(_d), (result)));				 \
+	assert(((void)(func), fetestexcept(exceptmask) == (excepts)));	\
+} while (0)
+
+/* Test all the functions that compute b^x. */
+#define	_testall0(x, result, exceptmask, excepts)	do {		\
+	test(exp, x, result, exceptmask, excepts);			\
+	test(expf, x, result, exceptmask, excepts);			\
+	test(exp2, x, result, exceptmask, excepts);			\
+	test(exp2f, x, result, exceptmask, excepts);			\
+} while (0)
+
+/* Skip over exp2l on platforms that don't support it. */
+#if LDBL_PREC == 53
+#define	testall0	_testall0
+#else
+#define	testall0(x, result, exceptmask, excepts)	do {		\
+	_testall0(x, result, exceptmask, excepts); 			\
+	test(exp2l, x, result, exceptmask, excepts);			\
+} while (0)
+#endif
+
+/* Test all the functions that compute b^x - 1. */
+#define	testall1(x, result, exceptmask, excepts)	do {		\
+	test(expm1, x, result, exceptmask, excepts);			\
+	test(expm1f, x, result, exceptmask, excepts);			\
+} while (0)
+
+void
+run_generic_tests(void)
+{
+
+	/* exp(0) == 1, no exceptions raised */
+	testall0(0.0, 1.0, ALL_STD_EXCEPT, 0);
+	testall1(0.0, 0.0, ALL_STD_EXCEPT, 0);
+	testall0(-0.0, 1.0, ALL_STD_EXCEPT, 0);
+	testall1(-0.0, -0.0, ALL_STD_EXCEPT, 0);
+
+	/* exp(NaN) == NaN, no exceptions raised */
+	testall0(NAN, NAN, ALL_STD_EXCEPT, 0);
+	testall1(NAN, NAN, ALL_STD_EXCEPT, 0);
+
+	/* exp(Inf) == Inf, no exceptions raised */
+	testall0(INFINITY, INFINITY, ALL_STD_EXCEPT, 0);
+	testall1(INFINITY, INFINITY, ALL_STD_EXCEPT, 0);
+
+	/* exp(-Inf) == 0, no exceptions raised */
+	testall0(-INFINITY, 0.0, ALL_STD_EXCEPT, 0);
+	testall1(-INFINITY, -1.0, ALL_STD_EXCEPT, 0);
+
+#if !defined(__i386__)
+	/* exp(big) == Inf, overflow exception */
+	testall0(50000.0, INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_OVERFLOW);
+	testall1(50000.0, INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_OVERFLOW);
+
+	/* exp(small) == 0, underflow and inexact exceptions */
+	testall0(-50000.0, 0.0, ALL_STD_EXCEPT, FE_UNDERFLOW | FE_INEXACT);
+#endif
+	testall1(-50000.0, -1.0, ALL_STD_EXCEPT, FE_INEXACT);
+}
+
+void
+run_exp2_tests(void)
+{
+	int i;
+
+	/*
+	 * We should insist that exp2() return exactly the correct
+	 * result and not raise an inexact exception for integer
+	 * arguments.
+	 */
+	feclearexcept(FE_ALL_EXCEPT);
+	for (i = FLT_MIN_EXP - FLT_MANT_DIG; i < FLT_MAX_EXP; i++) {
+		assert(exp2f(i) == ldexpf(1.0, i));
+		assert(fetestexcept(ALL_STD_EXCEPT) == 0);
+	}
+	for (i = DBL_MIN_EXP - DBL_MANT_DIG; i < DBL_MAX_EXP; i++) {
+		assert(exp2(i) == ldexp(1.0, i));
+		assert(fetestexcept(ALL_STD_EXCEPT) == 0);
+	}
+	for (i = LDBL_MIN_EXP - LDBL_MANT_DIG; i < LDBL_MAX_EXP; i++) {
+		assert(exp2l(i) == ldexpl(1.0, i));
+		assert(fetestexcept(ALL_STD_EXCEPT) == 0);
+	}
+}
+
+int
+main(int argc, char *argv[])
+{
+
+	printf("1..3\n");
+
+	run_generic_tests();
+	printf("ok 1 - exponential\n");
+
+#ifdef __i386__
+	fpsetprec(FP_PE);
+	run_generic_tests();
+#endif
+	printf("ok 2 - exponential\n");
+
+	run_exp2_tests();
+	printf("ok 3 - exponential\n");
+
+	return (0);
+}
diff --git a/lib/msun/tests/fma_test.c b/lib/msun/tests/fma_test.c
new file mode 100644
index 0000000..af7910e
--- /dev/null
+++ b/lib/msun/tests/fma_test.c
@@ -0,0 +1,542 @@
+/*-
+ * Copyright (c) 2008 David Schultz <das@FreeBSD.org>
+ * All rights reserved.
+ *
+ * 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 AUTHOR 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 AUTHOR 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.
+ */
+
+/*
+ * Tests for fma{,f,l}().
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <assert.h>
+#include <fenv.h>
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "test-utils.h"
+
+#pragma STDC FENV_ACCESS ON
+
+/*
+ * Test that a function returns the correct value and sets the
+ * exception flags correctly. The exceptmask specifies which
+ * exceptions we should check. We need to be lenient for several
+ * reasons, but mainly because on some architectures it's impossible
+ * to raise FE_OVERFLOW without raising FE_INEXACT.
+ *
+ * These are macros instead of functions so that assert provides more
+ * meaningful error messages.
+ */
+#define	test(func, x, y, z, result, exceptmask, excepts) do {		\
+	volatile long double _vx = (x), _vy = (y), _vz = (z);		\
+	assert(feclearexcept(FE_ALL_EXCEPT) == 0);			\
+	assert(fpequal((func)(_vx, _vy, _vz), (result)));		\
+	assert(((void)(func), fetestexcept(exceptmask) == (excepts)));	\
+} while (0)
+
+#define	testall(x, y, z, result, exceptmask, excepts)	do {		\
+	test(fma, (double)(x), (double)(y), (double)(z),		\
+		(double)(result), (exceptmask), (excepts));		\
+	test(fmaf, (float)(x), (float)(y), (float)(z),			\
+		(float)(result), (exceptmask), (excepts));		\
+	test(fmal, (x), (y), (z), (result), (exceptmask), (excepts));	\
+} while (0)
+
+/* Test in all rounding modes. */
+#define	testrnd(func, x, y, z, rn, ru, rd, rz, exceptmask, excepts)	do { \
+	fesetround(FE_TONEAREST);					\
+	test((func), (x), (y), (z), (rn), (exceptmask), (excepts));	\
+	fesetround(FE_UPWARD);						\
+	test((func), (x), (y), (z), (ru), (exceptmask), (excepts));	\
+	fesetround(FE_DOWNWARD);					\
+	test((func), (x), (y), (z), (rd), (exceptmask), (excepts));	\
+	fesetround(FE_TOWARDZERO);					\
+	test((func), (x), (y), (z), (rz), (exceptmask), (excepts));	\
+} while (0)
+
+/*
+ * This is needed because clang constant-folds fma in ways that are incorrect
+ * in rounding modes other than FE_TONEAREST.
+ */
+volatile double one = 1.0;
+
+static void
+test_zeroes(void)
+{
+	const int rd = (fegetround() == FE_DOWNWARD);
+
+	testall(0.0, 0.0, 0.0, 0.0, ALL_STD_EXCEPT, 0);
+	testall(1.0, 0.0, 0.0, 0.0, ALL_STD_EXCEPT, 0);
+	testall(0.0, 1.0, 0.0, 0.0, ALL_STD_EXCEPT, 0);
+	testall(0.0, 0.0, 1.0, 1.0, ALL_STD_EXCEPT, 0);
+
+	testall(-0.0, 0.0, 0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0);
+	testall(0.0, -0.0, 0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0);
+	testall(-0.0, -0.0, 0.0, 0.0, ALL_STD_EXCEPT, 0);
+	testall(0.0, 0.0, -0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0);
+	testall(-0.0, -0.0, -0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0);
+
+	testall(-0.0, 0.0, -0.0, -0.0, ALL_STD_EXCEPT, 0);
+	testall(0.0, -0.0, -0.0, -0.0, ALL_STD_EXCEPT, 0);
+
+	testall(-one, one, one, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0);
+	testall(one, -one, one, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0);
+	testall(-one, -one, -one, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0);
+
+	switch (fegetround()) {
+	case FE_TONEAREST:
+	case FE_TOWARDZERO:
+		test(fmaf, -FLT_MIN, FLT_MIN, 0.0, -0.0,
+		     ALL_STD_EXCEPT, FE_INEXACT | FE_UNDERFLOW);
+		test(fma, -DBL_MIN, DBL_MIN, 0.0, -0.0,
+		     ALL_STD_EXCEPT, FE_INEXACT | FE_UNDERFLOW);
+		test(fmal, -LDBL_MIN, LDBL_MIN, 0.0, -0.0,
+		     ALL_STD_EXCEPT, FE_INEXACT | FE_UNDERFLOW);
+	}
+}
+
+static void
+test_infinities(void)
+{
+
+	testall(INFINITY, 1.0, -1.0, INFINITY, ALL_STD_EXCEPT, 0);
+	testall(-1.0, INFINITY, 0.0, -INFINITY, ALL_STD_EXCEPT, 0);
+	testall(0.0, 0.0, INFINITY, INFINITY, ALL_STD_EXCEPT, 0);
+	testall(1.0, 1.0, INFINITY, INFINITY, ALL_STD_EXCEPT, 0);
+	testall(1.0, 1.0, -INFINITY, -INFINITY, ALL_STD_EXCEPT, 0);
+
+	testall(INFINITY, -INFINITY, 1.0, -INFINITY, ALL_STD_EXCEPT, 0);
+	testall(INFINITY, INFINITY, 1.0, INFINITY, ALL_STD_EXCEPT, 0);
+	testall(-INFINITY, -INFINITY, INFINITY, INFINITY, ALL_STD_EXCEPT, 0);
+
+	testall(0.0, INFINITY, 1.0, NAN, ALL_STD_EXCEPT, FE_INVALID);
+	testall(INFINITY, 0.0, -0.0, NAN, ALL_STD_EXCEPT, FE_INVALID);
+
+	/* The invalid exception is optional in this case. */
+	testall(INFINITY, 0.0, NAN, NAN, ALL_STD_EXCEPT & ~FE_INVALID, 0);
+
+	testall(INFINITY, INFINITY, -INFINITY, NAN,
+		ALL_STD_EXCEPT, FE_INVALID);
+	testall(-INFINITY, INFINITY, INFINITY, NAN,
+		ALL_STD_EXCEPT, FE_INVALID);
+	testall(INFINITY, -1.0, INFINITY, NAN,
+		ALL_STD_EXCEPT, FE_INVALID);
+
+	test(fmaf, FLT_MAX, FLT_MAX, -INFINITY, -INFINITY, ALL_STD_EXCEPT, 0);
+	test(fma, DBL_MAX, DBL_MAX, -INFINITY, -INFINITY, ALL_STD_EXCEPT, 0);
+	test(fmal, LDBL_MAX, LDBL_MAX, -INFINITY, -INFINITY,
+	     ALL_STD_EXCEPT, 0);
+	test(fmaf, FLT_MAX, -FLT_MAX, INFINITY, INFINITY, ALL_STD_EXCEPT, 0);
+	test(fma, DBL_MAX, -DBL_MAX, INFINITY, INFINITY, ALL_STD_EXCEPT, 0);
+	test(fmal, LDBL_MAX, -LDBL_MAX, INFINITY, INFINITY,
+	     ALL_STD_EXCEPT, 0);
+}
+
+static void
+test_nans(void)
+{
+
+	testall(NAN, 0.0, 0.0, NAN, ALL_STD_EXCEPT, 0);
+	testall(1.0, NAN, 1.0, NAN, ALL_STD_EXCEPT, 0);
+	testall(1.0, -1.0, NAN, NAN, ALL_STD_EXCEPT, 0);
+	testall(0.0, 0.0, NAN, NAN, ALL_STD_EXCEPT, 0);
+	testall(NAN, NAN, NAN, NAN, ALL_STD_EXCEPT, 0);
+
+	/* x*y should not raise an inexact/overflow/underflow if z is NaN. */
+	testall(M_PI, M_PI, NAN, NAN, ALL_STD_EXCEPT, 0);
+	test(fmaf, FLT_MIN, FLT_MIN, NAN, NAN, ALL_STD_EXCEPT, 0);
+	test(fma, DBL_MIN, DBL_MIN, NAN, NAN, ALL_STD_EXCEPT, 0);
+	test(fmal, LDBL_MIN, LDBL_MIN, NAN, NAN, ALL_STD_EXCEPT, 0);
+	test(fmaf, FLT_MAX, FLT_MAX, NAN, NAN, ALL_STD_EXCEPT, 0);
+	test(fma, DBL_MAX, DBL_MAX, NAN, NAN, ALL_STD_EXCEPT, 0);
+	test(fmal, LDBL_MAX, LDBL_MAX, NAN, NAN, ALL_STD_EXCEPT, 0);
+}
+
+/*
+ * Tests for cases where z is very small compared to x*y.
+ */
+static void
+test_small_z(void)
+{
+
+	/* x*y positive, z positive */
+	if (fegetround() == FE_UPWARD) {
+		test(fmaf, one, one, 0x1.0p-100, 1.0 + FLT_EPSILON,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fma, one, one, 0x1.0p-200, 1.0 + DBL_EPSILON,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fmal, one, one, 0x1.0p-200, 1.0 + LDBL_EPSILON,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+	} else {
+		testall(0x1.0p100, one, 0x1.0p-100, 0x1.0p100,
+			ALL_STD_EXCEPT, FE_INEXACT);
+	}
+
+	/* x*y negative, z negative */
+	if (fegetround() == FE_DOWNWARD) {
+		test(fmaf, -one, one, -0x1.0p-100, -(1.0 + FLT_EPSILON),
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fma, -one, one, -0x1.0p-200, -(1.0 + DBL_EPSILON),
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fmal, -one, one, -0x1.0p-200, -(1.0 + LDBL_EPSILON),
+		     ALL_STD_EXCEPT, FE_INEXACT);
+	} else {
+		testall(0x1.0p100, -one, -0x1.0p-100, -0x1.0p100,
+			ALL_STD_EXCEPT, FE_INEXACT);
+	}
+
+	/* x*y positive, z negative */
+	if (fegetround() == FE_DOWNWARD || fegetround() == FE_TOWARDZERO) {
+		test(fmaf, one, one, -0x1.0p-100, 1.0 - FLT_EPSILON / 2,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fma, one, one, -0x1.0p-200, 1.0 - DBL_EPSILON / 2,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fmal, one, one, -0x1.0p-200, 1.0 - LDBL_EPSILON / 2,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+	} else {
+		testall(0x1.0p100, one, -0x1.0p-100, 0x1.0p100,
+			ALL_STD_EXCEPT, FE_INEXACT);
+	}
+
+	/* x*y negative, z positive */
+	if (fegetround() == FE_UPWARD || fegetround() == FE_TOWARDZERO) {
+		test(fmaf, -one, one, 0x1.0p-100, -1.0 + FLT_EPSILON / 2,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fma, -one, one, 0x1.0p-200, -1.0 + DBL_EPSILON / 2,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fmal, -one, one, 0x1.0p-200, -1.0 + LDBL_EPSILON / 2,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+	} else {
+		testall(-0x1.0p100, one, 0x1.0p-100, -0x1.0p100,
+			ALL_STD_EXCEPT, FE_INEXACT);
+	}
+}
+
+/*
+ * Tests for cases where z is very large compared to x*y.
+ */
+static void
+test_big_z(void)
+{
+
+	/* z positive, x*y positive */
+	if (fegetround() == FE_UPWARD) {
+		test(fmaf, 0x1.0p-50, 0x1.0p-50, 1.0, 1.0 + FLT_EPSILON,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fma, 0x1.0p-100, 0x1.0p-100, 1.0, 1.0 + DBL_EPSILON,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fmal, 0x1.0p-100, 0x1.0p-100, 1.0, 1.0 + LDBL_EPSILON,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+	} else {
+		testall(-0x1.0p-50, -0x1.0p-50, 0x1.0p100, 0x1.0p100,
+			ALL_STD_EXCEPT, FE_INEXACT);
+	}
+
+	/* z negative, x*y negative */
+	if (fegetround() == FE_DOWNWARD) {
+		test(fmaf, -0x1.0p-50, 0x1.0p-50, -1.0, -(1.0 + FLT_EPSILON),
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fma, -0x1.0p-100, 0x1.0p-100, -1.0, -(1.0 + DBL_EPSILON),
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fmal, -0x1.0p-100, 0x1.0p-100, -1.0, -(1.0 + LDBL_EPSILON),
+		     ALL_STD_EXCEPT, FE_INEXACT);
+	} else {
+		testall(0x1.0p-50, -0x1.0p-50, -0x1.0p100, -0x1.0p100,
+			ALL_STD_EXCEPT, FE_INEXACT);
+	}
+
+	/* z negative, x*y positive */
+	if (fegetround() == FE_UPWARD || fegetround() == FE_TOWARDZERO) {
+		test(fmaf, -0x1.0p-50, -0x1.0p-50, -1.0,
+		     -1.0 + FLT_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT);
+		test(fma, -0x1.0p-100, -0x1.0p-100, -1.0,
+		     -1.0 + DBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT);
+		test(fmal, -0x1.0p-100, -0x1.0p-100, -1.0,
+		     -1.0 + LDBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT);
+	} else {
+		testall(0x1.0p-50, 0x1.0p-50, -0x1.0p100, -0x1.0p100,
+			ALL_STD_EXCEPT, FE_INEXACT);
+	}
+
+	/* z positive, x*y negative */
+	if (fegetround() == FE_DOWNWARD || fegetround() == FE_TOWARDZERO) {
+		test(fmaf, 0x1.0p-50, -0x1.0p-50, 1.0, 1.0 - FLT_EPSILON / 2,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fma, 0x1.0p-100, -0x1.0p-100, 1.0, 1.0 - DBL_EPSILON / 2,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+		test(fmal, 0x1.0p-100, -0x1.0p-100, 1.0, 1.0 - LDBL_EPSILON / 2,
+		     ALL_STD_EXCEPT, FE_INEXACT);
+	} else {
+		testall(-0x1.0p-50, 0x1.0p-50, 0x1.0p100, 0x1.0p100,
+			ALL_STD_EXCEPT, FE_INEXACT);
+	}
+}
+
+static void
+test_accuracy(void)
+{
+
+	/* ilogb(x*y) - ilogb(z) = 20 */
+	testrnd(fmaf, -0x1.c139d8p-51, -0x1.600e7ap32, 0x1.26558cp-38,
+		0x1.34e48ap-18, 0x1.34e48cp-18, 0x1.34e48ap-18, 0x1.34e48ap-18,
+		ALL_STD_EXCEPT, FE_INEXACT);
+	testrnd(fma, -0x1.c139d7b84f1a3p-51, -0x1.600e7a2a16484p32,
+		0x1.26558cac31580p-38, 0x1.34e48a78aae97p-18,
+		0x1.34e48a78aae97p-18, 0x1.34e48a78aae96p-18,
+		0x1.34e48a78aae96p-18, ALL_STD_EXCEPT, FE_INEXACT);
+#if LDBL_MANT_DIG == 113
+	testrnd(fmal, -0x1.c139d7b84f1a3079263afcc5bae3p-51L,
+		-0x1.600e7a2a164840edbe2e7d301a72p32L,
+		0x1.26558cac315807eb07e448042101p-38L,
+		0x1.34e48a78aae96c76ed36077dd387p-18L,
+		0x1.34e48a78aae96c76ed36077dd388p-18L,
+		0x1.34e48a78aae96c76ed36077dd387p-18L,
+		0x1.34e48a78aae96c76ed36077dd387p-18L,
+		ALL_STD_EXCEPT, FE_INEXACT);
+#elif LDBL_MANT_DIG == 64
+	testrnd(fmal, -0x1.c139d7b84f1a307ap-51L, -0x1.600e7a2a164840eep32L,
+		0x1.26558cac315807ecp-38L, 0x1.34e48a78aae96c78p-18L,
+		0x1.34e48a78aae96c78p-18L, 0x1.34e48a78aae96c76p-18L,
+		0x1.34e48a78aae96c76p-18L, ALL_STD_EXCEPT, FE_INEXACT);
+#elif LDBL_MANT_DIG == 53
+	testrnd(fmal, -0x1.c139d7b84f1a3p-51L, -0x1.600e7a2a16484p32L,
+		0x1.26558cac31580p-38L, 0x1.34e48a78aae97p-18L,
+		0x1.34e48a78aae97p-18L, 0x1.34e48a78aae96p-18L,
+		0x1.34e48a78aae96p-18L, ALL_STD_EXCEPT, FE_INEXACT);
+#endif
+
+	/* ilogb(x*y) - ilogb(z) = -40 */
+	testrnd(fmaf, 0x1.98210ap53, 0x1.9556acp-24, 0x1.d87da4p70,
+		0x1.d87da4p70, 0x1.d87da6p70, 0x1.d87da4p70, 0x1.d87da4p70,
+		ALL_STD_EXCEPT, FE_INEXACT);
+	testrnd(fma, 0x1.98210ac83fe2bp53, 0x1.9556ac1475f0fp-24,
+		0x1.d87da3aafc60ep70, 0x1.d87da3aafda40p70,
+		0x1.d87da3aafda40p70, 0x1.d87da3aafda3fp70,
+		0x1.d87da3aafda3fp70, ALL_STD_EXCEPT, FE_INEXACT);
+#if LDBL_MANT_DIG == 113
+	testrnd(fmal, 0x1.98210ac83fe2a8f65b6278b74cebp53L,
+		0x1.9556ac1475f0f28968b61d0de65ap-24L,
+		0x1.d87da3aafc60d830aa4c6d73b749p70L,
+		0x1.d87da3aafda3f36a69eb86488224p70L,
+		0x1.d87da3aafda3f36a69eb86488225p70L,
+		0x1.d87da3aafda3f36a69eb86488224p70L,
+		0x1.d87da3aafda3f36a69eb86488224p70L,
+		ALL_STD_EXCEPT, FE_INEXACT);
+#elif LDBL_MANT_DIG == 64
+	testrnd(fmal, 0x1.98210ac83fe2a8f6p53L, 0x1.9556ac1475f0f28ap-24L,
+		0x1.d87da3aafc60d83p70L, 0x1.d87da3aafda3f36ap70L,
+		0x1.d87da3aafda3f36ap70L, 0x1.d87da3aafda3f368p70L,
+		0x1.d87da3aafda3f368p70L, ALL_STD_EXCEPT, FE_INEXACT);
+#elif LDBL_MANT_DIG == 53
+	testrnd(fmal, 0x1.98210ac83fe2bp53L, 0x1.9556ac1475f0fp-24L,
+		0x1.d87da3aafc60ep70L, 0x1.d87da3aafda40p70L,
+		0x1.d87da3aafda40p70L, 0x1.d87da3aafda3fp70L,
+		0x1.d87da3aafda3fp70L, ALL_STD_EXCEPT, FE_INEXACT);
+#endif
+
+	/* ilogb(x*y) - ilogb(z) = 0 */
+	testrnd(fmaf, 0x1.31ad02p+100, 0x1.2fbf7ap-42, -0x1.c3e106p+58,
+		-0x1.64c27cp+56, -0x1.64c27ap+56, -0x1.64c27cp+56,
+		-0x1.64c27ap+56, ALL_STD_EXCEPT, FE_INEXACT);
+	testrnd(fma, 0x1.31ad012ede8aap+100, 0x1.2fbf79c839067p-42,
+		-0x1.c3e106929056ep+58, -0x1.64c282b970a5fp+56,
+		-0x1.64c282b970a5ep+56, -0x1.64c282b970a5fp+56,
+		-0x1.64c282b970a5ep+56, ALL_STD_EXCEPT, FE_INEXACT);
+#if LDBL_MANT_DIG == 113
+	testrnd(fmal, 0x1.31ad012ede8aa282fa1c19376d16p+100L,
+		 0x1.2fbf79c839066f0f5c68f6d2e814p-42L,
+		-0x1.c3e106929056ec19de72bfe64215p+58L,
+		-0x1.64c282b970a612598fc025ca8cddp+56L,
+		-0x1.64c282b970a612598fc025ca8cddp+56L,
+		-0x1.64c282b970a612598fc025ca8cdep+56L,
+		-0x1.64c282b970a612598fc025ca8cddp+56L,
+		ALL_STD_EXCEPT, FE_INEXACT);
+#elif LDBL_MANT_DIG == 64
+	testrnd(fmal, 0x1.31ad012ede8aa4eap+100L, 0x1.2fbf79c839066aeap-42L,
+		-0x1.c3e106929056e61p+58L, -0x1.64c282b970a60298p+56L,
+		-0x1.64c282b970a60298p+56L, -0x1.64c282b970a6029ap+56L,
+		-0x1.64c282b970a60298p+56L, ALL_STD_EXCEPT, FE_INEXACT);
+#elif LDBL_MANT_DIG == 53
+	testrnd(fmal, 0x1.31ad012ede8aap+100L, 0x1.2fbf79c839067p-42L,
+		-0x1.c3e106929056ep+58L, -0x1.64c282b970a5fp+56L,
+		-0x1.64c282b970a5ep+56L, -0x1.64c282b970a5fp+56L,
+		-0x1.64c282b970a5ep+56L, ALL_STD_EXCEPT, FE_INEXACT);
+#endif
+
+	/* x*y (rounded) ~= -z */
+	/* XXX spurious inexact exceptions */
+	testrnd(fmaf, 0x1.bbffeep-30, -0x1.1d164cp-74, 0x1.ee7296p-104,
+		-0x1.c46ea8p-128, -0x1.c46ea8p-128, -0x1.c46ea8p-128,
+		-0x1.c46ea8p-128, ALL_STD_EXCEPT & ~FE_INEXACT, 0);
+	testrnd(fma, 0x1.bbffeea6fc7d6p-30, 0x1.1d164c6cbf078p-74,
+		-0x1.ee72993aff948p-104, -0x1.71f72ac7d9d8p-159,
+		-0x1.71f72ac7d9d8p-159, -0x1.71f72ac7d9d8p-159,
+		-0x1.71f72ac7d9d8p-159, ALL_STD_EXCEPT & ~FE_INEXACT, 0);
+#if LDBL_MANT_DIG == 113
+	testrnd(fmal, 0x1.bbffeea6fc7d65927d147f437675p-30L,
+		0x1.1d164c6cbf078b7a22607d1cd6a2p-74L,
+		-0x1.ee72993aff94973876031bec0944p-104L,
+		0x1.64e086175b3a2adc36e607058814p-217L,
+		0x1.64e086175b3a2adc36e607058814p-217L,
+		0x1.64e086175b3a2adc36e607058814p-217L,
+		0x1.64e086175b3a2adc36e607058814p-217L,
+		ALL_STD_EXCEPT & ~FE_INEXACT, 0);
+#elif LDBL_MANT_DIG == 64
+	testrnd(fmal, 0x1.bbffeea6fc7d6592p-30L, 0x1.1d164c6cbf078b7ap-74L,
+		-0x1.ee72993aff949736p-104L, 0x1.af190e7a1ee6ad94p-168L,
+		0x1.af190e7a1ee6ad94p-168L, 0x1.af190e7a1ee6ad94p-168L,
+		0x1.af190e7a1ee6ad94p-168L, ALL_STD_EXCEPT & ~FE_INEXACT, 0);
+#elif LDBL_MANT_DIG == 53
+	testrnd(fmal, 0x1.bbffeea6fc7d6p-30L, 0x1.1d164c6cbf078p-74L,
+		-0x1.ee72993aff948p-104L, -0x1.71f72ac7d9d8p-159L,
+		-0x1.71f72ac7d9d8p-159L, -0x1.71f72ac7d9d8p-159L,
+		-0x1.71f72ac7d9d8p-159L, ALL_STD_EXCEPT & ~FE_INEXACT, 0);
+#endif
+}
+
+static void
+test_double_rounding(void)
+{
+
+	/*
+	 *     a =  0x1.8000000000001p0
+	 *     b =  0x1.8000000000001p0
+	 *     c = -0x0.0000000000000000000000000080...1p+1
+	 * a * b =  0x1.2000000000001800000000000080p+1
+	 *
+	 * The correct behavior is to round DOWN to 0x1.2000000000001p+1 in
+	 * round-to-nearest mode.  An implementation that computes a*b+c in
+	 * double+double precision, however, will get 0x1.20000000000018p+1,
+	 * and then round UP.
+	 */
+	fesetround(FE_TONEAREST);
+	test(fma, 0x1.8000000000001p0, 0x1.8000000000001p0,
+	     -0x1.0000000000001p-104, 0x1.2000000000001p+1,
+	     ALL_STD_EXCEPT, FE_INEXACT);
+	fesetround(FE_DOWNWARD);
+	test(fma, 0x1.8000000000001p0, 0x1.8000000000001p0,
+	     -0x1.0000000000001p-104, 0x1.2000000000001p+1,
+	     ALL_STD_EXCEPT, FE_INEXACT);
+	fesetround(FE_UPWARD);
+	test(fma, 0x1.8000000000001p0, 0x1.8000000000001p0,
+	     -0x1.0000000000001p-104, 0x1.2000000000002p+1,
+	     ALL_STD_EXCEPT, FE_INEXACT);
+
+	fesetround(FE_TONEAREST);
+	test(fmaf, 0x1.800002p+0, 0x1.800002p+0, -0x1.000002p-46, 0x1.200002p+1,
+	     ALL_STD_EXCEPT, FE_INEXACT);
+	fesetround(FE_DOWNWARD);
+	test(fmaf, 0x1.800002p+0, 0x1.800002p+0, -0x1.000002p-46, 0x1.200002p+1,
+	     ALL_STD_EXCEPT, FE_INEXACT);
+	fesetround(FE_UPWARD);
+	test(fmaf, 0x1.800002p+0, 0x1.800002p+0, -0x1.000002p-46, 0x1.200004p+1,
+	     ALL_STD_EXCEPT, FE_INEXACT);
+
+	fesetround(FE_TONEAREST);
+#if LDBL_MANT_DIG == 64
+	test(fmal, 0x1.4p+0L, 0x1.0000000000000004p+0L, 0x1p-128L,
+	     0x1.4000000000000006p+0L, ALL_STD_EXCEPT, FE_INEXACT);
+#elif LDBL_MANT_DIG == 113
+	test(fmal, 0x1.8000000000000000000000000001p+0L,
+	     0x1.8000000000000000000000000001p+0L,
+	     -0x1.0000000000000000000000000001p-224L,
+	     0x1.2000000000000000000000000001p+1L, ALL_STD_EXCEPT, FE_INEXACT);
+#endif
+
+}
+
+int
+main(int argc, char *argv[])
+{
+	int rmodes[] = { FE_TONEAREST, FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO };
+	int i, j;
+
+#if defined(__i386__)
+	printf("1..0 # SKIP all testcases fail on i386\n");
+	exit(0);
+#endif
+
+	j = 1;
+
+	printf("1..19\n");
+
+	for (i = 0; i < nitems(rmodes); i++, j++) {
+		printf("rmode = %d\n", rmodes[i]);
+		fesetround(rmodes[i]);
+		test_zeroes();
+		printf("ok %d - fma zeroes\n", j);
+	}
+
+	for (i = 0; i < nitems(rmodes); i++, j++) {
+#if defined(__amd64__)
+		printf("ok %d # SKIP testcase fails assertion on "
+		    "amd64\n", j);
+		continue;
+#endif
+		printf("rmode = %d\n", rmodes[i]);
+		fesetround(rmodes[i]);
+		test_infinities();
+		printf("ok %d - fma infinities\n", j);
+	}
+
+	fesetround(FE_TONEAREST);
+	test_nans();
+	printf("ok 9 - fma NaNs\n");
+
+	for (i = 0; i < nitems(rmodes); i++, j++) {
+		printf("rmode = %d\n", rmodes[i]);
+		fesetround(rmodes[i]);
+		test_small_z();
+		printf("ok %d - fma small z\n", j);
+	}
+
+	for (i = 0; i < nitems(rmodes); i++, j++) {
+		printf("rmode = %d\n", rmodes[i]);
+		fesetround(rmodes[i]);
+		test_big_z();
+		printf("ok %d - fma big z\n", j);
+	}
+
+	fesetround(FE_TONEAREST);
+	test_accuracy();
+	printf("ok %d - fma accuracy\n", j);
+	j++;
+
+	test_double_rounding();
+	printf("ok %d - fma double rounding\n", j);
+	j++;
+
+	/*
+	 * TODO:
+	 * - Tests for subnormals
+	 * - Cancellation tests (e.g., z = (double)x*y, but x*y is inexact)
+	 */
+
+	return (0);
+}
diff --git a/lib/msun/tests/invtrig_test.c b/lib/msun/tests/invtrig_test.c
new file mode 100644
index 0000000..01b0379
--- /dev/null
+++ b/lib/msun/tests/invtrig_test.c
@@ -0,0 +1,479 @@
+/*-
+ * Copyright (c) 2008 David Schultz <das@FreeBSD.org>
+ * All rights reserved.
+ *
+ * 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 AUTHOR 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 AUTHOR 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.
+ */
+
+/*
+ * Tests for corner cases in the inverse trigonometric functions. Some
+ * accuracy tests are included as well, but these are very basic
+ * sanity checks, not intended to be comprehensive.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <assert.h>
+#include <fenv.h>
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+
+#include "test-utils.h"
+
+#pragma STDC FENV_ACCESS ON
+
+/*
+ * Test that a function returns the correct value and sets the
+ * exception flags correctly. A tolerance specifying the maximum
+ * relative error allowed may be specified. For the 'testall'
+ * functions, the tolerance is specified in ulps.
+ *
+ * These are macros instead of functions so that assert provides more
+ * meaningful error messages.
+ */
+#define	test_tol(func, x, result, tol, excepts) do {			\
+	volatile long double _in = (x), _out = (result);		\
+	assert(feclearexcept(FE_ALL_EXCEPT) == 0);			\
+	assert(fpequal_tol(func(_in), _out, (tol), CS_BOTH));		\
+	assert(((void)func, fetestexcept(ALL_STD_EXCEPT) == (excepts))); \
+} while (0)
+#define test(func, x, result, excepts)					\
+	test_tol(func, (x), (result), 0, (excepts))
+
+#define	_testall_tol(prefix, x, result, tol, excepts) do {		\
+	test_tol(prefix, (double)(x), (double)(result),			\
+		 (tol) * ldexp(1.0, 1 - DBL_MANT_DIG), (excepts));	\
+	test_tol(prefix##f, (float)(x), (float)(result),		\
+		 (tol) * ldexpf(1.0, 1 - FLT_MANT_DIG), (excepts));	\
+} while (0)
+
+#if LDBL_PREC == 53
+#define	testall_tol	_testall_tol
+#else
+#define	testall_tol(prefix, x, result, tol, excepts) do {		\
+	_testall_tol(prefix, x, result, tol, excepts);			\
+	test_tol(prefix##l, (x), (result),				\
+		 (tol) * ldexpl(1.0, 1 - LDBL_MANT_DIG), (excepts));	\
+} while (0)
+#endif
+
+#define testall(prefix, x, result, excepts)				\
+	testall_tol(prefix, (x), (result), 0, (excepts))
+
+#define	test2_tol(func, y, x, result, tol, excepts) do {		\
+	volatile long double _iny = (y), _inx = (x), _out = (result);	\
+	assert(feclearexcept(FE_ALL_EXCEPT) == 0);			\
+	assert(fpequal_tol(func(_iny, _inx), _out, (tol), CS_BOTH));	\
+	assert(((void)func, fetestexcept(ALL_STD_EXCEPT) == (excepts))); \
+} while (0)
+#define test2(func, y, x, result, excepts)				\
+	test2_tol(func, (y), (x), (result), 0, (excepts))
+
+#define	_testall2_tol(prefix, y, x, result, tol, excepts) do {		\
+	test2_tol(prefix, (double)(y), (double)(x), (double)(result),	\
+		  (tol) * ldexp(1.0, 1 - DBL_MANT_DIG), (excepts));	\
+	test2_tol(prefix##f, (float)(y), (float)(x), (float)(result),	\
+		  (tol) * ldexpf(1.0, 1 - FLT_MANT_DIG), (excepts));	\
+} while (0)
+
+#if LDBL_PREC == 53
+#define	testall2_tol	_testall2_tol
+#else
+#define	testall2_tol(prefix, y, x, result, tol, excepts) do {		\
+	_testall2_tol(prefix, y, x, result, tol, excepts);		\
+	test2_tol(prefix##l, (y), (x), (result),			\
+		  (tol) * ldexpl(1.0, 1 - LDBL_MANT_DIG), (excepts));	\
+} while (0)
+#endif
+
+#define testall2(prefix, y, x, result, excepts)				\
+	testall2_tol(prefix, (y), (x), (result), 0, (excepts))
+
+long double
+pi =   3.14159265358979323846264338327950280e+00L,
+pio3 = 1.04719755119659774615421446109316766e+00L,
+c3pi = 9.42477796076937971538793014983850839e+00L,
+c5pi = 1.57079632679489661923132169163975140e+01L,
+c7pi = 2.19911485751285526692385036829565196e+01L,
+c5pio3 = 5.23598775598298873077107230546583851e+00L,
+sqrt2m1 = 4.14213562373095048801688724209698081e-01L;
+
+
+/*
+ * Test special case inputs in asin(), acos() and atan(): signed
+ * zeroes, infinities, and NaNs.
+ */
+static void
+test_special(void)
+{
+
+	testall(asin, 0.0, 0.0, 0);
+	testall(acos, 0.0, pi / 2, FE_INEXACT);
+	testall(atan, 0.0, 0.0, 0);
+	testall(asin, -0.0, -0.0, 0);
+	testall(acos, -0.0, pi / 2, FE_INEXACT);
+	testall(atan, -0.0, -0.0, 0);
+
+	testall(asin, INFINITY, NAN, FE_INVALID);
+	testall(acos, INFINITY, NAN, FE_INVALID);
+	testall(atan, INFINITY, pi / 2, FE_INEXACT);
+	testall(asin, -INFINITY, NAN, FE_INVALID);
+	testall(acos, -INFINITY, NAN, FE_INVALID);
+	testall(atan, -INFINITY, -pi / 2, FE_INEXACT);
+
+	testall(asin, NAN, NAN, 0);
+	testall(acos, NAN, NAN, 0);
+	testall(atan, NAN, NAN, 0);
+}
+
+/*
+ * Test special case inputs in atan2(), where the exact value of y/x is
+ * zero or non-finite.
+ */
+static void
+test_special_atan2(void)
+{
+	long double z;
+	int e;
+
+	testall2(atan2, 0.0, -0.0, pi, FE_INEXACT);
+	testall2(atan2, -0.0, -0.0, -pi, FE_INEXACT);
+	testall2(atan2, 0.0, 0.0, 0.0, 0);
+	testall2(atan2, -0.0, 0.0, -0.0, 0);
+
+	testall2(atan2, INFINITY, -INFINITY, c3pi / 4, FE_INEXACT);
+	testall2(atan2, -INFINITY, -INFINITY, -c3pi / 4, FE_INEXACT);
+	testall2(atan2, INFINITY, INFINITY, pi / 4, FE_INEXACT);
+	testall2(atan2, -INFINITY, INFINITY, -pi / 4, FE_INEXACT);
+
+	/* Tests with one input in the range (0, Inf]. */
+	z = 1.23456789L;
+	for (e = FLT_MIN_EXP - FLT_MANT_DIG; e <= FLT_MAX_EXP; e++) {
+		test2(atan2f, 0.0, ldexpf(z, e), 0.0, 0);
+		test2(atan2f, -0.0, ldexpf(z, e), -0.0, 0);
+		test2(atan2f, 0.0, ldexpf(-z, e), (float)pi, FE_INEXACT);
+		test2(atan2f, -0.0, ldexpf(-z, e), (float)-pi, FE_INEXACT);
+		test2(atan2f, ldexpf(z, e), 0.0, (float)pi / 2, FE_INEXACT);
+		test2(atan2f, ldexpf(z, e), -0.0, (float)pi / 2, FE_INEXACT);
+		test2(atan2f, ldexpf(-z, e), 0.0, (float)-pi / 2, FE_INEXACT);
+		test2(atan2f, ldexpf(-z, e), -0.0, (float)-pi / 2, FE_INEXACT);
+	}
+	for (e = DBL_MIN_EXP - DBL_MANT_DIG; e <= DBL_MAX_EXP; e++) {
+		test2(atan2, 0.0, ldexp(z, e), 0.0, 0);
+		test2(atan2, -0.0, ldexp(z, e), -0.0, 0);
+		test2(atan2, 0.0, ldexp(-z, e), (double)pi, FE_INEXACT);
+		test2(atan2, -0.0, ldexp(-z, e), (double)-pi, FE_INEXACT);
+		test2(atan2, ldexp(z, e), 0.0, (double)pi / 2, FE_INEXACT);
+		test2(atan2, ldexp(z, e), -0.0, (double)pi / 2, FE_INEXACT);
+		test2(atan2, ldexp(-z, e), 0.0, (double)-pi / 2, FE_INEXACT);
+		test2(atan2, ldexp(-z, e), -0.0, (double)-pi / 2, FE_INEXACT);
+	}
+	for (e = LDBL_MIN_EXP - LDBL_MANT_DIG; e <= LDBL_MAX_EXP; e++) {
+		test2(atan2l, 0.0, ldexpl(z, e), 0.0, 0);
+		test2(atan2l, -0.0, ldexpl(z, e), -0.0, 0);
+		test2(atan2l, 0.0, ldexpl(-z, e), pi, FE_INEXACT);
+		test2(atan2l, -0.0, ldexpl(-z, e), -pi, FE_INEXACT);
+		test2(atan2l, ldexpl(z, e), 0.0, pi / 2, FE_INEXACT);
+		test2(atan2l, ldexpl(z, e), -0.0, pi / 2, FE_INEXACT);
+		test2(atan2l, ldexpl(-z, e), 0.0, -pi / 2, FE_INEXACT);
+		test2(atan2l, ldexpl(-z, e), -0.0, -pi / 2, FE_INEXACT);
+	}
+
+	/* Tests with one input in the range (0, Inf). */
+	for (e = FLT_MIN_EXP - FLT_MANT_DIG; e <= FLT_MAX_EXP - 1; e++) {
+		test2(atan2f, ldexpf(z, e), INFINITY, 0.0, 0);
+		test2(atan2f, ldexpf(-z,e), INFINITY, -0.0, 0);
+		test2(atan2f, ldexpf(z, e), -INFINITY, (float)pi, FE_INEXACT);
+		test2(atan2f, ldexpf(-z,e), -INFINITY, (float)-pi, FE_INEXACT);
+		test2(atan2f, INFINITY, ldexpf(z,e), (float)pi/2, FE_INEXACT);
+		test2(atan2f, INFINITY, ldexpf(-z,e), (float)pi/2, FE_INEXACT);
+		test2(atan2f, -INFINITY, ldexpf(z,e), (float)-pi/2,FE_INEXACT);
+		test2(atan2f, -INFINITY, ldexpf(-z,e),(float)-pi/2,FE_INEXACT);
+	}
+	for (e = DBL_MIN_EXP - DBL_MANT_DIG; e <= DBL_MAX_EXP - 1; e++) {
+		test2(atan2, ldexp(z, e), INFINITY, 0.0, 0);
+		test2(atan2, ldexp(-z,e), INFINITY, -0.0, 0);
+		test2(atan2, ldexp(z, e), -INFINITY, (double)pi, FE_INEXACT);
+		test2(atan2, ldexp(-z,e), -INFINITY, (double)-pi, FE_INEXACT);
+		test2(atan2, INFINITY, ldexp(z,e), (double)pi/2, FE_INEXACT);
+		test2(atan2, INFINITY, ldexp(-z,e), (double)pi/2, FE_INEXACT);
+		test2(atan2, -INFINITY, ldexp(z,e), (double)-pi/2,FE_INEXACT);
+		test2(atan2, -INFINITY, ldexp(-z,e),(double)-pi/2,FE_INEXACT);
+	}
+	for (e = LDBL_MIN_EXP - LDBL_MANT_DIG; e <= LDBL_MAX_EXP - 1; e++) {
+		test2(atan2l, ldexpl(z, e), INFINITY, 0.0, 0);
+		test2(atan2l, ldexpl(-z,e), INFINITY, -0.0, 0);
+		test2(atan2l, ldexpl(z, e), -INFINITY, pi, FE_INEXACT);
+		test2(atan2l, ldexpl(-z,e), -INFINITY, -pi, FE_INEXACT);
+		test2(atan2l, INFINITY, ldexpl(z, e), pi / 2, FE_INEXACT);
+		test2(atan2l, INFINITY, ldexpl(-z, e), pi / 2, FE_INEXACT);
+		test2(atan2l, -INFINITY, ldexpl(z, e), -pi / 2, FE_INEXACT);
+		test2(atan2l, -INFINITY, ldexpl(-z, e), -pi / 2, FE_INEXACT);
+	}
+}
+
+/*
+ * Test various inputs to asin(), acos() and atan() and verify that the
+ * results are accurate to within 1 ulp.
+ */
+static void
+test_accuracy(void)
+{
+
+	/* We expect correctly rounded results for these basic cases. */
+	testall(asin, 1.0, pi / 2, FE_INEXACT);
+	testall(acos, 1.0, 0, 0);
+	testall(atan, 1.0, pi / 4, FE_INEXACT);
+	testall(asin, -1.0, -pi / 2, FE_INEXACT);
+	testall(acos, -1.0, pi, FE_INEXACT);
+	testall(atan, -1.0, -pi / 4, FE_INEXACT);
+
+	/*
+	 * Here we expect answers to be within 1 ulp, although inexactness
+	 * in the input, combined with double rounding, could cause larger
+	 * errors.
+	 */
+
+	testall_tol(asin, sqrtl(2) / 2, pi / 4, 1, FE_INEXACT);
+	testall_tol(acos, sqrtl(2) / 2, pi / 4, 1, FE_INEXACT);
+	testall_tol(asin, -sqrtl(2) / 2, -pi / 4, 1, FE_INEXACT);
+	testall_tol(acos, -sqrtl(2) / 2, c3pi / 4, 1, FE_INEXACT);
+
+	testall_tol(asin, sqrtl(3) / 2, pio3, 1, FE_INEXACT);
+	testall_tol(acos, sqrtl(3) / 2, pio3 / 2, 1, FE_INEXACT);
+	testall_tol(atan, sqrtl(3), pio3, 1, FE_INEXACT);
+	testall_tol(asin, -sqrtl(3) / 2, -pio3, 1, FE_INEXACT);
+	testall_tol(acos, -sqrtl(3) / 2, c5pio3 / 2, 1, FE_INEXACT);
+	testall_tol(atan, -sqrtl(3), -pio3, 1, FE_INEXACT);
+
+	testall_tol(atan, sqrt2m1, pi / 8, 1, FE_INEXACT);
+	testall_tol(atan, -sqrt2m1, -pi / 8, 1, FE_INEXACT);
+}
+
+/*
+ * Test inputs to atan2() where x is a power of 2. These are easy cases
+ * because y/x is exact.
+ */
+static void
+test_p2x_atan2(void)
+{
+
+	testall2(atan2, 1.0, 1.0, pi / 4, FE_INEXACT);
+	testall2(atan2, 1.0, -1.0, c3pi / 4, FE_INEXACT);
+	testall2(atan2, -1.0, 1.0, -pi / 4, FE_INEXACT);
+	testall2(atan2, -1.0, -1.0, -c3pi / 4, FE_INEXACT);
+
+	testall2_tol(atan2, sqrt2m1 * 2, 2.0, pi / 8, 1, FE_INEXACT);
+	testall2_tol(atan2, sqrt2m1 * 2, -2.0, c7pi / 8, 1, FE_INEXACT);
+	testall2_tol(atan2, -sqrt2m1 * 2, 2.0, -pi / 8, 1, FE_INEXACT);
+	testall2_tol(atan2, -sqrt2m1 * 2, -2.0, -c7pi / 8, 1, FE_INEXACT);
+
+	testall2_tol(atan2, sqrtl(3) * 0.5, 0.5, pio3, 1, FE_INEXACT);
+	testall2_tol(atan2, sqrtl(3) * 0.5, -0.5, pio3 * 2, 1, FE_INEXACT);
+	testall2_tol(atan2, -sqrtl(3) * 0.5, 0.5, -pio3, 1, FE_INEXACT);
+	testall2_tol(atan2, -sqrtl(3) * 0.5, -0.5, -pio3 * 2, 1, FE_INEXACT);
+}
+
+/*
+ * Test inputs very close to 0.
+ */
+static void
+test_tiny(void)
+{
+	float tiny = 0x1.23456p-120f;
+
+	testall(asin, tiny, tiny, FE_INEXACT);
+	testall(acos, tiny, pi / 2, FE_INEXACT);
+	testall(atan, tiny, tiny, FE_INEXACT);
+
+	testall(asin, -tiny, -tiny, FE_INEXACT);
+	testall(acos, -tiny, pi / 2, FE_INEXACT);
+	testall(atan, -tiny, -tiny, FE_INEXACT);
+
+	/* Test inputs to atan2() that would cause y/x to underflow. */
+	test2(atan2f, 0x1.0p-100, 0x1.0p100, 0.0, FE_INEXACT | FE_UNDERFLOW);
+	test2(atan2, 0x1.0p-1000, 0x1.0p1000, 0.0, FE_INEXACT | FE_UNDERFLOW);
+	test2(atan2l, ldexpl(1.0, 100 - LDBL_MAX_EXP),
+	      ldexpl(1.0, LDBL_MAX_EXP - 100), 0.0, FE_INEXACT | FE_UNDERFLOW);
+	test2(atan2f, -0x1.0p-100, 0x1.0p100, -0.0, FE_INEXACT | FE_UNDERFLOW);
+	test2(atan2, -0x1.0p-1000, 0x1.0p1000, -0.0, FE_INEXACT | FE_UNDERFLOW);
+	test2(atan2l, -ldexpl(1.0, 100 - LDBL_MAX_EXP),
+	      ldexpl(1.0, LDBL_MAX_EXP - 100), -0.0, FE_INEXACT | FE_UNDERFLOW);
+	test2(atan2f, 0x1.0p-100, -0x1.0p100, (float)pi, FE_INEXACT);
+	test2(atan2, 0x1.0p-1000, -0x1.0p1000, (double)pi, FE_INEXACT);
+	test2(atan2l, ldexpl(1.0, 100 - LDBL_MAX_EXP),
+	      -ldexpl(1.0, LDBL_MAX_EXP - 100), pi, FE_INEXACT);
+	test2(atan2f, -0x1.0p-100, -0x1.0p100, (float)-pi, FE_INEXACT);
+	test2(atan2, -0x1.0p-1000, -0x1.0p1000, (double)-pi, FE_INEXACT);
+	test2(atan2l, -ldexpl(1.0, 100 - LDBL_MAX_EXP),
+	      -ldexpl(1.0, LDBL_MAX_EXP - 100), -pi, FE_INEXACT);
+}
+
+/*
+ * Test very large inputs to atan().
+ */
+static void
+test_atan_huge(void)
+{
+	float huge = 0x1.23456p120;
+
+	testall(atan, huge, pi / 2, FE_INEXACT);
+	testall(atan, -huge, -pi / 2, FE_INEXACT);
+
+	/* Test inputs to atan2() that would cause y/x to overflow. */
+	test2(atan2f, 0x1.0p100, 0x1.0p-100, (float)pi / 2, FE_INEXACT);
+	test2(atan2, 0x1.0p1000, 0x1.0p-1000, (double)pi / 2, FE_INEXACT);
+	test2(atan2l, ldexpl(1.0, LDBL_MAX_EXP - 100),
+	      ldexpl(1.0, 100 - LDBL_MAX_EXP), pi / 2, FE_INEXACT);
+	test2(atan2f, -0x1.0p100, 0x1.0p-100, (float)-pi / 2, FE_INEXACT);
+	test2(atan2, -0x1.0p1000, 0x1.0p-1000, (double)-pi / 2, FE_INEXACT);
+	test2(atan2l, -ldexpl(1.0, LDBL_MAX_EXP - 100),
+	      ldexpl(1.0, 100 - LDBL_MAX_EXP), -pi / 2, FE_INEXACT);
+
+	test2(atan2f, 0x1.0p100, -0x1.0p-100, (float)pi / 2, FE_INEXACT);
+	test2(atan2, 0x1.0p1000, -0x1.0p-1000, (double)pi / 2, FE_INEXACT);
+	test2(atan2l, ldexpl(1.0, LDBL_MAX_EXP - 100),
+	      -ldexpl(1.0, 100 - LDBL_MAX_EXP), pi / 2, FE_INEXACT);
+	test2(atan2f, -0x1.0p100, -0x1.0p-100, (float)-pi / 2, FE_INEXACT);
+	test2(atan2, -0x1.0p1000, -0x1.0p-1000, (double)-pi / 2, FE_INEXACT);
+	test2(atan2l, -ldexpl(1.0, LDBL_MAX_EXP - 100),
+	      -ldexpl(1.0, 100 - LDBL_MAX_EXP), -pi / 2, FE_INEXACT);
+}
+
+/*
+ * Test that sin(asin(x)) == x, and similarly for acos() and atan().
+ * You need to have a working sinl(), cosl(), and tanl() for these
+ * tests to pass.
+ */
+static long double
+sinasinf(float x)
+{
+
+	return (sinl(asinf(x)));
+}
+
+static long double
+sinasin(double x)
+{
+
+	return (sinl(asin(x)));
+}
+
+static long double
+sinasinl(long double x)
+{
+
+	return (sinl(asinl(x)));
+}
+
+static long double
+cosacosf(float x)
+{
+
+	return (cosl(acosf(x)));
+}
+
+static long double
+cosacos(double x)
+{
+
+	return (cosl(acos(x)));
+}
+
+static long double
+cosacosl(long double x)
+{
+
+	return (cosl(acosl(x)));
+}
+
+static long double
+tanatanf(float x)
+{
+
+	return (tanl(atanf(x)));
+}
+
+static long double
+tanatan(double x)
+{
+
+	return (tanl(atan(x)));
+}
+
+static long double
+tanatanl(long double x)
+{
+
+	return (tanl(atanl(x)));
+}
+
+static void
+test_inverse(void)
+{
+	float i;
+
+	for (i = -1; i <= 1; i += 0x1.0p-12f) {
+		testall_tol(sinasin, i, i, 2, i == 0 ? 0 : FE_INEXACT);
+		/* The relative error for cosacos is very large near x=0. */
+		if (fabsf(i) > 0x1.0p-4f)
+			testall_tol(cosacos, i, i, 16, i == 1 ? 0 : FE_INEXACT);
+		testall_tol(tanatan, i, i, 2, i == 0 ? 0 : FE_INEXACT);
+	}
+}
+
+int
+main(int argc, char *argv[])
+{
+
+#if defined(__i386__)
+	printf("1..0 # SKIP fails all assertions on i386\n");
+	return (0);
+#endif
+
+	printf("1..7\n");
+
+	test_special();
+	printf("ok 1 - special\n");
+
+	test_special_atan2();
+	printf("ok 2 - atan2 special\n");
+
+	test_accuracy();
+	printf("ok 3 - accuracy\n");
+
+	test_p2x_atan2();
+	printf("ok 4 - atan2 p2x\n");
+
+	test_tiny();
+	printf("ok 5 - tiny inputs\n");
+
+	test_atan_huge();
+	printf("ok 6 - atan huge inputs\n");
+
+	test_inverse();
+	printf("ok 7 - inverse\n");
+
+	return (0);
+}
diff --git a/lib/msun/tests/lround_test.c b/lib/msun/tests/lround_test.c
new file mode 100644
index 0000000..2a37367
--- /dev/null
+++ b/lib/msun/tests/lround_test.c
@@ -0,0 +1,115 @@
+/*-
+ * Copyright (c) 2005 David Schultz <das@FreeBSD.org>
+ * All rights reserved.
+ *
+ * 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 AUTHOR 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 AUTHOR 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 for lround(), lroundf(), llround(), and llroundf().
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <assert.h>
+#include <fenv.h>
+#include <limits.h>
+#include <math.h>
+#include <stdio.h>
+
+/*
+ * XXX The volatile here is to avoid gcc's bogus constant folding and work
+ *     around the lack of support for the FENV_ACCESS pragma.
+ */
+#define	test(func, x, result, excepts)	do {				\
+	volatile double _d = x;						\
+	assert(feclearexcept(FE_ALL_EXCEPT) == 0);			\
+	assert((func)(_d) == (result) || fetestexcept(FE_INVALID));	\
+	assert(fetestexcept(FE_ALL_EXCEPT) == (excepts));		\
+} while (0)
+
+#define	testall(x, result, excepts)	do {				\
+	test(lround, x, result, excepts);				\
+	test(lroundf, x, result, excepts);				\
+	test(llround, x, result, excepts);				\
+	test(llroundf, x, result, excepts);				\
+} while (0)
+
+#define	IGNORE	0
+
+#pragma STDC FENV_ACCESS ON
+
+int
+main(int argc, char *argv[])
+{
+
+	printf("1..1\n");
+
+	testall(0.0, 0, 0);
+	testall(0.25, 0, FE_INEXACT);
+	testall(0.5, 1, FE_INEXACT);
+	testall(-0.5, -1, FE_INEXACT);
+	testall(1.0, 1, 0);
+	testall(0x12345000p0, 0x12345000, 0);
+	testall(0x1234.fp0, 0x1235, FE_INEXACT);
+	testall(INFINITY, IGNORE, FE_INVALID);
+	testall(NAN, IGNORE, FE_INVALID);
+
+#if (LONG_MAX == 0x7fffffffl)
+	test(lround, 0x7fffffff.8p0, IGNORE, FE_INVALID);
+	test(lround, -0x80000000.8p0, IGNORE, FE_INVALID);
+	test(lround, 0x80000000.0p0, IGNORE, FE_INVALID);
+	test(lround, 0x7fffffff.4p0, 0x7fffffffl, FE_INEXACT);
+	test(lround, -0x80000000.4p0, -0x80000000l, FE_INEXACT);
+	test(lroundf, 0x80000000.0p0f, IGNORE, FE_INVALID);
+	test(lroundf, 0x7fffff80.0p0f, 0x7fffff80l, 0);
+#elif (LONG_MAX == 0x7fffffffffffffffll)
+	test(lround, 0x8000000000000000.0p0, IGNORE, FE_INVALID);
+	test(lroundf, 0x8000000000000000.0p0f, IGNORE, FE_INVALID);
+	test(lround, 0x7ffffffffffffc00.0p0, 0x7ffffffffffffc00l, 0);
+	test(lroundf, 0x7fffff8000000000.0p0f, 0x7fffff8000000000l, 0);
+	test(lround, -0x8000000000000800.0p0, IGNORE, FE_INVALID);
+	test(lroundf, -0x8000010000000000.0p0f, IGNORE, FE_INVALID);
+	test(lround, -0x8000000000000000.0p0, -0x8000000000000000l, 0);
+	test(lroundf, -0x8000000000000000.0p0f, -0x8000000000000000l, 0);
+#else
+#error "Unsupported long size"
+#endif
+
+#if (LLONG_MAX == 0x7fffffffffffffffLL)
+	test(llround, 0x8000000000000000.0p0, IGNORE, FE_INVALID);
+	test(llroundf, 0x8000000000000000.0p0f, IGNORE, FE_INVALID);
+	test(llround, 0x7ffffffffffffc00.0p0, 0x7ffffffffffffc00ll, 0);
+	test(llroundf, 0x7fffff8000000000.0p0f, 0x7fffff8000000000ll, 0);
+	test(llround, -0x8000000000000800.0p0, IGNORE, FE_INVALID);
+	test(llroundf, -0x8000010000000000.0p0f, IGNORE, FE_INVALID);
+	test(llround, -0x8000000000000000.0p0, -0x8000000000000000ll, 0);
+	test(llroundf, -0x8000000000000000.0p0f, -0x8000000000000000ll, 0);
+#else
+#error "Unsupported long long size"
+#endif
+
+	printf("ok 1 - lround\n");
+
+	return (0);
+}
diff --git a/lib/msun/tests/lround_test.t b/lib/msun/tests/lround_test.t
new file mode 100644
index 0000000..8bdfd03
--- /dev/null
+++ b/lib/msun/tests/lround_test.t
@@ -0,0 +1,10 @@
+#!/bin/sh
+# $FreeBSD$
+
+cd `dirname $0`
+
+executable=`basename $0 .t`
+
+make $executable 2>&1 > /dev/null
+
+exec ./$executable
diff --git a/lib/msun/tests/test-utils.h b/lib/msun/tests/test-utils.h
new file mode 100644
index 0000000..bf0d6de
--- /dev/null
+++ b/lib/msun/tests/test-utils.h
@@ -0,0 +1,174 @@
+/*-
+ * Copyright (c) 2005-2013 David Schultz <das@FreeBSD.org>
+ * All rights reserved.
+ *
+ * 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 AUTHOR 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 AUTHOR 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.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef	_TEST_UTILS_H_
+#define	_TEST_UTILS_H_
+
+#include <complex.h>
+#include <fenv.h>
+
+/*
+ * Implementations are permitted to define additional exception flags
+ * not specified in the standard, so it is not necessarily true that
+ * FE_ALL_EXCEPT == ALL_STD_EXCEPT.
+ */
+#define	ALL_STD_EXCEPT	(FE_DIVBYZERO | FE_INEXACT | FE_INVALID | \
+			 FE_OVERFLOW | FE_UNDERFLOW)
+#define	OPT_INVALID	(ALL_STD_EXCEPT & ~FE_INVALID)
+#define	OPT_INEXACT	(ALL_STD_EXCEPT & ~FE_INEXACT)
+#define	FLT_ULP()	ldexpl(1.0, 1 - FLT_MANT_DIG)
+#define	DBL_ULP()	ldexpl(1.0, 1 - DBL_MANT_DIG)
+#define	LDBL_ULP()	ldexpl(1.0, 1 - LDBL_MANT_DIG)
+
+/*
+ * Flags that control the behavior of various fpequal* functions.
+ * XXX This is messy due to merging various notions of "close enough"
+ * that are best suited for different functions.
+ *
+ * CS_REAL
+ * CS_IMAG
+ * CS_BOTH
+ *   (cfpequal_cs, fpequal_tol, cfpequal_tol) Whether to check the sign of
+ *   the real part of the result, the imaginary part, or both.
+ *
+ * FPE_ABS_ZERO
+ *   (fpequal_tol, cfpequal_tol) If set, treats the tolerance as an absolute
+ *   tolerance when the expected value is 0.  This is useful when there is
+ *   round-off error in the input, e.g., cos(Pi/2) ~= 0.
+ */
+#define	CS_REAL		0x01
+#define	CS_IMAG		0x02
+#define	CS_BOTH		(CS_REAL | CS_IMAG)
+#define	FPE_ABS_ZERO	0x04
+
+#ifdef	DEBUG
+#define	debug(...)	printf(__VA_ARGS__)
+#else
+#define	debug(...)	(void)0
+#endif
+
+/*
+ * XXX The ancient version of gcc in the base system doesn't support CMPLXL,
+ * but we can fake it most of the time.
+ */
+#ifndef CMPLXL
+static inline long double complex
+CMPLXL(long double x, long double y)
+{
+	long double complex z;
+
+	__real__ z = x;
+	__imag__ z = y;
+	return (z);
+}
+#endif
+
+/*
+ * Compare d1 and d2 using special rules: NaN == NaN and +0 != -0.
+ * Fail an assertion if they differ.
+ */
+static int
+fpequal(long double d1, long double d2)
+{
+
+	if (d1 != d2)
+		return (isnan(d1) && isnan(d2));
+	return (copysignl(1.0, d1) == copysignl(1.0, d2));
+}
+
+/*
+ * Determine whether x and y are equal, with two special rules:
+ *	+0.0 != -0.0
+ *	 NaN == NaN
+ * If checksign is 0, we compare the absolute values instead.
+ */
+static int
+fpequal_cs(long double x, long double y, int checksign)
+{
+	if (isnan(x) && isnan(y))
+		return (1);
+	if (checksign)
+		return (x == y && !signbit(x) == !signbit(y));
+	else
+		return (fabsl(x) == fabsl(y));
+}
+
+static int
+fpequal_tol(long double x, long double y, long double tol, unsigned int flags)
+{
+	fenv_t env;
+	int ret;
+
+	if (isnan(x) && isnan(y))
+		return (1);
+	if (!signbit(x) != !signbit(y) && (flags & CS_BOTH))
+		return (0);
+	if (x == y)
+		return (1);
+	if (tol == 0)
+		return (0);
+
+	/* Hard case: need to check the tolerance. */
+	feholdexcept(&env);
+	/*
+	 * For our purposes here, if y=0, we interpret tol as an absolute
+	 * tolerance. This is to account for roundoff in the input, e.g.,
+	 * cos(Pi/2) ~= 0.
+	 */
+	if ((flags & FPE_ABS_ZERO) && y == 0.0)
+		ret = fabsl(x - y) <= fabsl(tol);
+	else
+		ret = fabsl(x - y) <= fabsl(y * tol);
+	fesetenv(&env);
+	return (ret);
+}
+
+static int
+cfpequal(long double complex d1, long double complex d2)
+{
+
+	return (fpequal(creall(d1), creall(d2)) &&
+		fpequal(cimagl(d1), cimagl(d2)));
+}
+
+static int
+cfpequal_cs(long double complex x, long double complex y, int checksign)
+{
+	return (fpequal_cs(creal(x), creal(y), checksign)
+		&& fpequal_cs(cimag(x), cimag(y), checksign));
+}
+
+static int
+cfpequal_tol(long double complex x, long double complex y, long double tol,
+		     unsigned int flags)
+{
+	return (fpequal_tol(creal(x), creal(y), tol, flags)
+		&& fpequal_tol(cimag(x), cimag(y), tol, flags));
+}
+
+#endif /* _TEST_UTILS_H_ */